sábado, 14 de julio de 2012

4.1.2. Creación de Excepciones


Revisando Excepciones Existentes
Entre algunas de las excepciones ya definidas en el sistema más conocidas están:
NullPointerException
Se produce cuando se intenta acceder a una variable o método antes de ser definido:
public class Ejemplo {
   String hola;
   public static void main(String[] args) {
        System.out.println(hola);
   }
}
IncompatibleClassChangeException
El intento de cambiar una clase afectada por referencias en otros objetos, específicamente cuando esos objetos todavía no han sido recompilados.
ClassCastException
El intento de convertir un objeto a otra clase que no es válida.
y = (ClaseA)x;      // donde x no puede ser de tipo ClaseA
NegativeArraySizeException
Puede ocurrir si hay un error aritmético al cambiar el tamaño de un arreglo.
OutOfMemoryException
¡No debería producirse nunca!, pero sucede con el intento de crear un objeto con el operador new y este ha fallado por falta de memoria. Y siempre tendría que haber memoria suficiente porque el garbage collector se encarga de proporcionarla al ir liberando objetos que no se usan y devolviendo memoria al sistema.
NoClassDefFoundException
Se hizo referencia a una clase que el sistema es incapaz de encontrar.
ArrayIndexOutOfBoundsException
Es la excepción que más frecuentemente se produce. Se genera al intentar acceder a un elemento de un arreglo más allá de los límites definidos inicialmente para ese arreglo. Ejemplo:
  int arreglo[] = new int[5];
  arreglo[5] = 100;   // no puede ser ya que solo existen del cero al cuatro

Creando Excepciones

Un programador puede crear excepciones propias en Java, las cuales pueden ser utilizadas en diferentes aplicaciones.
Las Excepciones se pueden crear, es decir puede haber excepciones definidas para que sean utilizadas en algunas aplicaciones en las que podemos incurrir en ellas, esto puede ser definido en alguna compañía en la que trabajemos, o por un mismo programador que desarrolle software en el que se desee reutilizar código.
Una manera fácil de manejar excepciones nuevas sería la de siempre hacerlas subclases de Throwable, como se muestra a continuación:
public class MiExcepcion extends Throwable {
     public MiExcepcion() {
        System.out.println("Se arrojo excepción mía");
     }
}
Con esto, las excepciones de MiExcepcion pueden ser lanzadas, declaradas y atrapadas como en el siguiente ejemplo:
import java.io.*;
public class AplicacionExcepcion5 {

 public static void metodo(String s) throws MiExcepcion {     if ("feliz".equals(s)) {
   System.out.println("Son iguales.");
    } else {
   throw new MiExcepcion(); //se lanza
  }
 }

 public static void main(String[] args) throws IOException,
MiExcepcion {
  BufferedReader in =
   new BufferedReader(new InputStreamReader(System.in));

  String s;
  System.out.println("Da la palabra");
  s = in.readLine();
  metodo(s);
 }
}
En este ejemplo observamos que si la palabra dada por el usuario coincide con feliz entonces se desplegará el mensaje son iguales, y la aplicación terminará normalmente, por otro lado si la palabra no concuerda con feliz, entonces se lanzará la excepción MiExcepcion y el mensaje se arrojo excepción mía será desplegado, veamos la ejecución en ambos casos:
Throw
La instrucción throw puede ser utilizada para lanzar una excepción ya sea propia o del sistema, es decir nosotros podríamos decir throw ArithmeticException, así como pusimos throw MiExcepcion, claro que no tendría razon que lanzáramos una excepción, lo importante es atraparla, es decir tener el try/catch correspondiente para cada una de las excepciones que podamos llegar a tener en nuestra aplicación o applet.
Aplicaciones con el uso de Excepciones
Revisemos algunas aplicaciones pasadas que pudieran tener errores, cuyos errores pudieran ser ahora corregidos con el uso del try/catch, veamos el applet que utilizaba un arreglo:
import java.awt.*;
import java.applet.*;
import java.awt.event.*;
// <applet width="400" height="200" code="AppletArreglos1"></applet>
public class AppletArreglos1 extends Applet implements ActionListener{
    Label l1, l2;
    Button b1, b2,b3,b4;
    TextField t1;
    TextArea ta1;
    int arreglo[];
    int conta;
       public AppletArreglos1() {
  l1 = new Label("Dato a Añadir");
  l2 = new Label("Texto para ver Arreglo");
  t1 = new TextField();
  ta1 = new TextArea(10,12);
  b1 = new Button("Añade");
  b2 = new Button("Muestra Vector");
  b3 = new Button("Limpia Vector");
  b4 = new Button("Limpia Campos");
  add(l1);
  add(t1);
  add(l2);
  add(ta1);
  add(b1);
  add(b2);
  add(b3);
  add(b4);
  b1.addActionListener(this);
  b2.addActionListener(this);
  b3.addActionListener(this);
  b4.addActionListener(this);
  arreglo = new int[100];
  conta=0;
     }
     
    public void actionPerformed(ActionEvent ae) {
        if (ae.getSource() == b1) {
            if (conta > arreglo.length) {
                ta1.setText("No se puede añadir otro elemento");
            }
            else {
                arreglo[conta++] = Integer.parseInt(t1.getText());
                t1.setText("");   
            }
         }
         if (ae.getSource() == b2) {
               ta1.setText("");
               for (int i=0; i < conta; i++) {
                   ta1.append("" + arreglo[i] + "\n");
               }
         }
         if (ae.getSource() == b3) {
               conta = 0;
               arreglo = new int[100];
         }
         if (ae.getSource() == b4) {
    t1.setText("");
    ta1.setText("");
         }
    }
}
Si revisamos el applet podemos ver el problema de no validar si el dato que se teclea es un número, lo cual nos puede dar un error de ejecución,  como lo vemos en el ejemplo:
 
La mejor forma de revisarlo es usar el try/catch para que esto no funcione, como se indica:
import java.awt.*;
import java.applet.*;
import java.awt.event.*;
public class AppletArreglos1 extends Applet implements ActionListener{
    Label l1, l2;
    Button b1, b2,b3,b4;
    TextField t1;
    TextArea ta1;
    int arreglo[];
    int conta;
       public AppletArreglos1() {
  l1 = new Label("Dato a Añadir");
  l2 = new Label("Texto para ver Arreglo");
  t1 = new TextField();
  ta1 = new TextArea(10,12);
  b1 = new Button("Añade");
  b2 = new Button("Muestra Vector");
  b3 = new Button("Limpia Vector");
  b4 = new Button("Limpia Campos");
  add(l1);
  add(t1);
  add(l2);
  add(ta1);
  add(b1);
  add(b2);
  add(b3);
  add(b4);
  b1.addActionListener(this);
  b2.addActionListener(this);
  b3.addActionListener(this);
  b4.addActionListener(this);
  arreglo = new int[100];
  conta=0;
     }
     
    public void actionPerformed(ActionEvent ae) {
        if (ae.getSource() == b1) {
            if (conta > arreglo.length) {
                ta1.setText("No se puede añadir otro elemento");
            }
            else {
             try {
              int numero = Integer.parseInt(t1.getText());
                  arreglo[conta++] = numero;              
             }
             catch(NumberFormatException nfe) {
              ta1.setText("invalido " + nfe.toString());
             }
                t1.setText("");   
            }
         }
         if (ae.getSource() == b2) {
               ta1.setText("");
               for (int i=0; i < conta; i++) {
                   ta1.append("" + arreglo[i] + "\n");
               }
         }
         if (ae.getSource() == b3) {
               conta = 0;
               arreglo = new int[100];
         }
         if (ae.getSource() == b4) {
    t1.setText("");
    ta1.setText("");
         }
    }
}
 
Observamos en el try, que únicamente después de la instrucción que puede dar la excepción, es que se añade el valor al arreglo, de tal manera que hacemos que sea solo un valor adecuado.

No hay comentarios:

Publicar un comentario en la entrada