Your SlideShare is downloading. ×
Gestión eficiente de errores: Excepciones en Java.
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Gestión eficiente de errores: Excepciones en Java.

4,392
views

Published on

- como responder a las excepciones que se produzcan …

- como responder a las excepciones que se produzcan
- como crear métodos que puedan ignorar esas excepciones, dejando que sea otra clase la que las maneje
- como usar métodos que provoquen ellos mismos excepciones
- como podemos crear excepciones propias

Published in: Technology

1 Comment
1 Like
Statistics
Notes
No Downloads
Views
Total Views
4,392
On Slideshare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
Downloads
69
Comments
1
Likes
1
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Gestión eficiente de errores: Caso práctico de Excepciones en Java PUA Mascheroni, Maximiliano Agustín
  • 2. Tratamiento de problemas en tiempo de ejecución
    • En el mundo de la programación hay algo que siempre ocurre: los errores en los programas. En algunos casos estos hasta resultan inevitables, por ejemplo por algún problema de tipeo: se ingresan letras cuando el programa espera recibir números, escribir alguna letra de más, etc.
  • 3.  
  • 4. Definición
    • Una excepción es un evento que ocurre durante la ejecución del programa que interrumpe el flujo normal de las sentencias, es decir, algo que altera la ejecución normal. Cuando hablamos del manejo de excepciones, nos referimos a un modo de tratar distintos tipos de errores que impiden que un programa se ejecute correctamente.
  • 5.
    • Veremos:
    • - como responder a las excepciones que se produzcan
    • - como crear métodos que puedan ignorar esas excepciones, dejando que sea otra clase la que las maneje
    • - como usar métodos que provoquen ellos mismos excepciones
    • - como podemos crear excepciones propias
  • 6.
    • En la mayoría de los lenguajes de programación utilizábamos condicionales para avisarle al usuario que se ha producido algún tipo de error.
    • Por ejemplo: si deseamos realizar una división, teníamos que asegurarnos de que el denominador sea distinto de 0.
  • 7.
    • Entonces un ejemplo de pseudocódigo para esta situación sería:
    • Comienzo;
    • Escribir “Ingrese numerador”;
    • Leer num;
    • Escribir “Ingrese denominador”;
    • Leer deno;
    • si (deno <> 0){
    • resultado = num/deno;
    • Escribir resultado;
    • }sino{
    • Escribir “Denominador debe ser distinto de 0”;
    • }//fin si
    • Fin;
  • 8. Comprobación de estados
    • La comprobación de estados hace referencia a las condiciones que deben cumplir los estados de ciertos objetos antes o después de realizar una operación. Con la comprobación de estados se busca evitar o minimizar la posibilidad de que un objeto quede en estado inválido, por no haber terminado correctamente una tarea que afecta al objeto. Este problema puede ser enfocado de dos maneras: en forma conservadora, o en forma optimista.
  • 9. Enfoque conservador
    • Al enfoque conservador de comprobación de estados se lo puede caracterizar como: comprobar primero, actuar después. La idea de este enfoque es comprobar que se cumple la precondición y realizar la tarea solamente en ese caso. Este enfoque abarca tres tipos de soluciones:
    • - rechazo: si no se cumplen las condiciones no se realiza la operación, enviando algún tipo de aviso al usuario o al módulo invocante.
    • - suspensión protegida: se espera a que la precondición sea verdadera para realizar la acción.
    • - plazos temporales: corresponden a una suspensión protegida, pero limitada a un intervalo de tiempo (en contextos concurrentes) o a un número de intentos, pasando luego al rechazo.
  • 10. Enfoque Optimista
    • El enfoque optimista consiste en intentar primero, analizar después. Se realiza la operación independientemente de que se pueda hacer o no. Y si durante la ejecución surge un problema o al final de la misma no se cumple una poscondición necesaria, se intenta resolver el inconveniente.
  • 11.
    • Pero cuando hablamos de Java existe una técnica mejor para trabajar con circunstancias excepcionales que puedan producirse al ejecutarse un programa. Consiste en el uso de un conjunto de clases que se denominan justamente así, EXCEPTIONS. Éstas permiten manejar errores cuando se produzcan y probablemente darles una solución
    • Por lo tanto, podemos decir que Java cuenta con su propio sistema para el manejo de errores y condiciones excepcionales en la ejecución de programas. Una serie de características que realizan comprobaciones en tiempo de ejecución del programa y que utilizan dichas clases.
  • 12. Ventajas del manejo de Excepciones
    • Separar el Manejo de Errores del Código &quot;Normal“. Estará en una zona separada donde podremos tratar las excepciones como un código ‘especial’.
    • Propagar los Errores sobre la Pila de Llamadas. Podemos propagar el error a la primera función que llamó a las diversas funciones hasta que llegamos al error.
    • Agrupar Errores y Diferenciación. Gracias a esto tenemos todos los posibles errores juntos y podemos pensar una manera de tratarlos que sea adecuado.
  • 13.  
  • 14.
    • http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Exception.html
  • 15.
    • Vamos a ver un primer ejemplo de excepción muy simple, en el cual tenemos un programa Java que compila correctamente, pero en el momento en el que lo ejecutamos encuentra algún tipo de problema.
    • public class ArraySimple {
    • public static void main(String[] arguments) {
    • String[] carreras = { &quot;LSI&quot;, &quot;CE&quot;, &quot;LAE&quot; };
    • System.out.println(carreras[3]);
    • }
    • }
  • 16.
    • Veamos un nuevo ejemplo.
    • public class Sumador {
    • public static void main(String[] arguments) {
    • float sum = 0;
    • for (int i = 0; i < arguments.length; i++) {
    • sum = sum + Float.parseFloat(arguments[i]);
    • }
    • System.out.println(&quot;Esos números suman un total de: &quot; + sum);
    • }
    • }
  • 17. Capturar y Manejar Excepciones
    • try: e l primer paso en la escritura de un manejador de excepciones es poner la sentencia Java dentro de la cual se puede producir la excepción dentro de un bloque try . Es el bloque de código donde se prevé que se genere una excepción.
    • catch: es si se produce la excepción, en este bloque irá el código que se debe ejecutar en tal caso.
    • • Si no se produce la excepción, el código se ejecutará normalmente.
  • 18.  
  • 19.
    • Entonces, la aplicación anterior quedará modificada con los bloques try-catch de la siguiente manera:
    • public class NuevoSumador {
    • public static void main(String[] arguments) {
    • float sum = 0;
    • for (int i = 0; i < arguments.length; i++) {
    • try {
    • sum = sum + Float.parseFloat(arguments[i]);
    • } catch (NumberFormatException e) {
    • System.out.println(arguments[i] + &quot; no es un número.&quot;);
    • }
    • }
    • System.out.println(&quot;Esos números suman un total de &quot; + sum);
    • }
    • }
    • Si se produce la excepción en el bloque try al intentar convertir a float un carácter no válido, el bloque catch se encargará de capturar la excepción y devolverle un mensaje al usuario.
  • 20.
    • Hemos visto que podemos capturar una excepción y poder manejarla utilizando los bloques try-catch. Sin embargo, también nos permiten capturar y tratar más de una excepción de distintos tipos, incluso si son lanzadas por declaraciones diferentes, es decir, no tiene porque haber un único catch. En este caso, tendremos tantos catchs como excepciones queramos lanzar.
    • Continuaremos con otra aplicación muy sencilla, que toma dos argumentos de tipo Integer, ingresados como parámetros del método main y los utilizaremos para llevar a cabo una división. Pero a diferencia del ejemplo anterior, ésta aplicación debe ser capaz de poder tratar con dos problemas potenciales en las entradas de los usuarios. Por un lado que los argumentos sean no numéricos, y por lo tanto no van a poder ser operados; por el otro, que el denominador sea 0 y por ende, no se pueda realizar la división.
  • 21.
    • public class Division {
    • public static void main(String[] arguments) {
    • if (arguments.length == 2) {
    • int resultado = 0;
    • try {
    • resultado = Integer.parseInt(arguments[0]) /
    • Integer.parseInt(arguments[1]);
    • System.out.println(arguments[0] + &quot; dividido por &quot;
    • + arguments[1] + &quot; igual a &quot; + resultado);
    • } catch (NumberFormatException e) {
    • System.out.println(&quot;Ambos argumentos deben ser números.&quot;);
    • } catch (ArithmeticException e) {
    • System.out.println(&quot;Error: &quot; + e.getMessage());
    • }
    • }
    • }
    • }
    • El método getMessage() nos devuelve el mensaje del tipo de error de la excepción.
  • 22.
    • Cuando estamos tratando con múltiples excepciones usando try-catch, seguro que van a haber ocasiones en las que queramos que el programa haga algo al final del bloque, tanto si ocurre una excepción, como no. Podemos hacer esto utilizando un tercer bloque denominado finally, que nos proporciona un mecanismo que permite a sus métodos limpiarse a si mismos sin importar lo que sucede dentro del bloque try . Se utiliza el bloque finally para cerrar ficheros o liberar otros recursos del sistema después de que ocurra una excepción.
  • 23.  
  • 24.
    • Agregando el bloque finally al ejemplo anterior, nos aseguramos de que se imprima el mensaje colocado dentro del bloque al finalizar el programa.
    • public class Division {
    • public static void main(String[] arguments) {
    • if (arguments.length == 2) {
    • int resultado = 0;
    • try {
    • resultado = Integer.parseInt(arguments[0]) /
    • Integer.parseInt(arguments[1]);
    • System.out.println(arguments[0] + &quot; dividido por &quot;
    • + arguments[1] + &quot; igual a &quot; + resultado);
    • } catch (NumberFormatException e) {
    • System.out.println(&quot;Ambos argumentos deben ser números.&quot;);
    • } catch (ArithmeticException e) {
    • System.out.println(&quot;Error: &quot; + e.getMessage());
    • }
    • finally {
    • System.out.println(&quot;El bloque try-catch ha finalizado. Se ejecuta siempre finally&quot;);
    • }
    • }
    • }
    • }
  • 25. Lanzamiento de Excepciones
    • Muchas veces el programador dentro de un determinado método deberá comprobar si alguna condición de excepción se cumple, y si es así lanzarla. Para ello se utilizan las palabras reservadas  throw  y  throws .
    • Por una parte la excepción se lanza mediante la sentencia  thrown , esta sería la sintaxis:
    • if ( condicion_de_excepcion = = true) throw new miExcepcion();
  • 26.
    • Los constructores de excepciones son siempre dos por defecto: uno sin parámetros, y otro que recibe una cadena de caracteres que se usa para enviar información pertinente, como muestra el ejemplo que sigue:
    • Ejemplo:
    • if (p = = null) throw new NullPointerException();
    • if (p = = null) throw new NullPointerException(&quot;Puntero nulo&quot;);
  • 27.
    • El propósito es disparar una excepción de una clase diferente por cada tipo de anomalía. En general es la propia clase de excepción la que se usa para determinar de qué error se trata por parte de quien la recibe. Por eso es especialmente importante elegir un buen nombre para la clase de excepción. En Java, en la declaración del método se indica qué excepciones arroja, de modo que el cliente de la clase sepa qué excepciones debe manejar. Para ello se usa la cláusula mencionada throws. La idea es que un método lance una excepción a otro método que lo llama desde la misma clase o desde cualquier otra.
  • 28.
    • public static void main(String [] args){
    • try{
    • metodoX();
    • }
    • catch(Exception e){
    • System.out.println(&quot;Se produjo un error en el metodo&quot;);
    • }
    • }
    • public static void metodoX() throws Exception{
    • Scanner teclado = new Scanner(System.in);
    • System.out.println(&quot;Ingrese numero: &quot;);
    • String string = teclado.next();
    • int x = Integer.parseInt(string);
    • System.out.println(&quot;El valor es: &quot;+x);
    • }
    • }
  • 29.  
  • 30. Excepciones Propias
    • Como vimos, el lenguaje Java proporciona las clases que manejan casi cualquier tipo de excepción. Sin embargo, podemos imaginar situaciones en la que se producen excepciones que no están dentro del lenguaje. Para este tipo de situaciones, el programador puede crear sus propias clases de excepciones, indicando con precisión el tipo particular de error que un método puede elevar.
    • Para crear una Clase de Excepcion propia seguimos la siguiente estructura:
    • public class MiExcepcion extends Exception {
    • public MiExcepcion(String msg) {
    • super(msg);
    • }
    • }