Qué son las Excepciones
Una excepción es un evento anormal en la ejecución de un programa, un buen programador debería ser capaz de predecir las excepciones que pudieran presentarse en cada parte de su programa y de proporcionarle a dicho programa los mecanismos de recuperación adecuados y de ésta manera construir programas robustos.
Una excepción no tratada, provocará que se detenga la ejecución del programa.
• En Java una excepción es un objeto que avisa que ha ocurrido alguna condición inusual. Existen muchos objetos de excepción predefinidos… ¿y si no está predefinida la excepción que quiero tratar? Pues podremos crear nuestros propios objetos de excepción 😉
Manejo de Excepciones
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
// Ejemplo de tratamiento de excepciones public class EjExcepcionBien { public static void main (String args[]) { int i = 0; String cadenas[] = { "Cadena 1", "Cadena 2", "Cadena 3", "Cadena 4" }; try { for (i=0; i<=4; i++) System.out.println(cadenas[i]); } catch( ArrayIndexOutOfBoundsException ae ) { System.out.println("\nError: Fuera del índice del array\n"); } catch( Exception e ) { // Captura cualquier otra excepción System.out.println( e.toString() ); } finally { System.out.println( "Esto se imprime siempre." ); } } } |
• Como resultado de la ejecución del programa obtendremos:
> java EjExcepcionBien
Cadena 1
Cadena 2
Cadena 3
Cadena 4
Error: Fuera del índice del array
Esto se imprime siempre.
• Recordemos:
1 2 3 4 |
catch( Exception e ) { // Captura cualquier otra excepción System.out.println( e.toString() ); } |
Funciona como un mecanismo general de captura de excepciones, es decir, cualquier excepción no tratada anteriormente es tratada aquí.
MANEJO DE EXCEPCIONES – try
• try
• Define un bloque de código donde se puede generar una excepción. El bloque try va seguido inmediatamente de uno o más bloques catch y opcionalmente de una cláusula finally. Cuando se lanza una excepción el control sale del bloque try actual y pasa a un manejador catch apropiado.
• La sintaxis general del bloque try consiste en la palabra clave try y una o más sentencias entre llaves.
1 2 3 |
try { // Sentencias Java } |
• Se pueden presentar dos situaciones diferentes a la hora de definir el bloque try:
-Podemos tener más de una sentencia que generen excepciones, en cuyo caso podemos definir bloques individuales para tratarlos.
-Podemos tener agrupadas en un mismo bloque try varias sentencias que puedan lanzar excepciones, con lo que habría que asociar múltiples controladores a ese bloque.
Será la decisión del programador utilizar una forma u otra de controlar las excepciones.
MANEJO DE EXCEPCIONES – catch
• catch
• Define el bloque de sentencias que se ejecutarán cuando se haya producido una excepción en un bloque try.
• La sintaxis general de la sentencia catch en Java es la siguiente:
1 2 3 |
catch( TipoExcepcionnombreVariable ) { // sentencias Java } |
• Se pueden colocar sentencias catch sucesivas, cada una controlando una excepción diferente.
• No debería intentarse capturar todas las excepciones con una sola cláusula ya que representa un uso demasiado general y podrían llegar muchas excepciones.
catch( Exception e ) { … } //captura genérica
MANEJO DE EXCEPCIONES – finally
• finally
• El bloque de código definido en finally se ejecuta siempre, haya o no excepción.
• Dicha cláusula o instrucción debe ir siempre después de un bloque “try” y sus respectivos “catch”.
MANEJO DE EXCEPCIONES – throw
• throw
• La sentencia throw se ejecuta para indicar que ha ocurrido una excepción, o lanzamiento de una excepción. La sentencia throw especifica el objeto que se lanzará. La forma general de la sentencia throw es:
throw ObjetoThrowable;
• El flujo de la ejecución se detiene inmediatamente después de la sentencia throw, y nunca se llega a la sentencia siguiente, ya que el control sale del bloque try y pasa a un manejador catch cuyo tipo coincide con el del objeto. Si se encuentra, el control se transfiere a esa sentencia. Si no, se inspeccionan los siguientes bloques hasta que el gestor de excepciones más externo detiene el programa.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
// Ejemplo de tratamiento de excepciones con throw import java.io.*; public class ExcepcionThrow { public static void main (String args[]) { double op1, op2, resd; BufferedReader entrada=new BufferedReader(new InputStreamReader(System.in)); //bucle infinito aunque se produzca una excepción while (true) { try { System.out.println("\n######## Nueva División ########"); System.out.print("\nNumerador: "); op1 = Double.parseDouble(entrada.readLine()); System.out.print("\nDenominador: "); op2 = Double.parseDouble(entrada.readLine()); if (op2 == 0) throw new ArithmeticException(); resd = op1 / op2; System.out.println( "\nResultado: " + Double.toString(resd) ); } catch ( ArithmeticException ae ) { System.out.println("\nError aritmético: " + ae.toString()); } catch( NumberFormatException nfe ) { System.out.println("\nError de formato numérico: " + nfe.toString()); } catch( IOException ioe ) { System.out.println( "\nError de entrada/salida: " + ioe.toString() ); } catch( Exception e ) { // Captura cualquier otra excepción System.out.println( e.toString() ); } } } } |
MANEJO DE EXCEPCIONES – throws
• throws
• Con throwsun método lista las excepciones que puede lanzar, y que no va a manejar. Esto sirve para que todos los métodos que lo llamen puedan colocar protecciones frente a esas excepciones.
• Para la mayoría de las subclases de la clase Exception, el compilador Java obliga a declarar qué tipos de excepciones podrá lanzar un método.
• Si un método lanza explícitamente una instancia de Exception o de sus subclases, se debe declarar su tipo con la sentencia throws. La declaración del método sigue ahora la sintaxis siguiente:
tipo nombreMetodo( argumentos ) throws excepciones { … }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
// Ejemplo de tratamiento de excepciones con throws import java.io.*; public class ExcepcionThrows { public static void main (String args[]) { double op1, op2, resd; //bucle infinito aunque se produzca una excepción while (true) { try { System.out.println("\n######## Nueva División ########"); System.out.print("\nNumerador: "); op1 = capturanum(); System.out.print("\nDenominador: "); op2 = capturanum(); if (op2 == 0) throw new ArithmeticException(); resd = op1 / op2; System.out.println( "\nResultado: " + Double.toString(resd) ); } catch ( ArithmeticException ae ) { System.out.println("\nError aritmético: " + ae.toString()); } catch( NumberFormatException nfe ) { System.out.println("\nError de formato numérico: " + nfe.toString()); } catch( IOException ioe ) { System.out.println( "\nError de entrada/salida: " + ioe.toString() ); } catch( Exception e ) { // Captura cualquier otra excepción System.out.println( e.toString() ); } } } public static double capturanum() throws NumberFormatException, IOException { BufferedReader entrada= new BufferedReader(new InputStreamReader(System.in)); String txt = entrada.readLine(); double num = Double.parseDouble(txt); return num; } } |
EXCEPCIONES DEFINIDAS POR EL USUARIO
• También podemos lanzar nuestras propias excepciones, extendiendo la clase Exception.
• El siguiente programa hace uso de una excepción definida por el usuario. El programa realiza la media de una serie de notas introducidas por el usuario, cuando este intenta poner una nota inferior a 0 o superior a 10, salta la excepción NotaMal. También se han tenido en cuenta otras posibles excepciones predefinidas como errores de formato numérico, errores de entrada salida, etc.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
// Notas.java import java.io.*; public class Notas { public static void main( String args[] ) { double media=0, total=0, notanum=0; int contador=0; String notatxt=""; BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in)); while ( ! notatxt.equals("Z") ) { try { System.out.print( "\nTeclee calificación (0-10), Z para terminar: " ); notatxt = entrada.readLine().toUpperCase(); notanum = Double.valueOf(notatxt).doubleValue(); if (notanum < 0 || notanum > 10) throw new NotaMal(); total += notanum; contador = contador + 1; } catch (NotaMal nm) { System.out.println( "\n" + nm.getMessage() ); } catch( NumberFormatException nfe ) { if ( ! notatxt.equals("Z") ) System.out.println("\nError de formato numérico: " + nfe.toString()); } catch( IOException ioe ) { System.out.println( "\nError de entrada/salida: " + ioe.toString() ); } catch( Exception e ) { // Captura cualquier otra excepción System.out.println( e.toString() ); } } if ( contador != 0 ) { media = (double) total / contador; System.out.println( "\nEl promedio del grupo es: " + media ); } else { System.out.println( "\nNo se introdujeron calificaciones." ); } } class NotaMal extends Exception { public NotaMal() { super( "Excepción definida por el usuario: NOTA INCORRECTA." ); } } } |
Arthur Van Wolfenstein liked this on Facebook.
Gerardo Molina liked this on Facebook.
Oh es un lindo plugin llamado Crayon Sintax Highlighter
Marcela Sena liked this on Facebook.
Israel García Herrera liked this on Facebook.
Que bonito 🙂 que usas para dar formato al código que pones en tu pag?