En esta sección se exponen ejemplos en Java acerca del manejo de excepciones, un tema importante en la construcción de aplicaciones de "misión crítica" o de "comercio crítico". Para utilizar un componente de Java, es necesario saber no sólo la manera como se comporta ese componente cuando "las cosas salen bien", sino también cuando "las cosas salen mal". En esta sección se introducen instrucciones imprescindibles en el manejo de excepciones (try, catch, finally).

Un ejemplo de manejo de excepciones que comprueba la división entre cero

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class PruebaDivisionEntreCero extends JFrame implements ActionListener
{

   private JTextField campoEntrada1, campoEntrada2, campoSalida;
   private int numero1, numero2, resultado;

   // configurar GUI
   public PruebaDivisionEntreCero()
   {
      super( "Demostración de las excepciones" );

      // obtener panel de contenido y establecer su esquema
      Container contenedor = getContentPane();
      contenedor.setLayout( new GridLayout( 3, 2 ) );

      // establecer etiqueta y campoEntrada1
      contenedor.add(
         new JLabel( "Escriba el numerador ", SwingConstants.RIGHT ) );
      campoEntrada1 = new JTextField();
      contenedor.add( campoEntrada1 );

      // establecer etiqueta y campoEntrada2; registrar componente de escucha
      contenedor.add( new JLabel( "Escriba el denominador y oprima Intro ",
         SwingConstants.RIGHT ) );
      campoEntrada2 = new JTextField();
      contenedor.add( campoEntrada2 );
      campoEntrada2.addActionListener( this );

      // establecer etiqueta y campoSalida
      contenedor.add( new JLabel( "RESULTADO ", SwingConstants.RIGHT ) );
      campoSalida = new JTextField();
      contenedor.add( campoSalida );

      setSize( 475, 100 );
      setVisible( true );

   } // fin del constructor de PruebaDivisionEntreCero

   // procesar eventos de GUI
   public void actionPerformed( ActionEvent evento )
   {
      campoSalida.setText( "" );   // borrar campoSalida

      // leer dos números y calcular el cociente
      try {
         numero1 = Integer.parseInt( campoEntrada1.getText() );
         numero2 = Integer.parseInt( campoEntrada2.getText() );

         resultado = cociente( numero1, numero2 );
         campoSalida.setText( String.valueOf( resultado ) );
      }

      // procesar la entrada con formato incorrecto
      catch ( NumberFormatException excepcionFormatoNumero ) {
         JOptionPane.showMessageDialog( this,
            "Debe escribir dos enteros", "Formato de número inválido",
            JOptionPane.ERROR_MESSAGE );
      }

      // procesar los intentos de dividir entre cero
      catch ( ArithmeticException excepcionAritmetica ) {
         JOptionPane.showMessageDialog( this,
            excepcionAritmetica.toString(), "Excepción aritmética",
            JOptionPane.ERROR_MESSAGE );
      }

   } // fin del método actionPerformed

   // demuestra cómo lanzar una excepción cuando ocurre una división entre cero
   public int cociente( int numerador, int denominador )
      throws ArithmeticException
   {
      return numerador / denominador;
   }

   public static void main( String args[] )
   {
      JFrame.setDefaultLookAndFeelDecorated(true);
      JDialog.setDefaultLookAndFeelDecorated(true);
      PruebaDivisionEntreCero aplicacion = new PruebaDivisionEntreCero();
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   }

} // fin de la clase PruebaDivisionEntreCero

Descargar código fuente

Demostración del mecanismo try-catch-finally para manejar excepciones.

public class UsoExcepciones {

   public static void main( String args[] )
   {
      try {
         lanzarExcepcion(); // llamar al método lanzarExcepcion
      }

      // atrapar excepciones lanzadas por el método lanzarExcepcion
      catch ( Exception excepcion ) {
         System.err.println( "La excepcion se manejo en main" );
      }

      noLanzaExcepcion();
   }

   // demostrar try/catch/finally
   public static void lanzarExcepcion() throws Exception
   {
      // lanzar una excepción y atraparla inmediatamente
      try {
         System.out.println( "El metodo lanzarExcepcion" );
         throw new Exception();  // generar excepción
      }

      // atrapar la excepción lanzada en el bloque try
      catch ( Exception excepcion ) {
         System.err.println(
            "La excepcion se manejo en el metodo lanzarExcepcion" );
         throw excepcion;  // volver a lanzar para procesarla posteriormente

         // cualquier código aquí no llegaría a ejecutarse
      }

      // este bloque se ejecuta, sin importar lo que ocurra en try/catch
      finally {
         System.err.println( "Finalmente se ejecuto en lanzarExcepcion" );
      }

      // cualquier código aquí no llegaría a ejecutarse

   } // fin del método lanzarExcepcion

   // demostrar finally cuando no ocurre excepción
   public static void noLanzaExcepcion()
   {
      // el bloque try no lanza una excepción
      try {
         System.out.println( "El metodo noLanzaExcepcion" );
      }

      // catch no se ejecuta, porque no se lanzó una excepción
      catch( Exception excepcion ) {
         System.err.println( excepcion );
      }

      // la cláusula this se ejecuta, sin importar lo que ocurra en try/catch
      finally {
         System.err.println(
            "Finalmente se ejecuto en noLanzaExcepcion" );
      }

      System.out.println( "Fin del metodo noLanzaExcepcion" );

   } // fin del método noLanzaExcepcion

} // fin de la clase UsoExcepciones

#java UsoExcepciones
El metodo lanzarExcepcion
La excepcion se manejo en el metodo lanzarExcepcion
Finalmente se ejecuto en lanzarExcepcion
La excepcion se manejo en main
El metodo noLanzaExcepcion
Finalmente se ejecuto en noLanzaExcepcion
Fin del metodo noLanzaExcepcion

Descargar código fuente