Java

Excepciones

H. Tejeda V

htejeda@fismat.umich.mx

Universidad Michoacana

Facultad de Ciencias Fısico-Matematicas

Java– p. 1

Introduccion

• Una aplicación durante su ejecución puede producir muchas clases deerrores de diversos niveles de severidad.

• Al invocar un método sobre un objeto, el objeto puede descubrirproblemas de estado interno (valores de variables inconsistentes),detectar errores con los objetos o datos que maneja (como un archivo odirección de red), determinar que se está violando su contrato básico(por ejemplo, leer datos de un stream ya cerrado), etc.

• Si se comprueban todas las posibles condiciones de error, el código sevuelve ininteligible.

• Las excepciones proveen una forma fácil de comprobar errores sinoscurecer el código, dando un mecanismo para indicar la existencia deerrores, en vez de usar indicadores o efectos laterales.

• Las excepciones convierten las condiciones de error que un métodopuede señalar en una parte explícita del contrato del método.

Java– p. 2

Introduccion cont.

• Una excepción se lanza cuando se encuentra una condición de errorinesperada.

• La excepción es capturada por una cláusula cercana en la pila deinvocación de métodos.

• Las excepciones no capturadas producen la finalización del hilo deejecución, pero antes de que éste finalice, se da a ThreadGroup laposibilidad de gestionar la excepción de la mejor forma posible,generalmente imprimiendo información útil sobre el lanzamiento de laexcepción.

Java– p. 3

Creacion de Tipos de Excepcion

• Las excepciones son objetos. Todos los tipos de excepción debenextender la clase Throwable o una de sus subclases. Para describir laexcepción se puede usar una cadena de texto que contiene la claseThrowable . Por convenio, los nuevos tipos de excepción extienden aException , una subclase de Throwable .

• Las excepciones son principalmente excepciones comprobadas , por loque el compilador comprueba que los métodos lanzan sólo lasexcepciones que ellos mismos han declarado que pueden lanzar.

• Las excepciones y errores estándar en tiempo de ejecución extiendenuna de las clases RuntimeException o Error , y se denominanexcepciones no comprobadas .

• Las excepciones comprobadas representan condiciones que, aunqueexcepcionales, se puede esperar razonablemente que ocurran, por loque deben ser consideradas. Al ser comprobada la excepción sedocumenta la existencia y se asegura que al llamar a un método setratará la excepción.

Java– p. 4

Creacion de Tipos de Excepcion cont. 1

• Las excepciones no comprobadas representan condiciones que reflejanerrores en la lógica del programa, por ejemplo, la excepciónIndexOutOfBoundsException se lanza al intentar acceder fuera delos límites de una arreglo.

• Como pueden producirse errores al escribir cualquier sentencia, esimposible declarar y capturar todas las excepciones que pueden surgir,por eso existen las excepciones no comprobadas.

• Algunas veces es útil tener más datos para describir la condiciónexcepcional, aparte de la cadena de texto de Exception , por lo que sepuede extender a Exception para tener una clase con los datosañadidos.

• Se añade el método sustituirValor a la interfaz Atribuido , el cualcambia el valor actual de un atributo con un nombre dado, si el atributocon nombre no existe, se lanza una excepción, donde la excepción debetener el nombre del atributo. Para representar la excepción se crea laclase NoTalAtributoException

Java– p. 5

Creacion de Tipos de Excepcion cont. 2

public class NoTalAtributoException extends Exception {public String nombreAtrib;

// constructorpublic NoTalAtributoException(String nombre) {

super("El atributo con el nombre " nombre ++ "¨ no se encuentra");

nombreAtrib = nombre;}

}

• Los nuevos tipos de excepciones se deben crear cuando losprogramadores deseen manejar una determinada clase de error y nootra, por lo que pueden así usar el tipo de la excepción para ejecutar elcódigo correcto, en vez de examinar el contenido de la excepción paradeterminar si les importa esa excepción o han capturadoaccidentalmente una excepción irrelevante.

Java– p. 6

throw

• Las excepciones se lanzan usando la sentencia throw

throw expresi on ;

donde la expresión debe evaluarse dando una referencia a un objetoThrowable .

public void sustituirValor(String nombre, Object nuevoVa lor)throws NoTalAtributoException {

Atrib atrib = buscar(nombre); // busca el atribif (atrib == null) // si no se encuentra

throw new NoTalAtributoException(nombre);atrib.setValor(nuevoValor);

}

• El método sustituirValor primero busca por nombre el actual objetoAtrib . Si no existe, lanza un nuevo objeto del tipoNoTalAtributoException , dando al constructor el nombre delatributo. Como las excepciones son objetos, se deben crear antes de serlanzadas. También se puede generar una excepción invocando a unmétodo que lance la excepción.

Java– p. 7

Transferencia de Control

• Cuando se lanza una excepción, se dice que la sentencia o expresiónque causa la excepción termina bruscamente , con lo cual la cadena dellamadas se deshace gradualmente, ya que cada bloque o invocación demétodo se termina bruscamente, hasta que la excepción se captura.

• Si la excepción no se captura, el hilo de ejecución finaliza, aunque antesde que termine se da la oportunidad a ThreadGroup de gestionar laexcepción.

• Al producirse una excepción, las acciones que hubiera en espera en elpunto donde la excepción se produjo no tienen lugar.

• Por ejemplo, si la evaluación de un operando izquierdo produce unaexcepción, no se evalúa el operando derecho, o si la evaluación de laexpresión de un parámetro produce una excepción, no se evaluán losparámetros a la derecha.

• La siguiente acción que ocurrira estará o en un bloque finally o en unbloque catch que capture la excepción.

Java– p. 8

Excepciones Asıncronas

• La sentencia throw produce una excepción síncrona , al igual que laexcepción aritmética resultado de la división por cero, como resultado deejecutar una instrucción particular.

• Una excepción asíncrona se produce en cualquier momento, sinimportar la instrucción que se está ejecutando.

• Las excepciones asíncronas ocurren por un error interno de la máquinavirtual de Java en donde no se puede hacer nada, o bien, por el uso delmétodo desaprobados Thread.stop , o de los métodos aprobadosrelacionados con stopThread de la Interfaz de Depuración de laMáquina Virutal de Java.

Java– p. 9

Clausula throws

• Se usa para declarar una lista de las excepciones comprobadas quepuede lanzar un método. Con lo cual se indica que excepciones lanza unmétodo y asegura de que son tratadas al ser invocadas.

• Las excepciones comprobadas que devuelve un método son tanimportantes como el tipo de valor que devuelve, debiendo ser ambasdeclaradas.

• Es posible lanzar excepciones comprobadas que sean extensiones dealgún tipo de excepción declarado en la cláusula throws , ya que unaclase puede usarse polimórficamente allí donde se espere a susuperclase.

• Un método puede lanzar varias clases diferentes de excepcionescomprobadas (todas ellas extensiones de una clase particular deexcepción) y declarar sólo su superclase en la cláusual throws , pero seoculta información ya que no se sabría cuál de los posibles tipos deexcepción extendido podría ser lanzado.

• Para cumplir el contrato definido por la cláusula throws sólo se puedelanzar un tipo de excepción comprobada que haya sido declarado en lacláusula throws .

Java– p. 10

Clausula throws cont. 1

• Cuando un método no tiene cláusula throws , significa que no puedelanzar excepciones comprobadas.

• Las excepciones estándar en tiempo de ejecución (comoClassCastException y ArithmeticException ) son extensiones dela clase RuntimeException .

• Los errores más importantes son indicados por excepciones que sonextensiones de Error , pudiendo ocurrir en cualquier momento.

• Las excepciones RuntimeException y Error son las únicas que nohace falta incluir en la cláusula throws , y cualquier método puedelanzarlas.

• Los inicializadores y los bloques de inicialización estática no puedenlanzar excepciones comprobadas, ni directamente, ni invocando a unmétodo que lance la excepción.

• Los constructores y los bloques de inicialialización no estática puedendeclarar y lanzar excepciones comprobadas.

Java– p. 11

Clausula throws cont. 2

• Al invocar a un método que tiene una excepción comprobada en sucláusula throws , se presentan los siguientes 3 casos:◦ Capturar la excepción y gestionarla.◦ Capturar la excepción y transformarla en una de nuestras

excepciones lanzando una excepción de un tipo declarado ennuestra propia cláusula throws .

◦ Declarar la excepción en la cláusula throws y hacer que laexcepción pase por nuestro método.

• Para realizar lo anterior es necesario capturar excepciones lanzadas porotros métodos.

Java– p. 12

Clausulas throws y redefinicion de metodos

• Al redefinir un método heredado o implementar un método abstractoheredado, la cláusula throws del método que realiza la redefinicióndebe ser compatible con la cláusula throws del método heredado.

• No se permite que los métodos de redefinición o de implementacióndeclaren más excepciones combrobadas en la cláusula throws , que lasque declara el método heredado, ya que el código escrito en ladeclaración inicial del método no está preparado para ninguna excepcióncomprobada adicional.

• Si el método de redefinción o de implementación no lanza una excepcióncomprobada, no necesita declararla, ya que es una consideración deldiseño, por lo que la declaración en subclases puede perderse.

Java– p. 13

try , catch y finally

• Las excepciones se capturan encerrando código en bloques try , con lasiguiente sintaxis:

try {sentencias

catch ( excepci on tipo1 identificador1) {sentencias

} catch ( excepci on tipo2 identificador2) {sentencias

...} finally {

sentencias}

• El cuerpo de la sentencia try se ejecuta hasta que se lanza unaexcepción o hasta que se finaliza con éxito.

Java– p. 14

try , catch y finally cont. 1

• Si se lanza una excepción, se examinan sucesivamente las cláusulascatch para saber a cual será asociado de acuerdo con el tipo del objetode la excepción.

• Cuando se encuentra una cláusula catch asignable, se ejecuta sucuerpo, y no se ejecutará ninguna otra cláusula.

• Se puede asociar desde ningúna cláusula catch hasta cualquiernúmero a un try determinado, siempre que cada cláusula capture unatipo diferente de excepción.

• Si no se encuentra ningún catch apropiado, la excepción pasa de lasentencia try actual a otra sentencia try que pudiera tener unacláusula catch para gestionarla.

• Si aparece una cláusula finally el código que contiene se ejecutarádespues de que finalice el proceso de la sentencia try ,independientemente de cómo termine el proceso, ya sea mediante unaexcepción o mediante una sentecia de flujo de control, como break oreturn

Java– p. 15

try , catch y finally cont. 2

• Se muestra un ejemplo que está preparado para gestionar una de lasexcepciones que lanza sustituirValor :

Object valor = new Integer(8);try {

objAtribuido.sustituirValor("Edad", valor);} catch (NoTalAtributoExcepcion e) {

// no deber ıa suceder, pero si sucedeAtrib atrib = new Atrib(e.nombreAtrib, valor);objAtribuido.a nadir(atrib);

}

• En la sentencia try hay una sentencia que intenta hacer algo que seespera que suceda, si todo transcurre normalmente, el bloque finaliza.

• Si se lanza alguna excepción durante la ejecución de la sentencia, yasea en forma directa mediante throw o indirectamente por un método enel interior del bloque, la ejecución del código dentro de try se detiene, yse examina la cláusula catch adjunta para ver si desea capturar laexcepción lanzada.

Java– p. 16

try , catch y finally cont. 3

• Una cláusula catch es parecida a un método empotrado que tiene unparámetro (la excepción a ser capturada), y es donde se intentarecuperse de los efectos de la excepción, o bien realizando alguna tareade limpieza y volver a lanzar la excepción, de forma que cualquier códigoque llame use el código tenga la oportunidad de capturarla.

• No se puede poner una cláusula catch de una superclase antes de unacláusula catch de una de sus subclases.

• Las cláusulas catch se examinan en orden, por que un catch queselecciona un tipo de excepción antes del catch correspondiente a untipo extendido sería un error, ya que la cláusula nunca se alcanzaría.

Java– p. 17

try , catch y finally cont. 4

• Considerar el siguiente código que no acepta el compilador:

class SuperException extends Exception { }

class SubException extends SuperException { }

class MalaCaptura {

public void buenIntento() {/ * Orden no v alido para catch * /try {

throw new SubException();} catch (SuperException superRef) {

// Captura a SuperException como a SubException} catch (SubException subRef) {

// Esta parte nunca se alcanza}

}

}

Java– p. 18

finally

• Con esta cláusula se proporciona un mecanismo para ejecutar unasección de código, se lance o no una excepción.

• Se emplea para limpiar el estado interno o para liberar recursos que noson objetos, como archivos abiertos almacenados en variables locales.

public boolean busquedaDe(String archivo, String palabra )throws StreamException

{ // M etodo que revisa un archivo.Stream entrada = null;try {

entrada = new Stream(archivo);while (!entrada.eof())

if (entrada.netxt().equals(palabra))return true;

return false; // no se encuentra} finally {

if (entrada != null)entrada.close();

}

}

Java– p. 19

finally cont. 1

• Cuando se emplea new, si se tiene éxito entrada se referirá a un objetoque representa el archivo abierto, sino entonces mantendrá el valorinicial.

• Cuando se ejecute la cláusula finally , el stream entrada se cierrasólo si ha sido abierto, con lo cual se asegura que el archivo se cierra.

• El método BusquedaDe declara que lanza una excepciónStreamException , por lo que cualquier excepción generada es pasadaal código que lo invoca tras la operación de limpieza, incluso la lanzadapor la invocación de close .

• Una cláusula finally se puede usar para realizar las acciones finalestras sentencias break , continue y return .

• Por lo anterior, algunas veces se ve una cláusula try sin cláusulascatch

• No hay forma de salir de un bloque try sin ejecutar su cláusulafinally .

Java– p. 20

finally cont. 2

• Se debe tener cuidado de no cambiar la razón de salida cuando seemplea una cláusula finally , es decir se debe evitar crear su propiorazón de salida.

try {// . . . hace algo . . .return 1;

} finally {return 2;

}

• Al entrar al bloque try se ejecuta su sentencia return con la “razón” dedevolver 1, después se entra al bloque finally en el cual se devuelveel valor 2, por lo que la intención inicial se pierde. Se puede evitar si elbloque finally no devuelve un valor, sino que simplemente se llegahasta el final.

Java– p. 21

Cuando usar excepciones

• Las excepciones no están concebidas para situaciones simples yprevisibles, por ejemplo que se alcance el final de un stream de entrada,en ese caso basta un código de retorno para indicar el final de la entrada.

• Considerar el siguiente ciclo típico que usa un indicador de retorno:

while (( token = stream.next()) != Stream.END )proces

Java– p. 22