Construcción de Software II Guía 13 – Excepciones en JAVA Guía 13 – Excepciones en JAVA Construcción de Software II

86 79
Resumen Manejo de Excepciones en JAVA
try { Introducción
//Este código puede generar una excepción Los errores posibles en Java se gestionan como excepciones por el
} programador.
catch(Exception ex) { Control de errores por excepciones
//Este código se ejecuta cuando se produce una excepción En Java las situaciones que pueden provocar un fallo en el programa se
} denominan excepciones.
Finally { Las excepciones en Java son objetos de clases derivadas de la clase base
//Este código se ejecuta se produzca o no una excepción Exception.
} Las clases Error y Exception son clases derivadas de la clase base Throwable.

NOTAS DE CLASE Error

Throwable
Exception

Excepciones
Las excepciones son en cierto sentido errores que se pueden definir y
gestionar.
Las clases Exception y Error son las únicas subclases de Throwable (parece ser
que Error contiene errores que no se pueden gestionar porque son demasiado
drásticos).
Hay varias subclases ya definidas de Exception , la que contiene  errores  más
irrecuperables es RuntimeException , entre cuyas subclases están:

Nombre Descripción
ArithmeticException Error aritmético, por ejemplo división por un entero
nulo
ArrayStoreException Tipo erróneo en una matriz
IllegalArgumentException Argumento ilegal en un método
IndexOutOfBoundsException Índice fuera de rango en una matriz
NegativeArraySizeException Número negativo de términos de una matriz
NullPointerException Hay una referencia con un puntero nulo (es raro que
ocurra)

La forma de gestionar una excepción responde al siguiente esquema:

try{
/* Código en el que puede surgir una excepción */ }
catch(subclase_de_excepción Nombre){
/* Gestión del error */ }
El argumento de catch lo que hace es crear el objeto Nombre del tipo indicado por
la subclase de la excepción. Se pueden tratar  varias excepciones escribiendo
varios bloques catch .

dariolara@hotmail.com dariolara@hotmail.com
Construcción de Software II Guía 13 – Excepciones en JAVA Guía 13 – Excepciones en JAVA Construcción de Software II
80 85
A veces se añade después de lo anterior finally{...} donde las instrucciones entre Excepciones con vectores
llaves se ejecutan siempre después. Sirve por ejemplo para cerrar archivos que Practica 67
puedan haber quedado abiertos.   public class excepcionEnVectores {
public static void main(String[] args) {
Practica 63 int a=0;
El siguiente programa genera y trata excepciones. int [] vector=new int[3];
Según se quiten   las barras de comentarios, //, se generarán diferentes Object x[] = new String[3];
excepciones. Al final siempre se imprimirá "Termino". Try {
public class Proto{ // a=1/a;
    public static void main(String[] args){ // a=7; a=vector[a];
        int a=0; int [] matriz=new int[3]; // a=-7;
        Object x[] = new String[3]; int [ ] vector2=new int[a];
        try{ // x[0] = new Integer(0);
            // a=1/a; }
            // a=7; a=matriz[a]; catch(ArithmeticException e) {
            //a=-7; int [] matriz2=new int[a]; System.out.println("Operación imposible");
             // x[0] = new Integer(0); }
        } catch(ArrayIndexOutOfBoundsException e) {
        catch(ArithmeticException e){ System.out.println("Elemento de vector inexistente");
            System.out.println("Operación imposible"); }
        } catch(NegativeArraySizeException e) {
        catch(ArrayIndexOutOfBoundsException e){ System.out.println("Vector de tamaño negativo");
            System.out.println("Elemento de matriz inexistente"); }
        } catch(ArrayStoreException e) {
        catch(NegativeArraySizeException e){ System.out.println("Error en tipo de elementos del vector");
            System.out.println("Matriz de tamaño negativo"); }
        } Finally {
        catch(ArrayStoreException e){ System.out.println("Se acabó");
            System.out.println("Error en tipo de elementos de la matriz"); }
        } }
        finally{ }
            System.out.println("Termino");    } } }
La misma metodología de excepciones aplicada a vectores funciona con matrices
Los métodos de la clase Throwable son: y en general con todo tipo de arreglos

getMessage() , toString() , getLocalizedMessage() , y e.printStackTrace() .

No parece haber grandes diferencias entre los tres primeros, que generan una
cadena de caracteres con la descripción de la excepción.

El último imprime en pantalla una descripción más detallada.  

dariolara@hotmail.com dariolara@hotmail.com
Construcción de Software II Guía 13 – Excepciones en JAVA Guía 13 – Excepciones en JAVA Construcción de Software II
84 81
Jerarquía de las excepciones Practica 64
Las excepciones pertenecen a la jerarquía de clases siguiente: Clase prototipo
A la derecha se muestra la salida del siguiente programa:

java.lang.Object public class prototipo{

| +--java.lang.Throwable     public static void main(String[] args){ Operación imposible
| +--java.lang.Exception         int a=0; String mensaje; Con getMessage--> / by zero
| +--java.lang.RuntimeException         try{ Con toString-->
ArithmeticException,             a=1/a; java.lang.ArithmeticException: /
ArrayStoreException,         } by zero
CannotRedoException,         catch(ArithmeticException e){ Con getLocalizedMessage--> / by
CannotUndoException,             System.out.println("Operación imposible"); zero
ClassCastException,         mensaje=e.getMessage(); java.lang.ArithmeticException: /
CMMException,             System.out.println("Con getMessage " + by zero
ConcurrentModificationException, mensaje);         at Proto.main(Proto.java:5)
EmptyStackException,             mensaje=e.toString();
IllegalArgumentException,         System.out.println("Con toString " +
IllegalMonitorStateException, mensaje);
IllegalPathStateException,             mensaje = e.getLocalizedMessage();
IllegalStateException, System.out.println("CongetLocalizedMessage"
ImagingOpException, + mensaje);
IndexOutOfBoundsException,             e.printStackTrace();
MissingResourceException,         }    
NegativeArraySizeException, }
NoSuchElementException, }
NullPointerException,
NumberFormatException, La forma más simple de definir una nueva excepción responde a la plantilla:
ProfileDataException, class NuevaExcepcion extends Exception{
ProviderException,     NuevaExcepcion(){
RasterFormatException,         super("Mensaje de la excepción");  
SecurityException, }
SystemException, }
UndeclaredThrowableException,
UnsupportedOperationException Practica 65
En la definición de una excepción puede haber varios métodos que den más
información acerca del error o que actúen de cualquier forma. Por ejemplo

  public class Proto{

    public static void main(String[] args){
    for(int i=10; i<21; i++){
        System.out.println("número "+i);

dariolara@hotmail.com dariolara@hotmail.com
Construcción de Software II Guía 13 – Excepciones en JAVA Guía 13 – Excepciones en JAVA Construcción de Software II
82 83
try {
try{ class NuevaExcepcion número 10 numero=Integer.parseInt(str); }
            valido(i); extends Exception{ número 11 catch(NumberFormatException ex) {
        }     NuevaExcepcion(){ número 12 System.out.println("El dato ingresado no es un número"); }
        catch(NuevaExcepcion e){         super("\tNúmero feo. número 13
            "); Número feo. Practica 66
System.out.println(e.getMessage()     } ¡Es el 13! Lanzar una excepción
+e.MasInfo(i)); número 14 Archivo ejemploDeExcepcion.java
        }     String MasInfo(int n){ número 15 public class ejemploDeExcepcion {
    }         if(n==13) return "¡Es número 16 public static void main(String[] args) {
    } el 13!"; número 17 String str1="12";
        else return "No me número 18 String str2="0";
    public static void valido(int n) gusta"; número 19 String respuesta;
throws NuevaExcepcion{     }         Número int numerador, denominador, cociente;
        if((247%n)==0) } feo. No me try {
            throw new NuevaExcepcion(); gusta numerador=Integer.parseInt(str1);
} } número 20 denominador=Integer.parseInt(str2);
cociente=numerador/denominador;
Clases derivadas de Exception respuesta=String.valueOf(cociente); }
Estas clases derivadas se ubican en dos grupos principales: catch(NumberFormatException ex) {
Las excepciones en tiempo de ejecución respuesta="Hay caracteres no numéricos"; }
Si se sobrepasa la dimensión de un arreglo (Array) se lanza una excepción: catch(ArithmeticException ex) {
ArrayIndexOutOfBounds. respuesta="División por cero"; }
Cuando se hace uso de una referencia a un objeto que no ha sido creado se System.out.println(respuesta);
lanza la excepción: NullPointerException. }
Las excepciones “errores” }
El segundo grupo indican que ha sucedido algo inesperado o fuera de control. Notas
Con la clase String se puede convertir un string en un numero mediante Como vemos las sentencias susceptibles de lanzar una excepción se sitúan en un
Integer.parseInt bloque try...catch. Si el denominador es cero, se produce una excepción de la clase
String str=" 12 "; ArithmeticException en la expresión que halla el cociente, que es inmediatamente
int numero=Integer.parseInt(str); capturada en el bloque catch que maneja dicha excepción, ejecutándose las
Sentencias try .... catch .... finally sentencias que hay en dicho bloque. En este caso se guarda en el string respuesta el
Si se introducen caracteres no numéricos, o no se quitan los espacios en texto "División entre cero".
blanco al principio y al final del string, mediante la función trim, se lanza una
excepción NumberFormatException. Sentencia finally
…… Hay veces en las que se desea estar seguro de que un bloque de código se ejecute
public static void main(String[] args) { se produzcan o no excepciones. Se puede hacer esto añadiendo un bloque finally
String str; después del último catch. Esto es importante cuando accedemos a archivos, para
str.length(); asegurar que se cerrará siempre un archivo se produzca o no un error en el
//... } proceso.
// variable str no ha sido inicializada
String str=" 12 ";
int numero;

dariolara@hotmail.com dariolara@hotmail.com