INSTITUTO TECNOLOGICO DE TEHUACAN

Ingeniería en sistemas computacionales

Curso de apoyo a la titulaciónEXCEPCIONES EN JAVA

Diciembre de 2008

CONTENIDO

• Fundamentos• Tipos de excepción• Excepciones no

capturadas• try y catch• Claúsulas catch

múltiples• Sentencias try

anidadas

• throw• throws• finally

Fundamentos

• Una excepción es una condición anormal que surge en una secuencia de código durante la ejecución.

• La gestión de excepciones de Java lleva la gestión del error en tiempo de ejecución al mundo orientado a objetos. Una excepción de Java es un objeto que describe una condición excepcional que se ha producido en un fragmento de código.

Tipos de excepción

Excepciones no capturadas (1)

• Los objetos de excepción los crea automáticamente el intérprete de Java como respuesta a alguna condición excepcional.

• Como ejemplo tomamos una división por cero.

class Exc0{ public static void main(String args[]){ int d = 0; int a = 42 / d; }}

Excepciones no capturadas (2)

• Cuando el intérprete de Java intenta ejecutar la división, observa que el denominador es cero y construye un nuevo objeto de excepción para que se detenga este código y se trate esta condición de error.

• Una vez detenido el flujo del código en el operador de división, se buscará en la pila de llamadas actual cualquier gestor de excepciones (pila que contiene un registro de las llamadas a método).

Excepciones no capturadas (3)

• Un gestor de excepciones es algo establecido para tratar inmediatamente la condición excepcional.

• Si no codificamos un gestor de excepciones, se ejecutará el gestor en tiempo de ejecución por defecto.

• El gestor por defecto imprime el valor String de la excepción y el trazado de la pila del lugar donde se produjo la excepción.

Excepciones no capturadas (4)

class Exc0 {

public static void main(String args[]) {

int d = 0;

int a= 42 / d;

}

}

c:\> java Exc0

java.lang.ArithmeticException: / by zero

at Exc0.main(Exc0.java:4)

Excepciones no capturadas (5)class Excl { static void subroutine() { int d = 0; int a = l0 / d; } public static void main(String args[]) { Excl.subroutine(); }}

c:\> java Excl

java.lang.ArithmeticException: / by zero

at Excl.subroutine(Excl.java:4)

at Excl.main(Excl.java:7)

try y catch (1)

• A menudo es más elegante y practico manejar la excepción.

• Se puede utilizar la palabra clave try para especificar un bloque de código que se debería proteger frente a todas las excepciones.

• A continuación inmediatamente del bloque try, se incluye la cláusula catch que especifica el tipo de excepción que se desea captar.

try y catch (2)

• ArithmeticException es una subclase especial de Exception, que describe más específicamente el tipo de error que se ha producido. El ámbito de la cláusula catch está restringido a las sentencias especificadas por la sentencia try precedente.

try y catch (3)class Exc2 {

public static void main(String args[]) {

try {

int d = 0;

int a = 42;

} catch (ArithmeticException e) {

System.out.println("división por cero");

}

}

}

class Exc3 { public static void main(String args[]) { int d = 0; int a = 42; try { a = 42 / d; } catch (ArithmeticException e) { System.out.println("división por cero“); } } }

Cláusulas catch múltiples (1)

• En algunos casos, la misma secuencia de código puede activar más de una condición excepcional.

• Se pueden tener varias cláusulas catch. • Se inspecciona cada uno de estos tipos de

excepción en el orden en que están y el primero que coincida se ejecuta.

• Las clases de excepción más especificas se colocaran primero, dado que no se alcanzarán las subclases si están después de unas superclase.

Cláusulas catch múltiples (2)class MultiCatch { public static void main(String args[]) { try { int a= args.length; System.out.println("a = " + a); int b = 42 / a; int c[]={l}; c[42] = 99; } catch(ArithmeticException e) { System.out.println("div por 0: " + e); } catch(ArraylndexOutOfBoundsException e) { System.out.println("índice de matriz fuera de límites: "+e); } catch(Throwable t) { System.out.println("se ha obtenido t: " + t); } }}

Cláusulas catch múltiples (3)

c:\> java MultiCatch

a= 0

div por 0: java.lang.ArithmeticException: / by zero

C:\> java MultiCatch 1

a= 1

índice de matriz fuera de límites:

java.lang.ArraylndexOutOfBoundsException: 42

Sentencias try anidadasclass MultiNest { static void procedure() { try { int c[]={l}; c[42] = 99; } catch ( ArrayIndexOutOfBoundsException e ) { system.out.println("indice de matriz fuera de limites: " + e); } }

public static void main(String args[]) { try { int a= args.lehgth; system.out.println("a = " + a) ; int b = 42 / a; procedure(); } catch(ArithmeticException e) { System.out.println("div por 0: " + e); } })

Throw (1)

• La sentencia throw se utiliza para lanzar explícitamente una excepción. En primer lugar, debe obtener un descriptor de una instancia de Throwable, mediante un parámetro en una cláusula catch, o cerrar una utilizando el operador new. esta es la forma general de una sentencia throw:

throw InstanciaThrowable;

Throw (2)

• El flujo de la ejecución se detiene inmediatamente después de la sentencia throw, y no se llega a la sentencia siguiente.

• Se inspecciona el bloque try que la engloba más cercano para ver si tiene una cláusula catch cuyo tipo coincida con el de la instancia Throwable.

Throw (3)

• Si la encuentra, el control se transfiere a esa sentencia. Si no, se inspecciona el siguiente bloque try que la engloba, y así sucesivamente, hasta que el gestor de excepción más externo detiene el programa e imprime el trazado de la pila hasta la sentencia throw.

Throw (4)class ThrowDemo { static void demoproc() { try { throw new NullPointerException("demo"); } catch(NullPointerException e) { System.out.println("capturada dentro de demoproc"); throw e; } } public static void main(String args[]) { try { demoproc(); } catch(NullPointerException e) { System.out.printin("capturada de nuevo: " + e); } }}

Throw (5)

c:\> java ThrowDemo

capturada dentro de demoproc

capturada de nuevo: java.lang.Null.PointerException: demo

finally (1)

• A veces es necesario estar seguro de que se ejecutará un fragmento de código dado independientemente de que excepciones se provocan y capturan. Se puede utilizar la palabra clave finally para identificar dicho bloque de código. Incluso aunque no coincida ninguna de las cláusulas catch, se ejecutará el bloque finally antes del código que está después del final del bloque try completo.

finally (2)class FinallyDemo {

static void procA() {

try {

System.out.println("dentro de procA") ;

throw new RuntimeException("demo");

} finally {

System.out.println("finally de procA");

}

}

static void procB() {

try {

System.out.println("dentro de procB");

return;

} finally {

System.out.println("finally de procB");

}

}

public static void main(String args[]) {

try {

procA();

} catch (Exception e) ;

procB();

}

}