Java Tip 18: Errores y Excepciones

Un error en programación es:

un fallo catastrófico que interrumpirá abruptamente la ejecución del programa

Al programador, ese pseudo dios autoproclamado, solo le quedará observar, como un espectador pasivo, el hecho de que el fruto de su esfuerzo termina sin lograr el objetivo por el cual fue creado. No hay nada que hacer, solo suplicar que el suplicio acabe pronto.

Errores es el StackOverflowError, que ocurre cuando hay un desborde de pila (usualmente por un ciclo infinito).

Un excepción por su parte es:

un fallo previsto con antelación que no necesariamente terminará la ejecución del programa

Este puede ser:

Un bloque de código que al ejecutarse tiene la previsión de anticiparse a un probable error. Como lo puede ser la entrada de un tipo String cuando nosotros solicitamos un tipo Integer para realizar alguna operación. Un tipo null cuando lo que queremos es que al menos tenga un valor que procesar. Entre otros más complejos.

Hay dos tipos de Excepciones en Java:

1. Excepciones marcadas: todas las que ocurren en tiempo de compilación y que son obligatorias, excepto las RuntimeException. IOException, SQLException,ClassNotFoundException,etc. son algunas de éstas.
2. Excepciones no marcadas: las que ocurren en tiempo de ejecución, como las RuntimeException. ClassCastException, IllegalArgumentException, NumberFormatException, ArithmeticException, NullPointerException, etc. son algunas de éstas.

Todas las Excepciones son hijas de la clase Throwable y heredearán sus propiedades y métodos.

Ejemplo. División por cero.

 try{
      int division = 4/0;
    }catch(ArithmeticException | NumberFormatException ae){
      System.err.println("Division por cero: ArithmeticException o el formato del número no es correcto:  NumberFormatException!");
    }catch(Exception ex){
      ex.printStackTrace();
    }//Salida: Division por cero: ArithmeticException
 

Como se puede apreciar el programador debe colocar la excepciónn más próxima o adecuada a lo que pudiera ocurrir. Es decir, si vas a tratar con números u operaciones aritméticas es preciso especificar la excepción. Puedes usar la excepción ArithmeticException para operaciones ariméticas y NumberFormatException para cuando estes tratando con números. Al final la clase "padre" Exception cachará la exceción si las clases "hijas" no pudieron hacerlo. Es cuestión de jerarquías y orden. No hay mucha ciencia en eso.

Si no cumplimos con esa jerarquía, el código no compilará:

 try{
      int division = 4/0;
    }catch(Exception ex){
      ex.printStackTrace();
    }catch(ArithmeticException | NumberFormatException ae){
      System.err.println("Division por cero: ArithmeticException o el formato del número no es correcto:  NumberFormatException!");
    }

Este bloque de código no es correcto, ya que la excepción a tratar debe ser lo más específica que se pueda. La clase Exception trata todas las excepciones y eso causará un error de compilación.

Ejemplo. Tratar una cadena null.

    String cadena = null;
    try{
      cadena = cadena.toUpperCase();
    }catch(NullPointerException npe){
      System.err.println("Objeto null: NullPointerException");
    }catch(RuntimeException rex){
      rex.printStackTrace();
    }
    catch(Exception ex){
      ex.printStackTrace();
    }

Con el uso de algún IDE como Eclipse es más fácil rastrear los errores y las excepciones. Se puede colocar puntos para debuggear (depurar) el código y ver que es lo que está pasando en el flujo del programa. Continuaremos con este tema en próximos posts.