< Programmeren in Java

Programmeren in Java

  1. Inleiding
  2. Basis
  3. In- & uitvoer
  4. Stringbewerkingen
  5. Arrays
  6. Collections
  7. Exceptions
  8. Generics
  9. Ingebouwde functies
  10. Multithreading
  11. GUI
  12. JSP: JavaServer Pages

Klassen

  1. Klassen
  2. Overerving
  3. Geavanceerde klassen

Design Patterns

  1. Strategy Pattern

Appendices

  1. Appendix A: Installatie
  2. Appendix B: Javadoc

Excepties in Java maken het mogelijk om net als in sommige andere talen zoals C++ een speciale afhandeling te doen van bepaalde scenario's. Door excepties te gebruiken is het vaak mogelijk om ingewikkelde if-structuren te vermijden.

Een voorbeeld van een exceptie is als je een getal converteert van een stringrepresentatie naar een int. Het kan voorkomen dat de string helemaal geen getal bevat zoals '455', maar een woord bevat zoals 'banaan'. Bij de convertie zal dan een exceptie opgegooid worden.


Try en catch

Als je "risicocode" uitvoert die een fout kan veroorzaken (of in javajargon: een exceptie kan gooien), dien je dit op te vangen in een try-catch-(finally-)blok:

int getal = Integer.parseInt(tekst);

en dient opgevangen te worden aan de hand van een try-en-catch-constructie.

Java-code: korte code

    try {
      int getal = Integer.parseInt(tekst);
      System.out.println("Het is gelukt om " + tekst +  " om te zetten: " + getal);
    } catch (NumberFormatException fout) {
      System.out.println("Het is niet gelukt om " + tekst +  " om te zetten naar een getal.");
    }

In een uitgewerkt programma werkt dat zo:

Java-code: tryAndCatch.java

public class tryAndCatch {
  public static void main(String[] args){
    zetOm("34");
    zetOm("3A");
    zetOm("22");
  }
  public static void zetOm(String tekst) {
    try {
      int getal = Integer.parseInt(tekst);
      System.out.println("Het is gelukt om " + tekst +  " om te zetten: " + getal);
    } catch (NumberFormatException fout) {
      System.out.println("Het is niet gelukt om " + tekst +  " om te zetten naar een getal.");
    }
  }
}
Het is gelukt om 34 om te zetten: 34
Het is niet gelukt om 3A om te zetten naar een getal.
Het is gelukt om 22 om te zetten: 22

Als je probeert code te schrijven die een bepaalde exceptie niet opvangt, dan zal de javacompiler je daarover waarschuwen. Hierboven kan je code zien die een NumberFormatException kan gooien.

finally

Met finally kan je ervoor zorgen dat er, zelfs al treedt er een fout op, toch iets gedaan wordt. In dit geval krijg je altijd een vermenigvuldiging, zelfs al was er een deling door nul.

Java-code: het gooien van een fout

public class Main {
  public static void main(String[] args) {
    int lijst[] = {3, 2, 1, 0, -1};
    int eenGetal = 12;
    for (int i=0;i<lijst.length;i++) 
    {
      try { 
        System.out.println(eenGetal + " / " + lijst[i] +
                           " = " + eenGetal/lijst[i]); 
      }
      catch (ArithmeticException e) {
        System.out.println("Deling door nul (" + e.getMessage() + ")");
      }
      finally {
        System.out.println(eenGetal + " x " + lijst[i] + 
                           " = " + eenGetal * lijst[i]);
      }
    }                     
  }         
}
12 / 3 = 4
12 x 3 = 36
12 / 2 = 6
12 x 2 = 24
12 / 1 = 12
12 x 1 = 12
Deling door nul (/ by zero)
12 x 0 = 0
12 / -1 = -12
12 x -1 = -12

Throws-clausule

Als je een exceptie wenst te gooien om de gebruiker van je functie te informeren over een exceptie die opgetreden is en die enkel afgehandeld kan worden door de aanroeper, kan je het sleutelwoord throws gebruiken. Met deze aanroep kan je dus zelf bestaande excepties opgooien. Ook kan je zelf exceptieklasses maken door deze af te leiden van java.lang.Exception.

De afhandeling van de fout in bovenstaand voorbeeld kan dus ook afgewenteld worden op het hoofdprogramma:

Java-code: het gooien van een fout

  public static void zetOm(String tekst) throws NumberFormatException {
    int getal = Integer.parseInt(tekst);
    System.out.println("Het is gelukt " + tekst +  " om te zetten: " + getal);
  }

Een uitgewerkt voorbeeld ziet er als volgt uit:

Java-code: gooien.java

public class gooien {
  public static void main(String[] args){
    int i = 0;
    String[] rij = {"12","2C","22"};
    for (i = 0; i < rij.length; i++){
      try {
        zetOm(rij[i]);
      } catch (NumberFormatException foutmelding) {
        System.out.println("Het is niet gelukt om " + rij[i] + " om te zetten naar een getal.");
      }
    }
  }
  public static void zetOm(String tekst) throws NumberFormatException {
    int getal = Integer.parseInt(tekst);
    System.out.println("Het is gelukt " + tekst +  " om te zetten: " + getal);
  }
}
Het is gelukt 12 om te zetten: 12
Het is niet gelukt om 2C om te zetten naar een getal.
Het is gelukt 22 om te zetten: 22

Eigen exceptions

Het is ook mogenlijk om je eigen exception te defineren in java:

Java-code: MijnException.java

public class MijnException extends Exception {
  public MijnException(String error) {  
    super(error);
  }
  public void eenMethode(){
    System.out.println("MijnException.eenMethode() aangeroepen");
  }
}

Dit defineert de exception MijnException. Omdat hij de class Exception overerft, is het een zogeheten checked exception. (het volgende hoofdstuk bevat meer info hierover.) Om deze exception te gooien in de code gebruikt men het woordje throw. Voorbeeld:

Java-code: ThrowMijnException.java

public class ThrowMijnException {
  public staic void main(String[] arg) {  
    try
     {
        throw new MijnException("Mijn error");
        System.out.println("Dit komt nooit op het scherm");
     }
     catch(MijnException error)
     {
        System.out.println("De error is: "+error.getMessage());  // De methode getMessage() is gedefinieerd in java.lang.Throwable
        error.eenMethode();
      }
  }
}

Soorten

oorsprong

  • uit Exception-class
    • RuntimeException
    • IndexOutOfBoundsException gevraagd element bestaat niet in de rij
    • NullPointerException pointer verwijst naar nergens
  • IOExceptions uit java.io-package
    • EOFExceptions einde van het bestand
    • FileNotFoundExceptions bestand niet gevonden

inhoudelijk

  • checked exceptions zijn exceptions waarvan de compiler verwacht dat je ze vermeldt in de methodsignatuur of dat je ze opvangt in een try-en-catch-blok. Je code zal niet kunnen compileren indien je ze nergens opvangt.

Je moet deze excepties dus altijd opvangen, anders geraakt de code niet gecompileerd. Ze zijn afgeleid (inherited) van de klasse java.lang.Throwable

  • unchecked exceptions moet je niet vermelden in de methodsignatuur of moet je geen try-en-catch-blok voor coderen. Wanneer zich tijdens de uitvoering van een programma een unchecked exception voordoet, zal de JRE deze opvangen. Let op, je programma wordt afgebroken zonder dat dit invloed heeft naar het besturingssysteem toe. Meestal is het dus wel aangeraden om ook deze exceptions op te vangen of te vermelden.

Deze excepties kunnen, maar moeten dus niet opgevangen worden. Deze worden afgeleid van java.lang.Error en java.lang.RuntimeException.

This article is issued from Wikibooks. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.