try, cathc, finally

S.k. Exceptions, undantag, kastas ifall någonting går fel i koden. T.ex. kan det vara att man försöker konvertera en sträng till siffror, fylla en plats i en array där platsen inte finns (överskrider index), m.m. m.m. Undantag används mycket inom Java-programmeringen och det finns massvis av olika Exception-klasser. Om du inte då fångar dina undantag och rättar till dem, kan det således bli fel i programmet och det kan i vissa fall dö helt. Try-catch-block är därför en smidig lösning för att få en bättre kontroll över programflödet.

Det är inte så himla svårt egentligen... Man binder in koden som kan kasta undantag inuti try-blocket, och om det kastas ett undantag hanteras det i catch-blocket.

Som exempel kan vi använda ett Array-exempel, där ett ArrayIndexOutOfBoundsException kastas.

public class Test {
     public static void main( String[] argv ) {
          String[] sArr = new String[10];

          try {
               sArr[9] = "Wee!";
               sArr[10] = "Det här kommer inte funka, index 10 finns ju inte!";
          } catch( ArrayIndexOutOfBoundsException e ) {
               System.out.println( "Nu kastades ett Exception!" );
          }
     }
}

När vi försöker fylla index 10 med data, kommer ett undantag att kastas, eftersom att index 10 inte finns - det finns bara 10 platser i arrayen och index 9 är den sista platsen (Arrayer börjar alltid på 0 i Java, således finns bara platserna 0-9). Det fångas sedan i catch-blocket och vi skriver ut vad som händer på skärmen.

finally-block används tillsammans med try-catch, och innebär att vad som än händer så ska koden i finally-blocket exekveras.

Fotnot, ArrayIndexOutOfBoundsException är av typen RuntimeException, vilket innebär att programmet dör om undantaget inte fångas!

Här finns fler exempel
http://java.sun.com/docs/books/tutorial/essential/exceptions/
http://java.sun.com/docs/books/tutorial/essential/exceptions/handling.html

Det här med finally kan möjligen behöva mer förklaring. Tyvärr kan jag inte komma på något riktigt vettigt exempel så det får bli ett knasigt ett.

public class Knapsack {

  private Vector sack;
  private int moves;

  public void add(Knapsack K) {
     //....
  }

  //Tömmer innehållet till en ny Knapsack
  public boolean moveTo(Knapsack K) {
     while (!empty()) {
           K.add(sack.remove(0));
     }
     moves++;
  }

}

Om denna kod anropas med en existerande Knapsack så är allt frid och fröjd. Men om det i anropet skickas med null, så kommer exekveringen att kasta ett Exception här: K.add.... Det finns (naturligtvis) ingen metod add i null.

Om du nu vill fånga det fallet och i så fall behålla allt i denna Knapsack tex:

  //Tömmer innehållet till en ny Knapsack
  public boolean moveTo(Knapsack K) {
     try {
       while (!empty()) {
           K.add(sack.remove(0));
       }
       moves++;
     }
     catch(Exception e) {/* gör detta om K är null */ }
  }

Nu kraschar inte programmet om K var null, men eftersom körningen hoppade från K.add till catch-satsen så har moves inte uppdaterats heller. OM vi nu faktiskt vill att moves ska uppdateras under alla omständigheter så fixas det genom:

  //Tömmer innehållet till en ny Knapsack
  public boolean moveTo(Knapsack K) {
     try {
       while (!empty()) {
           K.add(sack.remove(0));
       }
     }
     catch(Exception e) {/* gör detta om K är null */ }
     finally() { moves++; }
  }