Java's throws Sleutelwoord Begrijpen: Voorbeelden & Best Practices

Java throws Sleutelwoord

Het throws sleutelwoord in Java laat je declareren dat een methode een of meer exceptions kan gooien. Door deze potentiële falen expliciet op te sommen, geef je aan roepende code dat ze de exception moeten afhandelen of verder propageren, wat je code duidelijk en betrouwbaar houdt.

Wanneer je een bibliotheekmethode aanroept die een checked exception kan gooien, dwingt Java je dit aan te pakken. Normaal zou je de riskante code in een try-catch blok wrappen:

import java.io.*;
class File1 {
    public static void main(String[] args) {
        try {
            FileWriter file = new FileWriter("c:\\Data1.txt");
            file.write("Guru99");
            file.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Als je de try-catch weglaat, zal de compiler het programma verwerpen. Hoewel het afhandelen van elke exception apart uitgebreid kan zijn, biedt Java een schonere alternatief: declareer de exception in de methodehandtekening met throws en laat de aanroeper beslissen hoe te hanteren.

throws Syntaxis

public void methodeNaam(Parameters) throws Exception1, Exception2, … {
    …
}

throws Voorbeeld

Hieronder is hetzelfde bestandsschrijfvoorbeeld, maar de main methode declareert dat het IOException gooit in plaats van het te vangen:

import java.io.*;
class File1 {
    public static void main(String[] args) throws IOException {
        FileWriter file = new FileWriter("c:\\Data1.txt");
        file.write("Guru99");
        file.close();
    }
}

Voordat je deze code runt, maak een leeg bestand genaamd Data1.txt aan op de C:\ schijf. Java biedt twee manieren om aan de compilerseis te voldoen dat checked exceptions adres worden:

1. Wrap de riskante code in een try-catch blok.
2. Declareer de methode met throws en propageer de exception naar de aanroeper.

De keuze voor de juiste benadering hangt af van de context. Als de methode onderdeel is van een publieke API, houdt het propageren van de exception vaak het API-oppervlak schoon en dwingt het aanroepers om fouten expliciet af te handelen.

Throw vs. Throws

Samenvatting

Het throws sleutelwoord is essentieel voor duidelijke exception propagatie in Java. Wanneer een methode throws declareert, moet elke aanroeper de exception afhandelen of verder declareren, wat zorgt dat foutcondities nooit stilzwijgend genegeerd worden.