Manejo de excepciones
"El manejo de excepciones es una estructura de control de los lenguajes de programacion diseñada para manejar condiciones anormales que pueden ser tratadas por el mismo programa que se desarrolla.
Por ejemplo, un programa puede admitir cierto número de errores en el formato de los datos y continuar su proceso para producir el mejor resultado posible en lugar de producir una salida aparatosa llena de mensajes de error probablemente incomprensibles para el usuario. Muchas veces la acción asociada a una excepción es simplemente producir un mensaje informativo y terminar, otras veces, es sólo indicación de la necesidad de un cambio en la estrategia de resolución del problema.
Algunos lenguajes de programación, por ejemplo Lips Ada, C++, C#, Delphi, Objective C , JAVA incluyen soporte para el manejo de excepciones. En esos lenguajes, al producirse una excepción se desciende en la pila de ejecución hasta encontrar un manejador para la excepción, el cual toma el control en ese momento".[1]
COMO MANEJAR EXCEPCIONES EN JAVA
"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( ActionEventevento ) { 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
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 ( Exceptionexcepcion )
{ 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"
[2]
BIBLIOGRAFIA
No hay comentarios:
Publicar un comentario