Vertel over het uitzonderingsmechanisme in Java.

In Java wordt het mechanisme van uitzonderingen gebruikt om fouten en andere uitzonderlijke situaties die zich tijdens de uitvoering van het programma voordoen, af te handelen.

Belangrijke elementen van het uitzonderingsmechanisme:

• Uitzondering (Exception): Object dat een gebeurtenis vertegenwoordigt die de normale stroom van de uitvoering van het programma onderbreekt.
• Blokken try, catch, finally: Worden gebruikt om uitzonderingen af te handelen.
  • try: Codeblok waarin een uitzondering kan optreden.
  • catch: Codeblok dat wordt uitgevoerd als er een uitzondering van een bepaald type optreedt in het try-blok.
  • finally: Codeblok dat altijd wordt uitgevoerd, ongeacht of er een uitzondering is opgetreden of niet. Wordt gebruikt om bronnen vrij te maken.
• Trefwoord throw: Wordt gebruikt om expliciet een uitzondering te creëren en te werpen.
• Trefwoord throws: Wordt gebruikt in de handtekening van een methode om de typen uitzonderingen aan te geven die de methode kan werpen.

Hiërarchie van uitzonderingen in Java:

• Throwable: Basisklasse voor alle uitzonderingen en fouten.
  • Error: Vertegenwoordigt ernstige problemen waaruit het programma meestal niet kan herstellen (bijvoorbeeld OutOfMemoryError).
  • Exception: Vertegenwoordigt uitzonderingen die door het programma kunnen worden opgevangen en afgehandeld.
    • RuntimeException (Unchecked Exceptions): Uitzonderingen die geen expliciete verwerking of declaratie in de handtekening van de methode vereisen (bijvoorbeeld NullPointerException, ArrayIndexOutOfBoundsException).
    • Checked Exceptions: Uitzonderingen die ofwel moeten worden afgehandeld met een try-catch-blok, of moeten worden gedeclareerd met throws in de handtekening van de methode (bijvoorbeeld IOException, FileNotFoundException).

Voorbeeld van het afhandelen van een uitzondering:

public class ExceptionExample {

    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Resultaat: " + result);
        } catch (ArithmeticException e) {
            // Afhandeling van ArithmeticException
            System.err.println("Fout: deling door nul is niet toegestaan.");
            System.err.println("Details van de uitzondering: " + e.getMessage());
            e.printStackTrace(); // toont de stack trace
        } finally {
            // Deze blok wordt altijd uitgevoerd
            System.out.println("Finally-blok uitgevoerd.");
        }
    }

    public static int divide(int a, int b) {
        // Kan ArithmeticException veroorzaken bij b = 0
        return a / b;
    }
}

Voorbeeld van het gebruik van throws:

import java.io.FileReader;
import java.io.IOException;

public class ThrowsExample {

    public static void readFile(String filename) throws IOException {
        // Kan IOException veroorzaken
        FileReader reader = new FileReader(filename);
        // Verdere verwerking van het bestand
    }

    public static void main(String[] args) {
        try {
            readFile("onbestaand_bestand.txt");
        } catch (IOException e) {
            System.err.println("Fout bij het lezen van het bestand: " + e.getMessage());
        }
    }
}