wiki.smarken.dk

Undtagelser kan fanges og håndteres. Det gøres ved at indkapsle den kritiske kode i en try-blok og behandle eventuelle undtagelser i en catch-blok:

try 
  { //...                     // programkode hvor der er en risiko//  //...                     // for at en undtagelse opstår// }
  catch ( //Undtagelsestype// u) ////// Undtagelsestype //er f.eks. Exception// { //...                     // kode som håndterer fejl af//  //...                     // typen// Undtagelsestype
  } //...                     // dette udføres både hvis ingen undtagelse opstod//  //...                     // og hvis der opstod fejl af typen// Undtagelsestype

Når programmet kører normalt, springes catch-blokken over. Hvis der opstår undtagelser i try-blokken, hoppes ned i catch-blokken, der håndterer fejlen, og derefter udføres koden efter catch.

Undtagelsestypen bestemmer, hvilke slags undtagelser der fanges.

Man kan fange alle slags ved at angive Exception eller en bestemt slags undtagelser, f.eks. ArrayIndexOutOfBoundsException.

Ser vi på vores Vector-eksempel igen, kunne det med undtagelseshåndtering se sådan ud:

import java.util.*;
public class SimpelUndtagelse2
{
  public static void main(String[] args)
  {
    System.out.println("Punkt A"); //// pkt. A//  //try//  //{// Vector v = new Vector();
      System.out.println("Punkt B"); //// pkt. B// v.elementAt(5);
      System.out.println("Punkt C"); //// pkt. C//  //}//  //catch (Exception u)//  //{//  //System.out.println("Der opstod en undtagelse!");//  //}// System.out.println("Punkt D"); //// pkt. D// }
}

Resultatet bliver

Punkt A
Punkt B
Der opstod en undtagelse!
Punkt D

Læg mærke til, at punkt C (der ligger i try-blokken efter, at undtagelsen opstod) ikke bliver udført. Punkt D (efter catch-blokken) bliver udført under alle omstændigheder.

En undtagelse er ligesom alt andet i Java repræsenteret ved et objekt, og en reference til dette overføres som parameter til catch-blokken.

Objektet har nyttige informationer om fejlen. Metoden printStackTrace() udskriver et stakspor (eng.: stack trace), der beskriver de metodekald, der førte til, at undtagelsen opstod:

...
    catch (Exception u)
    {
      System.out.println("Der opstod en undtagelse!"); //u.printStackTrace()// ;
    }
    ...

Resultatet bliver

Punkt A
Punkt B
Der opstod en undtagelse!
java.lang.ArrayIndexOutOfBoundsException: 5 >= 0
        at java.util.Vector.elementAt(Vector.java:441)
        at SimpelUndtagelse2.main( //SimpelUndtagelse2.java:11// )
Punkt D

Staksporet er nyttigt, når man skal finde ud af, hvordan fejlen opstod. Det viser præcist, at undtagelsen opstod i elementAt() i Vector, som blev kaldt fra SimpelUndtagelse2.java i main()-metoden linje 11.