Diferència entre revisions de la pàgina «DAM-M3-UF5. Control d'excepcions»

Revisió del 16:27, 6 set 2012

torna M3 - Programació

Excepcions

Una excepció és un esdeveniment anòmal (imprevist) durant l’execució d’un programa que es pot tractar per evitar la finalització del programa.

No s’ha de confondre les excepcions amb els errors, aquests són irrecuperables, fruit d'una implmentació incorrecte i haurien de finalitzar el programa.

Java controla múltiples tipus d’excepcions, apuntador a null, array fora de límits, etc.. i també permet definir-ne de pròpies.

Així les excepcions segueixen també l'arbre d'herència de Java, alguns exemples

• NullPointerException
• IndexOutOfBoundsException
• ClassCastException

http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/RuntimeException.html

Try / Catch / Finally

El control d’excepcions serveixen per gestionar els errors en temps d’execució i evitar la finalització del programa en situacions anòmales.

El programa executa les instruccions interiors a try, si es produeix qualsevol error llança una excepció que captura catch, i així podem controlar l’error sense finalitzar el programa de manera forçosa.

No s'executa cap instrucció dins del try posterior a la que genera un error.

Les instruccions dins el finally s’executen sempre hi hagi o no excepció.

    public static void main(String[] args) {
        int opcio;
        try {
            opcio = Integer.parseInt(args[0]);   

              switch(opcio) {
                case 0: System.out.println("Has introduït 0");
                         break;
                case 1: System.out.println("Has introduït 1");
                           break;
                default: System.out.println("????");
            }
        } catch (Exception e) {
            System.out.println("Error en els paràmetres --> " + args[0]);
                   System.exit(0);
        } finally {
            System.out.println( "Final" );
        }
    }

throw / throws

La instrucció throw permet llençar excepcions pròpies.

    public static void prova() {
        throw new NullPointerException("Texte de l’excepcio");
    }   

    public static void main(String[] args) {
        try {
            prova();
            System.out.println("No s'executa mai");
        } catch (Exception e) {
            System.out.println("Error " + e.getMessage());
        }
    }

El paràmetre throws s’indica en un mètode si aquest llença excepcions que no controla (Sense try / catch).

Serveix per advertir als altres mètodes que l’invoquen de les excepcions que aquest pot produir.

L'ús de certs mètodes marcats amb throws obliga a controlar l'excepció

• Opció 1. Usant try/catch
• Opció 2. Marcant el propi mètode com a throws

    public static void prova1() throws Exception {
        throw new NullPointerException("Texte de l’excepcio 1");
    }   

    public static void prova2() throws NullPointerException {
        throw new NullPointerException("Texte de l’excepcio 2");
    }   

   
    public static void main(String[] args) {
       
        int opcio = Integer.parseInt(args[0]);
       
        prova1();    // Error
         
        try {
            prova2();
            System.out.println("No s'executa mai");
        } catch (Exception e) {
            System.out.println("Error " + e.getMessage());
        }
    }

Propagació d'Excepcions

Així les excepcions es propaguen en la pila de crides a mètodes fins que algú les captura (try / catch) o bé arriben a la crida principal i finalitzen l'execució.

Per exemple suposa la següent pila de crides a mètodes

primer() => segon() => tercer()

En cas d’error en la crida tercer() l’excepció es propagarà a les altres crides descendentment fins que alguna el capturi o arribi al programa principal.

    public static void main(String[] args) {
        primer();
    }
   
    public static void primer() {
        segon();
    }
   
    public static void segon() {
        throw new NullPointerException();
    }