DAM-M3-UF5. Control d'excepcions

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 implementació incorrecte o d'algun problema extern, i haurien de finalitzar el programa.

Les excepcions per contra, es poden controlar, Java gestiona múltiples tipus d’excepcions, apuntador a null, array fora de límits, etc.. i també permet definir-ne de pròpies.

Classe Throwable,

• Subclasse Error
• Subclasse Exception
  • Subclasse RunTimeException

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 propaga possibles excepcions que genera un mètode, pròpies o generades pels mètodes que crida.

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

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

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

Propagació d'Excepcions

Les excepcions es propaguen diferent segons:

• Hereten de RunTimeException: Es propaguen automàticament, no és obligatori realitzar cap acció (però pot ser recomanable)
• Hereten de Exception (Però no de RunTimeException): No és automàtic, cal propagar-les o controlar-les
  • L'ús d'aquests mètodes obliga a controlar l'excepció
    • Opció 1. Usant try/catch
    • Opció 2. Marcant el propi mètode com a throws

    public static void prova0() { // Error
        throw new Exception("Texte de l’excepcio");
    }  
   
    public static void prova1() throws Exception { // Ok
        throw new Exception("Texte de l’excepcio");
    }  

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

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

    public static void main(String[] args) {
        prova1();
       
        prova2();
       
        prova3();
    }

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();
    }