Java5

Introducción a la Programación en Java
Ing. Alma Leticia Palacios Guerrero Pág. 39
Unidad 5. EXCEPCIONES
En Java una excepción es un error o una condición anormal que se ha producido durante la ejecución de
un programa. Java tiene diferentes tipos de excepciones: excepciones de I/O, las excepciones en tiempo
de ejecución y las de su propia creación. Durante la compilación solamente se detectan los errores de
sintaxis, pero el manejo de excepciones de Java permite el manipular los errores que ocurren en tiempo
de ejecución, entre estas podemos mencionar las excepciones aritméticas (división entre cero),
excepciones de puntero (acceso a punteros NULL) y excepciones de indexación (acceso por encima o
debajo de los límites de un vector). Algunas excepciones son fatales y causan el fin de la ejecución 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 operación, el programa puede dar al usuario la oportunidad de corregir el error.
Un buen programa debe manejar correctamente la mayoría de los errores que se puedan producir, Java
proporciona las siguientes herramientas para el manejo de excepciones: try, catch, throw, throws y finally.
5.1 Jerarquía 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 jerarquía de clases derivada de Throwable:
La clase Error está relacionada con errores de la máquina virtual de Java y no el código, 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
programación. El compilador de Java obliga a corregirlas.
5.2 Tipos de Excepciones
En resumen las excepciones son generadas de tres formas diferentes.
1) La máquina Virtual de Java puede generar una excepción como producto de un error interno que
está fuera de su control. Estas excepciones generalmente no pueden ser manejadas por el
programa.
2) Excepciones estándar: Son excepciones que deben ser manipuladas, se producen cuando se
ejecuta una división por cero o se trata de accesder a un arreglo con un índice fuera de límites
son generadas por errores en el código del programa.

3) El programador puede generar una excepción manualmente utilizando la estructura throw. Sin
importar cómo se produjo la excepción, se maneja de la misma forma.
5.3 Manejo de Excepciones
Cuando se produce un error en un método, este crea un objeto 'exception' el cual contiene información
sobre la excepción como el tipo de excepción y el estado del programa al presentarse el problema. El
sistema de ejecución es el responsable de buscar algún bloque de código que maneje la excepción. En la
terminología de java, al hecho de crear una objeto exception y manejarlo por el sistema de ejecución se
le conoce como lanzar una excepción (throwing an exception).
5.3.1 Bloque try/catch
El núcleo del manejo de excepciones son los bloques try y catch. A continuación se muestra la forma
general del manejo de bloques de excepción try/catch:
try{
/ código que pudiera ocasionar una excepción
}
catch (Tipo_de_Excepción1 Objeto_Excepcion){
código para manejar la excepción
}
catch (Tipo_de_Excepción2 Objeto_Excepcion){
código para manejar la excepción
}
Cuando un segmento de código lanza una excepción, esta es atrapada por su correspondiente
manejador catch. En un mismo bloque de instrucciones se puede generar más de una excepción, por lo
que puede haber más de un bloque catch asociado a un solo try.
La ejecución de catch no es como llamar a una función, es decir, después de ejecutar catch la ejecución
del programa no regresa a donde se generó la excepción, sino que el flujo del programa continúa
después del bloque catch.
El siguiente programa genera una excepción al momento de su ejecución:
public class PruebaExcepcion1{
public static void main(String args[]){
int numero[]=new int[5];
numero[7]=0;
}
}

La excepción generada es:
Agregando el código para el manejo de la excepción al mismo programa tenemos:
public class PruebaExcepcionCorregida{
try{
numero[7]=0;
}
catch(java.lang.ArrayIndexOutOfBoundsException Error){
System.out.println("Se genero una excepcion al acceder al arreglo");
}
}
}
Ahora al producirse la excepción sigue las acciones especificadas en el bloque catch, es este caso, la
acción consiste en mandar un mensaje.
5.3.3 Excepción producida por un método y atrapada en otro.
Una excepción puede ser generada en un método y atrapada por el método que llamó al primero, en el
siguiente ejemplo, la excepción es generada en un método de una clase y es atrapada en el main de otra
clase.
class GeneraExcepcion2{
void produceExcepcion(){
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");
}
}
}

5.3.4 Excepción generada y atrapada en un método.
Las excepciones no solamente son atrapadas en el método main, en el siguiente ejemplo la excepción es
generada y capturada en un método invocado por main.
class GeneraExcepcion3{
void produceExcepcion(){
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{
GeneraExcepcion3 objeto =new GeneraExcepcion3();
objeto.produceExcepcion();
}
}
En el ejemplo anterior dado que la excepción fue capturada por el método produceExcepcion(), el control
del programa no podrá volver a main.
5.3.5 Recuperación de la ejecución después de una excepción.
Uno de los mayores beneficios del manejo de excepciones es el permitir a un programa responder a un
error y luego continuar con la ejecución. 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{
ExcepcionContinua.divide();
}
}

5.3.6 Claúsulas Catch Múltiples
En un mismo segmento de código se pueden generar más de una excepción por diferentes motivos, por
lo tanto un dicho segmento puede tener un bloque catch para cada excepción.
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{
ExcepcionesMultiples.divide();
}
}
5.3.7 Manejo de excepciones generales y específicas
Una claúsula catch que atrapa a la superclase throwable atrapará a cualquier excepción. Si se requiere
atrapar excepciones con un catch general y además hacer un catch para una excepción específica,
entonces se debe colocar la subclase y después la clase Throwable.
class ExcepcionGeneralyEspecifica{
int num[]= {4,8,16,32,64,128,256,512};
int den[]= {2,0,4,4,0,8};
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
}

5.3.8 Bloques try anidados
Con frecuencia los bloques anidados try se usan para permitir diferentes niveles de errores, que serán
manejados de diferentes formas. Algunos de estos errores son menores y pueden arreglarse fácilmente,
pero otros son catastróficos y no se pueden corregir. Un método comúnmente 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 {
int num[]= {4,8,16,32,64,128,256,512};
int den[]= {2,0,4,4,0,8};
try{
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
}
5.4 Finally
Muchas veces, cuando se produce una excepción es necesario un mecanismo que limpie el estado del
método antes de que el control pase a otra parte del programa. Por ejemplo, una excepción podría
causar un error que termine el método actual, pero tal vez antes sea necesario cerrar un archivo o una
conexión a red. En Java esto se puede hacer esto encerrando el código de limpieza dentro de un bloque
finally. El formato general de un try/catch que incluye finally es:
try{
código que produce la (s) excepción (es)...
}
catch( TipoDeExcepcion objeto){
// Código para manejar la excepción
}
finally{
// código 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();
}
}
}

5.5 Throws
En algunos casos, si un método genera una excepción que el programa no maneja, se debe declarar
dicha excepción en la claúsula throws. La forma general de throws es:
valorRetorno nombreMetodo (parámetros) throws excepción1, …., excepciónN{
//código del método
}
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 compilación. 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{
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
Tarea. Investigar qué es un flujo o Stream y las clases de flujos en java.

Unidad 6. Entrada/Salida de Datos
Los programas necesitan comunicarse con su entorno, tanto para recoger datos e información que deben
procesar, como para devolver los resultados obtenidos. La manera de representar estas entradas y
salidas en Java es a base de streams (flujo). Un flujo es una abstracción que produce o consume
información y está encadenado a un dispositivo físico por el sistema de E/S de Java. La información se
trasmite en serie a través de la conexión. Por ejemplo, va a imprimir algo en pantalla, se hace a través de
un flujo que conecta el monitor con el programa. Este concepto es suficiente para representar la
lectura/escritura de archivos, la comunicación a través de Internet o la lectura de la información de un
sensor a través del puerto en serie.
El package java.io contiene dos familias de jerarquías distintas para la entrada/salida de datos. La
diferencia principal consiste en que una opera con bytes y la otra con caracteres (el carácter de Java está
formado por dos bytes porque sigue el código Unicode), esta diferencia hace el sistema de entrada salida
muy amplio. En un nivel más bajo toda entrada salida está orientada a bytes, los streams de caracter
simplemente facilitan el manejo de caracteres.
6.1 Flujos Caracter
Los flujos de bytes son poderosos y flexibles, pero no son la forma ideal para manejar la entrada/salida
de caracteres. Por esta razón en Java existen clases para el manejo de flujos de caracteres.

A la cabeza de la jerarquía de flujo de caracteres están las clases abstractas Reader y Writer. Todos los
métodos pueden lanzar una excepción en caso de error.
6.2 Entrada y Salida Estándar
En Java, la entrada desde teclado y la salida a pantalla están reguladas a través de la clase System. Esta
clase pertenece al package java.lang y agrupa diversos métodos y objetos que tienen relación con el
sistema local. Contiene, entre otros, tres objetos estáticos que son:
System.in: Objeto de la clase InputStream preparado para recibir datos desde la entrada estándar del
sistema (habitualmente el teclado).
System.out: Objeto de la clase PrintStream que imprimirá los datos en la salida estándar del sistema
(normalmente asociado con la pantalla).
System.err: Objeto de la clase PrintStream. Utilizado para mensajes de error que salen también por
pantalla por defecto.
6.3 Método para leer un caracter de teclado
char c;
c=(char)System.in.read();
Este método lanza la excepción java.io.IOException, que se tratará de la siguiente forma:
public class Captura
{ public static void main(String args[]) throws java.io.IOException
{ char letra;
try
{ System.out.println("Presiona una tecla");
letra=(char)System.in.read();
}
catch(java.io.IOException err)
{ System.out.println("Error, de teclado"); }
}//main
}

6.4 Método práctico para leer desde teclado
La mejor forma de leer desde el teclado es usar la clase BufferedReader, la cual soporta un flujo de
entrada desde un buffer de memoria, pero no se puede construir un BufferedReader directamente de
System.in. Primero debe convertirse a un flujo de caracteres a través de la clase InputStreamReader. El
código sería el siguiente:
InputStreamReader teclado = new InputStreamReader(System.in);
BufferedReader entrada =new BufferedReader(teclado);
opc= entrada.readLine();
6.5 Flujos Byte
Los flujos byte están definidos mediante el uso de dos jerarquías de clase, encabezadas por InputStream
y OutputStream. InputStream define las características para los flujos de entrada y OutputStream para los
flujos de salida. A partir de estas dos clases se crean otras clases que ofrecen funcionalidad y manejan
los detalles de la escritura/lectura a varios dispositivos, entre ellas los archivos de disco.
La clase InputStream es una superclase abstracta que proporciona un interface de programación mínimo
y una implementación parcial del canal de entrada. La clase InputStream define métodos para leer bytes
o arrays de bytes, marcar posiciones en el canal, saltar bytes de la entrada, conocer el número de bytes
disponibles para ser leidos y resetear la posición actual dentro del canal. Un canal de entrada se abre
automáticamente cuando se crea.
La clase OutputStream es una superclase abstracta que proporciona un interface de programación
mínimo y una implementación parcial de los canales de salida. Un canal de salida se abre
automáticamente cuando se crea..
Un canal se puede cerrar con close(), o se puede dejar que lo cierre el garbage collector.

Java5

Más contenido relacionado

La actualidad más candente (20)

Destacado (20)

Similar a Java5 (20)

Más de jbersosa (20)

Último (16)

Java5