MIGUEL ANGEL AGUILAR ESTANISLAO

ES1511109383

UNIVERSIDAD ABIERTA Y A DISTANCIA DE MEXICO

DESARROLLO DE SOFTWARE

PROGRAMACIN ORIENTADA A OBJETOS

3ER SEMESTRE

UNIDAD 3

ACTIVIDAD 3
EXCEPCIONES

En Java una excepcin es un error o una condicin anormal que se ha producido durante la
ejecucin de un programa. Java tiene diferentes tipos de excepciones: excepciones de I/O, las
excepciones en tiempo de ejecucin y las de su propia creacin. Durante la compilacin solamente se
detectan los errores de sintaxis, pero el manejo de excepciones de Java permite el manipular los errores
que ocurren en tiempo de ejecucin, entre estas podemos mencionar las excepciones aritmticas
(divisin entre cero), excepciones de puntero (acceso a punteros NULL) y excepciones de indexacin
(acceso por encima o debajo de los lmites de un vector). Algunas excepciones son fatales y causan el
fin de la ejecucin del programa. En este caso conviene terminar ordenadamente y enviar un mensaje
explicando el tipo de error que se ha producido. En otras situaciones, por ejemplo cuando no se
encuentra un archivo sobre el que se desea realizar una operacin, el programa puede dar al usuario la
oportunidad de corregir el error.

Un buen programa debe manejar correctamente la mayora de los errores que se puedan
producir, Java proporciona las siguientes herramientas para el manejo de excepciones: try, catch, throw,
throws y finally.

Jerarqua de las Excepciones

En Java, todas las excepciones estan consideradas en el de rbol de excepciones que se deriva
de la clase Throwable. Existen dos subclases directas de Throwable: Error y Exception. En la figura se
observa parte de la jerarqua de clases derivada de Throwable:

La clase Error est relacionada con errores de la mquina virtual de Java y no el cdigo,
generalmente estos errores no dependen del programador por lo que no debe preocuparse por tratarlos.

En la clase Exception se encuentran las excepciones RuntimeException, producidas por

errores de programacin. El compilador de Java obliga a corregirlas.

Tipos de Excepciones

En resumen las excepciones son generadas de tres formas diferentes.

1) La mquina Virtual de Java puede generar una excepcin como producto de un error interno que
est fuera de su control. Estas excepciones generalmente no pueden ser manejadas por el
programa.
2) Excepciones estndar: Son excepciones que deben ser manipuladas, se producen cuando se
ejecuta una divisin por cero o se trata de acceder a un arreglo con un ndice fuera de lmites
son generadas por errores en el cdigo del programa.
 3) El programador puede generar una excepcin manualmente utilizando la estructura throw. Sin
importar cmo se produjo la excepcin, se maneja de la misma forma.

Manejo de Excepciones

Cuando se produce un error en un mtodo, este crea un objeto 'exception' el cual contiene
informacin sobre la excepcin como el tipo de excepcin y el estado del programa al presentarse el
problema. El sistema de ejecucin es el responsable de buscar algn bloque de cdigo que maneje la
excepcin. En la terminologa de java, al hecho de crear una objeto exception y manejarlo por el sistema
de ejecucin se le conoce como lanzar una excepcin (throwing an exception).

Bloque try/catch

El ncleo del manejo de excepciones son los bloques try y catch. A continuacin se muestra la
forma general del manejo de bloques de excepcin try/catch:

try{
/ cdigo que pudiera ocasionar una excepcin
}

catch (Tipo_de_Excepcin1 Objeto_Excepcion){

cdigo para manejar la excepcin
}

catch (Tipo_de_Excepcin2 Objeto_Excepcion){

cdigo para manejar la excepcin
}

Cuando un segmento de cdigo lanza una excepcin, esta es atrapada por su

correspondiente manejador catch. En un mismo bloque de instrucciones se puede generar ms de una
excepcin, por lo que puede haber ms de un bloque catch asociado a un solo try.

La ejecucin de catch no es como llamar a una funcin, es decir, despus de ejecutar catch la
ejecucin del programa no regresa a donde se gener la excepcin, sino que el flujo del programa
contina despus del bloque catch.

El siguiente programa genera una excepcin al momento de su

ejecucin:

public class PruebaExcepcion1{

public static void main(String args[]){

int numero[]=new int[5];

numero[7]=0;
}
}
 La excepcin generada es:

Agregando el cdigo para el manejo de la excepcin al mismo programa tenemos:

public class PruebaExcepcionCorregida{

public static void main(String args[]){

int numero[]=new int[5];
try{
numero[7]=0;
}

catch(java.lang.ArrayIndexOutOfBoundsException Error){
System.out.println("Se genero una excepcion al acceder al arreglo");
}
}
}

Ahora al producirse la excepcin sigue las acciones especificadas en el bloque catch, es este
caso, la accin consiste en mandar un mensaje.

Excepcin producida por un mtodo y atrapada en otro.

Una excepcin puede ser generada en un mtodo y atrapada por el mtodo que llam al primero,
en el siguiente ejemplo, la excepcin es generada en un mtodo de una clase y es atrapada en el main
de otra clase.

class GeneraExcepcion2{
void produceExcepcion(){
int numero[]=new int[5];
System.out.println("Tratando de acceder a una posicion fuera del vector");
numero[7]=0;
}
}

public class PruebaGeneraExcepcion2{

public static void main (String args[]){
GeneraExcepcion2 objeto =new GeneraExcepcion2();
try{ objeto.produceExcepcion();
}
catch (ArrayIndexOutOfBoundsException excep){
System.out.println("Excepcion Generada en otro bloque");
}
}
}
Excepcin generada y atrapada en un mtodo.

Las excepciones no solamente son atrapadas en el mtodo main, en el siguiente ejemplo la

excepcin es generada y capturada en un mtodo invocado por main.

class GeneraExcepcion3{
void produceExcepcion(){
int numero[]=new int[5];
try{ System.out.println("Accesando a una posicion fuera del vector");
numero[7]=0;
}

catch (ArrayIndexOutOfBoundsException excep){

System.out.println("Ocurrio una excepcion");
}
}
}

public class PruebaGeneraExcepcion3{

public static void main (String args[]){
GeneraExcepcion3 objeto =new GeneraExcepcion3();
objeto.produceExcepcion();
}
}

En el ejemplo anterior dado que la excepcin fue capturada por el mtodo produceExcepcion(), el
control del programa no podr volver a main.

Recuperacin de la ejecucin despus de una excepcin.

Uno de los mayores beneficios del manejo de excepciones es el permitir a un programa

responder a un error y luego continuar con la ejecucin. Por ejemplo:

class ExcepcionContinua{
static void divide(){
int num[]={4,8,16,32,64,128,256};
int den[]={2,0,4,4,0,8,16};

for (int i=0;i<num.length;i++){

try{ System.out.println(num[i]+ "/" + "=" + num[i]/den[i]);
}
catch(java.lang.ArithmeticException excepcion){
System.out.println("Dividiendo por cero");
}
}
}
}

public class PruebaExcepcionContinua{

public static void main (String args[]){
ExcepcionContinua.divide();
}
}
Clasulas Catch Mltiples

En un mismo segmento de cdigo se pueden generar ms de una excepcin por diferentes

motivos, por lo tanto un dicho segmento puede tener un bloque catch para cada excepcin.

class ExcepcionesMultiples{
static void divide(){
int num[]={4,8,16,32,64,128,256};
int den[]={2,0,4,4,0,8};

for (int i=0;i<num.length+1;i++){

try{
System.out.println(num[i]+ "/" + "=" + num[i]/den[i]);
}

catch(java.lang.ArithmeticException excepcion){
System.out.println("Dividiendo por cero");
}
catch(java.lang.ArrayIndexOutOfBoundsException excepcion){
System.out.println("Error al accesar el vector");
}
}
}
}
public class PruebaExcepcionesMultiples{
public static void main (String args[]){
ExcepcionesMultiples.divide();
}
}

Manejo de excepciones generales y especficas

Una clasula catch que atrapa a la superclase throwable atrapar a cualquier excepcin. Si se
requiere atrapar excepciones con un catch general y adems hacer un catch para una excepcin
especfica, entonces se debe colocar la subclase y despus la clase Throwable.

class ExcepcionGeneralyEspecifica{
public static void main(String args[]){
int num[]= {4,8,16,32,64,128,256,512};
int den[]= {2,0,4,4,0,8};
for (int i=0;i<num.length;i++){
try{ System.out.println(num[i]+"/"+den[i]+"="+ num[i]/den[i]);
}

catch (ArrayIndexOutOfBoundsException Excep){

System.out.println("Fuera de limite"+ i);
}
catch (Throwable Excep){
System.out.println("Ocurrio una excepcion generica"); }
}
} // fin de main
}
Bloques try anidados

Con frecuencia los bloques anidados try se usan para permitir diferentes niveles de errores, que
sern manejados de diferentes formas. Algunos de estos errores son menores y pueden arreglarse
fcilmente, pero otros son catastrficos y no se pueden corregir. Un mtodo comnmente
empleado por los programadores es usar un bloque externo try para atrapar los errores graves y
bloques internos try para el control de los errores sencillos.

class ExcepcionesAnidadas {
public static void main(String args[]){
int num[]= {4,8,16,32,64,128,256,512};
int den[]= {2,0,4,4,0,8};
try{
for (int i=0;i<num.length;i++){
try{
System.out.println(num[i]+"/"+den[i]+"="+ num[i]/den[i]);
}
catch (ArithmeticException Excep){
System.out.println("Fuera de limite"+ i);
}
}
} //try externo

catch (Throwable Excep){

System.out.println("Ocurrio una excepcion fatal");
}
System.out.println("El programa puede continuar aqui");
} // fin de main
}

Finally

Muchas veces, cuando se produce una excepcin es necesario un mecanismo que limpie el
estado del mtodo antes de que el control pase a otra parte del programa. Por ejemplo, una
excepcin podra causar un error que termine el mtodo actual, pero tal vez antes sea necesario cerrar
un archivo o una conexin a red. En Java esto se puede hacer esto encerrando el cdigo de limpieza
dentro de un bloque finally. El formato general de un try/catch que incluye finally es:

try{
cdigo que produce la (s) excepcin (es)...
}
catch( TipoDeExcepcion objeto){
// Cdigo para manejar la excepcin
}
finally{
// cdigo de finally
}
El bloque finally ser ejecutado cada vez que se termine un bloque try/catch, sin importar como se salga
del bloque try.

class UseFinally{
public static void generaExcepcion(int i){
int t;
int num[] = {2,4,6};
System.out.println("Recibiendo "+ what);
try{

switch(i){
case 0: t=10/i; //division por cero
break;
case 1:num[4]=4; //genera un error
break;
case 2: return;
}
}

catch(ArithmeticException exc){
System.out.println("No puede dividir entre cero");
return; // regresa desde catch
}

catch(ArrayIndexOutOfBoundsException exc) {
System.out.println(" No hay elementos que coincidan");
}
finally {
System.out.println("Ejecutando codigo de limpieza");
}
} //fin de metodo
}//clase

class PruebaUseFinally
{ public static void main(String args[])
{ for (int i=0;i<4; i++)
{ UseFinally.generaExcepcion(i);
System.out.println();
}
}
}
 Throws

En algunos casos, si un mtodo genera una excepcin que el programa no maneja, se debe declarar
dicha excepcin en la clasula throws. La forma general de throws es:

valorRetorno nombreMetodo (parmetros) throws excepcin1, ., excepcinN{

//cdigo del mtodo
}

Las excepciones que derivan de Error o RuntimeException no necesitan ser especificados en una lista
throws. Todos los otros tipos de excepciones necesitan ser declarados, o se producen errores en tiempo
de compilacin. Por ejemplo, en la entrada por teclado se puede generar una excepcion IOException, la
cual no puede manejarse en el programa.

class UseThrows{
static char prompt(String str) throws java.io.IOException{
System.out.println(str+ ": ");
return (char) System.in.read();
}
}
public class PruebaUseThrows{
public static void main(String args[]){
char ch;
try{
ch=UseThrows.prompt("Escriba una letra");
}

catch( java.io.IOException exc){

System.out.println("Excepcion de entrada-Salida");
ch='X';
}
} // main
} //clase

Fuentes
http://www.mundojava.net/excepciones.html?Pg=java_inicial_4_6.html
http://codejavu.blogspot.mx/2013/05/interfaces-en-java.html
http://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=65
2:jerarquias-de-herencia-en-java-concepto-de-superclases-y-subclases-el-api-java-
ejemplos-cu00685b&catid=68:curso-aprender-programacion-java-desde-cero&Itemid=188