Java Academy · Lektion

Mönstermatchning för instanceof

Bind en variabel samtidigt som typen testas.

Lektion 1 av 413 steg

Mönstermatchning för instanceof är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Mönstermatchning för instanceof

Det äldre sättet att använda instanceof var att testa och sedan casta. Mönstermatchning kombinerar testet och castningen i ett steg och binder en typad variabel när testet lyckas.

Den gamla standardkoden

Klassisk kod kontrollerar typen och castar sedan till en ny variabel. Det blir repetitivt och är lätt att göra fel i.

public class Main {
    public static void main(String[] args) {
        Object obj = "hello";
        if (obj instanceof String) {
            String s = (String) obj;
            System.out.println(s.length());
        }
    }
}

Den nya formen

Ett typmönster deklarerar variabeln direkt: if (obj instanceof String s). När villkoret är sant innehåller s redan det castade värdet.

public class Main {
    public static void main(String[] args) {
        Object obj = "hello";
        if (obj instanceof String s) {
            System.out.println(s.length());
        }
    }
}

Bindningsvariabeln

Variabeln s kallas mönstervariabel. Den är tillgänglig överallt där kompilatorn kan bevisa att mönstret matchade, vilket gör koden både kortare och säkrare.

Använda den i villkor

I samma if-villkor kan Ni använda mönstervariabeln efter &&, eftersom matchningen är garanterad i den grenen.

public class Main {
    public static void main(String[] args) {
        Object obj = "developer";
        if (obj instanceof String s && s.length() > 5) {
            System.out.println("Long string: " + s);
        }
    }
}

Negation och flödesomfång

Vid negation vänds omfånget på ett intelligent sätt. Efter if (!(obj instanceof String s)) return; är variabeln s tillgänglig i resten av metoden, eftersom koden bara fortsätter när matchningen lyckades.

public class Main {
    static int safeLength(Object obj) {
        if (!(obj instanceof String s)) {
            return -1;
        }
        return s.length();
    }

    public static void main(String[] args) {
        System.out.println(safeLength("abc"));
        System.out.println(safeLength(42));
    }
}

Ersätt test-och-cast-mönstret i equals

Ett klassiskt exempel är en tydlig åsidosättning av equals: testa typen och bind variabeln på en rad, och jämför sedan fälten.

public class Main {
    static final class Point {
        final int x, y;
        Point(int x, int y) { this.x = x; this.y = y; }
        public boolean equals(Object o) {
            return o instanceof Point p && p.x == x && p.y == y;
        }
        public int hashCode() { return x * 31 + y; }
    }

    public static void main(String[] args) {
        System.out.println(new Point(1, 2).equals(new Point(1, 2)));
        System.out.println(new Point(1, 2).equals(new Point(3, 4)));
    }
}

Hantera blandade typer

Kedjade else if-grenar med mönster gör att man kan hantera flera möjliga typer på ett tydligt sätt.

public class Main {
    static String describe(Object obj) {
        if (obj instanceof Integer i) {
            return "int " + (i * 2);
        } else if (obj instanceof String s) {
            return "string of length " + s.length();
        } else {
            return "unknown";
        }
    }

    public static void main(String[] args) {
        System.out.println(describe(21));
        System.out.println(describe("hello"));
        System.out.println(describe(3.14));
    }
}

Null matchas aldrig

Ett instanceof-mönster är false för null, precis som den klassiska operatorn. Mönstervariabeln bindas därför aldrig till null, vilket eliminerar en vanlig källa till NPE:er.

public class Main {
    public static void main(String[] args) {
        Object obj = null;
        if (obj instanceof String s) {
            System.out.println("matched: " + s);
        } else {
            System.out.println("null or not a String");
        }
    }
}

Renare och säkrare kod

Mönstermatchning tar bort den överflödiga typomvandlingen, begränsar variabelns räckvidd så att den inte kan användas fel och är nästan lika lättläst som vanlig text. Det är den föredragna stilen i modern Java.

Sätta ihop delarna

En liten dispatcher som formaterar olika indata med hjälp av mönster.

public class Main {
    static String format(Object o) {
        if (o instanceof Double d) return String.format("%.1f", d);
        if (o instanceof Integer i) return Integer.toString(i);
        if (o instanceof String s && !s.isBlank()) return s.trim();
        return "n/a";
    }

    public static void main(String[] args) {
        System.out.println(format(3.14159));
        System.out.println(format(99));
        System.out.println(format("  spaced  "));
        System.out.println(format(null));
    }
}

Snabbtest

Testa er förståelse av instanceof-mönster.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er mönstermatchning för instanceof.

Den kombinerar typkontrollen och typomvandlingen i ett enda uttryck.
Mönstervariabeln har räckvidd där matchningen är bekräftad.
Mönster är false för null, vilket förebygger NPE:er.
Det förenklar överlagringar av equals och typdispatch.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Mönstermatchning för instanceof” gratis?

Ja – hela texten till ”Mönstermatchning för instanceof” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Mönstermatchning för instanceof”?

Bind en variabel samtidigt som typen testas. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Mönstermatchning för instanceof”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Java Academy