Control

de
Excepciones
Una excepción es una indicación de un
problema que ocurre durante la ejecución
de un programa e interrumpe el flujo
normal de este, en otras palabras, un error
en tiempo de ejecución del programa que
hace que se suspenda su ejecución, y
termine, enviando un mensaje de error
fatal.
Algunos ejemplos son:
- El programa pretende hacer una división entre cero
- Se quiere invocar un método sobre un objeto que esta referenciado a
null.
- Se accede a una posición de un arreglo más allá de su tamaño
- Se ingresa en una variable un valor que no corresponde al tipo de dato
de la variable.
En estos ejemplos, el problema es detectado en la ejecución y no en la
compilación. Esto ocasiona que el programa termine de ejecutarse
abruptamente, en forma prematura.
 En Java, las Excepciones
también son Objetos.
Las clases que las definen están
organizadas en una jerarquía de
herencia.
 Parte de la Jerarquía de excepciones en Java
Paquete:
[Link]
Object

Throwable

Exception Error

RuntimeException IOException AWTError ThreadDeath OutOfMemoryError

ClassCastException NullPointrException InputMismatchException

IlegalArgumentException
ArrayIndexOutOfBoundsException ArithmeticException NumberFormatException
En Java las excepciones se clasifican en dos categorías:

-Verificadas: todas las clases que heredan de la clase Exception, pero

NO de RuntimeException. En estos casos será obligatorio el uso de try
para la sentencias java que pueden lanzan estas excepciones.

- No verificadas: son todas aquellas excepciones que son subclase de

la clase RuntimeException. Por lo general se pueden evitar mediante
una codificación apropiada.

Verificadas No Verificadas
Exception RuntimeException
Excepciones predefinidas
ArithmeticException
Las excepciones aritméticas son típicamente el resultado de una división por 0:
int i = 34 / 0;

NullPointerException
Se produce cuando se intenta acceder a una variable o método antes de ser definido:
class Hola {
int mg;
g(mg, a);
}

IncompatibleClassChangeException
El intento de cambiar una clase afectada por referencias en otros objetos, específicamente cuando esos objetos
todavía no han sido recompilados.

ClassCastException
El intento de convertir un objeto a otra clase que no es válida.
NegativeArraySizeException
Puede ocurrir si hay un error aritmético al intentar cambiar el tamaño de un array.

ArrayIndexOutOfBoundsException
Es la excepción que más frecuentemente se produce. Se genera al intentar acceder a un elemento de un
array más allá de los límites definidos inicialmente para ese array.
public class Ejemplo{
public static void main (String args[]){
int i = 0;
String cadenas[] = { “A”,“B”,”C”};
for (i=0; i<=4; i++)
[Link](cadenas[i]);
}
}
En el momento de la ejecución del programa:
> java Ejemplo
ABC
[Link] //INDICA EL TIPO DE EXCEPCIÓN QUE SE PRODUJO
at [Link]([Link], Compiled Code)
Exception in thread "main" Process Exit...

NumberFormatException
Ocurre cuando se ingresa en una variable un valor que no corresponde al tipo de dato de la variable
El manejo de excepciones permite a los programadores
crear aplicaciones que puedan resolver dichas excepciones,
mediante una porción de código.

Esta diseñado para procesar errores sincrónicos, que ocurren

cuando se ejecuta un programa .

En Java, se pueden utilizar los manejadores de excepciones,

que se estructuran en tres bloques:
El bloque try
El bloque catch
El bloque finally
Un bloque try encierra código que podría lanzar una
excepción y el código que no debería ejecutarse si se
produce esa excepción.

Justo después del bloque try debe ir por lo menos un

bloque catch o un bloque finally.

try{
/*bloque de instrucciones,
que puede lanzar una excepción y
además de contener otras
instrucciones*/
}
Un bloque catch especifica entre paréntesis un parámetro
de excepción, el cual identifica el tipo de excepción que
puede procesar. Dentro del bloque se especifica el código
que maneja la excepción. Este código se ejecuta cuando el
bloque try detecta la excepción.

Si hay varios bloques catch que coinciden cuando ocurre una

excepción, sólo se ejecuta el primero.
try{
/*bloque de instrucciones, que
puede lanzar una excepción y además de
contener otras instrucciones*/
}

catch (TipoExcepcion1 nombre){

//tratamiento del error1
}
catch (TipoExcepcion2 nombre){
//tratamiento del error2
}
catch (TipoExcepcion3 nombre){
//tratamiento del error3
}
¿Cómo funciona la instrucción try – catch?
1) Comienza a ejecutarse el código que está dentro del bloque try
2) Si la excepción especificada en los paréntesis del catch es
lanzada:
a- Se detiene la ejecución de las instrucciones del bloque try.
b- Luego se ejecutan las instrucciones del bloque catch.
3) Si dicha excepción no es lanzada, el código del try termina de
ejecutarse normalmente y no se ejecutan las instrucciones del
catch.
Incluir una instrucción try-catch en un programa no significa
que necesariamente la excepción va a ser lanzada. Quiere decir
que, en caso de ser lanzada, el programa estará preparado
para manejarla.
Para tratar más de una instrucción try-catch, se puede incluir
más de un bloque catch, uno por cada excepción que
deseemos tratar.
En los casos en que, simplemente queremos que el programa
ejecute una acción genérica ante una excepción :
try {
//Bloque de Instrucciones del try
}catch (Exception e){
//trato esta excepción, sin importar cual sea
}
Un bloque finally se utiliza para ejecutar un bloque de
instrucciones sea cual sea la excepción que se produzca. Este
bloque se ejecutará en cualquier caso, incluso si no se produce
ninguna excepción.
Sirve para no tener que repetir código en los bloque try catch
try {
//Bloque de Instrucciones del try
}catch (TipoExcepción nombreVariable) {
//Bloque de Instrucciones del primer catch
}catch (TipoExcepción nombreVariable) {
//Bloque de Instrucciones del segundo catch
} .....
}finally {
Bloque de Instrucciones de finally
}
Throws
La sentencia throw se ejecuta para indicar que ha ocurrido una
excepción, o lanzamiento de una excepción. Esta, especifica el
objeto que se lanzará. La forma general de la sentencia throw es:
throw ObjetoThrowable;
La utilizamos cuando no deseamos manejar la excepción dentro
del mismo método en el cual se lanza.
Java permite redirecciónar una excepción hacia el método
superior, es decir, que se invoca el método dentro del cual la
excepción es lanzada.
 Sintaxis para la creación de
MÉTODOS Java con EXCEPCIONES

public void miMétodo(…) throws TipoExcepcion

{
…
instrucción x;

throw objetoException;

instrucción y;
}
 En un ejemplo
PRÁCTICO probemos
todos lo antes
expresado sobre
EXCEPCIONES
El ejemplo consiste en
ingresar una EDAD y
validar que se
encuentre entre el
rango de 1 año y 130
años.
 Creamos una Clase
llamada PruebaTryCarch
y utilizamos el método
MAIN para realizar la
prueba.
 Usando el objeto de tipo
Scanner ingresamos la edad.
 Si el operador ingresa una
edad correcta, el programa
funciona OK, pero si el
usuario comete un error,
nuestro programa suspende su
ejecución y finaliza.
Probemos:
 Ingreso
correcto por
parte del
operador
 Ingreso
incorrecto por parte
del operador
Excepción que se lanza al ingresar un carácter
no valido en el método .nextShort() de la clase
Scanner.
Si hacemos clic en la última línea, Eclipse no lleva al código,
a la línea 14, que se encuentra en el detalle, y la selecciona
con azul, indicando donde se lanza la excepción.
 Línea de
código que
lanza la
excepción.
 Usemos try / catch
para controlar que
nuestro programa no
se interrumpa.
 Para evitar la excepción
“encerramos” el código
que puede causarla
dentro de un bloque try.

Dentro del bloque catch se especifica el parámetro de

excepción y se determina el código que maneja la misma.
 Al cometer un error en el ingreso
podemos observar que se ejecutan las
sentencias que se encuentran en el
catch. No se suspende la ejecución del
programa.
package Pruebas;
import [Link]; Puede copiar
public class PruebaTryCatch {
este código y
public static void main(String[] args) {
Scanner input = new Scanner([Link]); probarlo.
short edad = 0;
/* Este Try controla la excepción de ingresar una edad incorrecta,
* es decir que, el usuario ingreso caracteres incorrector en lugar
* de ingresar un número de tipo short.*/
try {
[Link]("Ingrese una EDAD: ");
edad = [Link]();
} catch ([Link] e) {
[Link]("La edad ingresada no es correcta, debe ingresar
números correctamente...");
}

}
}
Nos esta faltando aún, validad
la edad entre los años 1 y 130,
esto se puede realizar de
muchas maneras distintas, en
este caso usaremos un
MÉTODO que lanza una
excepción.
 Creamos el objeto
miExcepcion del tipo de
excepción que deseamos que
se lance. Luego lo utilizamos
dentro del bloque en el lugar
que queremos que se lance
con la clausula throw.
public static void chequearEdad(short ed) throws ArithmeticException {

// Creamos el objeto tipo la excepción que deseamos usar

ArithmeticException miExcepcion= new ArithmeticException("Edad incorrecta - "

+ "Debe ingresar una edad mayor a 0 o menor a 131");

if (ed < 1 || ed > 130) {

throw miExcepcion; Puede copiar este

} else { código agregarlo
[Link]("Edad Correcta"); después de
}
}// fin de chequearEdad
finalizado el main
y probarlo.
Probamos
el método
 Al cometer un error en el
ingreso podemos observar que
se ejecutan nuevamente una
excepción que también
tendremos que controlar con
try/catch.
En este ejemplo donde también se
digita un carácter no válido, se
lanzan las dos excepciones.
Realicemos ahora
el control de
excepción para el
método.
 Puede copiar este código y
public static void main(String[] args) {
Scanner input = new Scanner([Link]); probarlo.
short edad = 0;
/* Este Try controla la excepción de ingresar una edad incorrecta,
* es decir que, el usuario ingreso caracteres incorrector en lugar
* de ingresar un número de tipo short.*/
try {
[Link]("Ingrese una EDAD: ");
edad = [Link]();
} catch ([Link] e) {
[Link]("La edad ingresada no es correcta, debe ingresar números
correctamente...");
}
try {
chequearEdad(edad);
} catch ([Link] e) {
[Link]("Error de ingreso, debe ingresar una edad entre 0 o menor a 131");
}
}// fin del main
 Ahora bien, nuestra aplicación no se
interrumpe, PERO….
Se ejecutan las dos excepciones cuando se
ingresa un carácter no válido y una edad fuera
del rango. Debemos mejorar eso, ¿Cómo?
 El error que tenemos es que colocamos
los try en paralelo, es decir uno a
continuación de otro. Y en realidad debemos
colocar uno dentro del otro, es decir, si se
ingresa un carácter invalido, no debe
ejecutarse el otro try, ya que el usuario no
ingreso la edad correctamente, por lo tanto el
segundo try debe estar dentro del bloque try
del primero.
Ejecutemos
ahora
 Es correcto para
todos los casos de
ingreso.
Finalizado
 En este ejemplo pudimos utilizar una
excepción perteneciente la
estandarización de Java, pero que pasa
cuando no tenemos o conocemos una
Excepción que nos sirva para nuestros
propósitos.

PODEMOS CREAR NUESTRAS

PROPIAS EXCEPCIONES.
Creación de Excepciones
Se pueden definir excepciones propias en
Java, no hay por qué limitarse a las
predefinidas.
Para ello, bastará con: la clase extienda de
la clase Exception y proporcionar la
funcionalidad extra que requiera el
tratamiento de esa excepción.
 En un ejemplo
PRÁCTICO probemos
como crear nuestras
propias EXCEPCIONES
 Conservemos parte del ejemplo
que trabajamos anteriormente,
consiste en ingresar una EDAD y
validar que se encuentre entre
el rango de 1 año y 130 años.
Pero en este caso en lugar de
usar la excepción de Java vamos
a crear la nuestra.
Primero creamos la
Clase que define la
excepción.
 Puede copiar este código y
probarlo.

public class ChequearEdad_erronea extends Exception {

// Creación de la Clase, es mi excepción la que luego utilio en el método

private static final long serialVersionUID = 1L;

public ChequearEdad_erronea() { // constructor por defecto, sin parámetros

}

public ChequearEdad_erronea(String msg_Error) {

// constructor con parámetro, el mensaje de error

super(msg_Error);
}

/* super, llama al constructor de la clase PADRE que en este caso es Exception

* y le pasa el mensaje de error.
*/
}
Segundo la usamos en
nuestro método y
también en el try,
cuando lo llamamos.
 El Método que usa nuestra clase
public static void chequearEdad(short ed) throws
ChequearEdad_erronea {
// Creamos el objeto tipo la excepción que deseamos usar

ChequearEdad_erronea miExcepcion = new ChequearEdad_erronea(

"Edad incorrecta - " + "Debe ingresar una edad
mayor a 0 o menor a 131");

if (ed < 1 || ed > 130) {

throw miExcepcion;
} else {
[Link]("Edad Correcta");
}
}// fin de chequearEdad Puede copiar este código y
probarlo.
public static void main(String[] args) {
Scanner input = new Scanner([Link]);
short edad = 0;

try {
Nuestro main
[Link]("Ingrese una EDAD: ");
edad = [Link]();

try {
chequearEdad(edad);

} catch (ChequearEdad_erronea e) {

// esta sentencia muestra la exception

// [Link]();

[Link]("Error, Debe ingresar una edad

mayor a 0 o menor a 131");
}

} catch ([Link] e) {
[Link]("La edad ingresada no es correcta, debe ingresar
números correctamente...");
}
}// fin del main Puede copiar este código y
probarlo.
 Hacemos
uso de la
clase que
creamos,
usamos el
constructor
con
parámetro.
Es correcto para todos
los casos de ingreso.
Bibliografía
Deitel & Deitel, Cómo programar en Java, Séptima Edición, Person
Educación, México, 2008

 [Link]

 [Link]

Realizado por Prof. Nora Hernández