Gestión de excepciones en Java

/* Se consignan diversos ejemplos donde puede verse cómo implementar la gestión de excepciones: manejo de try/catch, uso de throws/throw, y posible aplicación en corrección de datos. */

package excepciones1;

//El objetivo es definir cuatro versiones distintas de un mismo
//método cambiando, en cada caso, la forma de gestionar las
//excepciones que se puedan producir.

import java.util.Scanner;

/*
 * @authors ARF, RLR
 */

public class Main {
    public static void main(String[] args) 
    {
        int opcion;
        Scanner miTeclado = new Scanner(System.in);

        //Array de string que usamos como ejemplo
        String[] x = {"1", "a","-2", "asdf", null , "4", "rst", "5"};
        String[] y = {"1", null, "2", "-10", null , "4", "rst", "5"};

        System.out.println("Tratamiento de excepciones");
        System.out.println("--------------------------");
        System.out.println("1.- Ningun tratamiento especial");
        System.out.println("2.- try...catch");
        System.out.println("3.- throws/throw");
        System.out.println("4.- Definir excepciones especificas");
        System.out.println();
        System.out.println("Elige un numero: ");
        opcion = miTeclado.nextInt();
        System.out.println();
        switch(opcion)
        {
            case 1:
                //utiliza el método suma1
                System.out.println("El resultado de la suma es: "+suma1(x));
                break;

            case 2:
                //ver la diferencia entre métodos suma2 o suma2bis
                System.out.println("El resultado de la suma es: "+suma2(y));
                break;

            case 3:
                //utiliza el método suma3
                try
                {
                  System.out.println("El resultado de la suma es: "+suma3(x));
                }
                catch(Exception e)
                //catch(MiExcepcion e)    
                {                    
                  System.out.println("Excepcion capturada: " + e.getMessage());
                  //System.out.println("ELEMENTO: " + e.getIndice());
                  //e.printStackTrace();
                }                   
                break;

            case 4:
                //utiliza el método suma4
              boolean error=false;
              do
              {
                try
                {
                  System.out.println("El resultado de la suma es: "+suma4(x));
                  error=false;
                }
                catch(MiExcepcion e)  
                {  
                  error = true;  
                  System.out.println("Excepcion -> " + e.getMessage());
                  System.out.println("Da un nuevo numero: ");
                  x[e.getIndice()]=String.valueOf(miTeclado.nextInt());
                }
              }while(error);

              break;

              default:
                System.out.println("No es una opcion valida");
        }

        System.out.println("FIN-FIN");
        System.out.println("\n\nPulsa Tecla+Return para acabar.\n");
        String FIN=miTeclado.next();
    }

    //Sin ningún tratamiento especial
    public static String suma1(String[] datos) 
    {
        int res = 0;
        for (int i=0; i<datos.length; i++) 
        {
            int aux = Integer.parseInt(datos[i]);
            if (aux<0) 
            {
                System.out.println(datos[i] + " es negativo");
                System.out.println();
            }
            else
                res = res + aux;            
        }

        return String.valueOf(res);
    }

    //Usando la instrucción try...catch    
    public static String suma2(String[] datos) 
    {
        int res = 0;
        for (int i=0; i<datos.length; i++) 
        {
            try 
            {
                int aux = Integer.parseInt(datos[i]);
                if (aux<0) 
                {
                    System.out.println(datos[i] + " es negativo");
                    System.out.println();
                }
                else
                    res = res + aux;
            } 
            catch (NumberFormatException e) 
            {
                System.out.println("Excepcion capturada: " + e.getMessage());
                //e.printStackTrace();
            }
            //finally{ System.out.println("HOLA");}
        }

        return String.valueOf(res);
    }

    //Método suma2bis como el anterior cuyo bucle se detiene
    //al localizar una componente del array datos que no contiene un entero.    
    public static String suma2bis(String[] datos) 
    {
        int res = 0;
        try
        {
          for (int i=0; i<datos.length; i++) 
          {
                int aux = Integer.parseInt(datos[i]);
                if (aux<0) 
                {
                    System.out.println(datos[i] + " es negativo");
                    System.out.println();
                }
                else
                    res = res + aux;                
          } 
        }
        catch (NumberFormatException e) 
        {
                System.out.println("Excepcion capturada: " + e.getMessage());
                //e.printStackTrace();
        }

        return String.valueOf(res);
    }

    //Se implementa suma3 de modo similar a suma1, pero lanzando
    //cualquier tipo de excepción cuando se detecta un entero negativo.
    //En el programa principal se invoca este método capturando las expceciones
    //que puede lanzar.

    public static String suma3(String[] datos) 
            throws Exception 
    {
        int res = 0;
        for (int i=0; i<datos.length; i++) 
        {        
            int aux = Integer.parseInt(datos[i]);
            if (aux<0) 
            {
                System.out.println(datos[i] + " es negativo");
                throw new Exception(datos[i] + " es negativo"); //CORTA LA EJECUCION
            }
            else
                res = res + aux;
          }                                     

        return String.valueOf(res);    
      }

       public static String suma3bis(String[] datos) throws MiExcepcion 
       {
        int res = 0;
        for (int i=0; i<datos.length; i++) 
        {
          try
          {
            int aux = Integer.parseInt(datos[i]);
            if (aux<0) 
            {
                System.out.println(datos[i] + " es negativo");
                throw new MiExcepcion("Numero negativo ",i); //CORTA LA EJECUCION
            }
            else
                res = res + aux;
          }                    
          catch (NumberFormatException e) 
          {
                  System.out.println("Excepcion capturada: " + e.getMessage());
                  //e.printStackTrace();
          }
          finally{}                     
         }

        return String.valueOf(res);
       }

    //Se implementa suma4 de modo similar a suma2, pero capturando
    //las posibles excepciones NullPointerException y NumberFormatException.
    //En los correspondientes bloques catch (¿cuántos son necesarios?)
    //no tratamos, en realidad, el problema, sino que transformamos la
    //excepción lanzando una nueva de la clase MiExcepcion.
    //En el programa principal se invoca este método capturando todas las
    //posibles excpeciones y solicitando al usuario que introduzca por
    //teclado un valor correcto cuando se descubre uno erróneo en el array.

    public static String suma4(String[] datos) throws MiExcepcion 
       {
        int res = 0;
        for (int i=0; i<datos.length; i++) 
        {
          try
          {
            int aux = Integer.parseInt(datos[i]);
            if (aux<0)              
                throw new MiExcepcion("Numero negativo en lugar " +(i+1), i); 
            else
                res = res + aux;
          }                    
          catch (NumberFormatException e) 
          {
                  throw new MiExcepcion("No hay numero en lugar "+(i+1), i);
                  //e.printStackTrace();
          }
          catch (NullPointerException e) 
          {
                  throw new MiExcepcion("No hay numero en lugar "+(i+1), i);
                  //e.printStackTrace();
          }

         }

        return String.valueOf(res);
       }

}

//Definición, por herencia, de un nuevo tipo de excepción.
 class MiExcepcion extends Exception {
    private int indice;

    public MiExcepcion(String texto, int i) 
    {
        super(texto);
        indice = i;
    }

    public int getIndice() { return indice; }
}
Esta entrada fue publicada en Ciencia y programación. Guarda el enlace permanente.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s