KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Multi-catch: gedeelde afhandeling van uitzonderingen

Met de syntaxis `catch (A | B e)` kun je verschillende uitzonderingstypen in één blok afhandelen. De alternatieve typen mogen geen subtype-relatie hebben en parameter `e` is impliciet final.

Versie: Java SE 21; repository runtime, production runtime not attested

Syntax

try {
    // operation
} catch (A | B e) {
    // shared handler
}

catch (A | B e) biedt één handler voor uitzonderingen van type A of B, inclusief hun subtypen. | scheidt de alternatieven; het is hier geen bitwise-operator. e staat voor één opgevangen uitzondering, niet voor een verzameling.

De alternatieven moeten exception-klassen zijn en mogen geen subtypen van elkaar zijn. Daarom is catch (Exception | RuntimeException e) een compilatiefout.

Parameter e is impliciet final: je kunt er geen andere waarde aan toewijzen. Het gedeclareerde type is de kleinste bovengrens (lub) van de alternatieve typen; die bepaalt welke members beschikbaar zijn.

Het voorbeeld doorloopt beide paden en verwacht eerst A en daarna B. Gebruik één gedeelde handler als de afhandeling identiek is; gebruik anders aparte catch-clausules.

Voorbeelden

public class MultiCatchDemo {
    static class A extends Exception {}
    static class B extends Exception {}

    static void fail(boolean first) throws A, B {
        if (first) {
            throw new A();
        }
        throw new B();
    }

    public static void main(String[] args) {
        for (boolean first : new boolean[] {true, false}) {
            try {
                fail(first);
            } catch (A | B e) {
                System.out.println(e.getClass().getSimpleName());
            }
        }
    }
}

Resultaat

A
B

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen