Java Academy · Lektion

Pilsyntax för switch

Använd den moderna pilsyntaxen för switch

Lektion 1 av 413 steg

Pilsyntax för switch ä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.

Problemet med den gamla switch-syntaxen

Den klassiska Java-satsen switch använde etiketter med kolon och krävde break efter varje case. Om du glömde break uppstod buggar med fall-through, där körningen fortsatte in i nästa case.

Modern Java (14+) introducerar pilsyntax, som löser detta helt.

Grunderna i pilsyntax

Med pilsyntax för switch använder varje etikett -> i stället för :. Det finns ingen fall-through och inget behov av break. Varje gren kör endast sin egen kod.

public class Main {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1 -> System.out.println("Monday");
            case 3 -> System.out.println("Wednesday");
            default -> System.out.println("Other day");
        }
    }
}

Inget mer break

I den gamla syntaxen behövde du skriva break; efter varje case. Pilformen tar helt bort den belastningen. Endast den matchande grenen körs.

public class Main {
    public static void main(String[] args) {
        char grade = 'B';
        switch (grade) {
            case 'A' -> System.out.println("Excellent");
            case 'B' -> System.out.println("Good");
            case 'C' -> System.out.println("Average");
            default -> System.out.println("Needs work");
        }
    }
}

Blockkroppar

När en gren behöver mer än en sats omsluter du den med klamrar { }. Blocket kan innehålla valfritt antal satser.

public class Main {
    public static void main(String[] args) {
        int code = 2;
        switch (code) {
            case 2 -> {
                System.out.println("Processing code 2");
                System.out.println("Done");
            }
            default -> System.out.println("Unknown");
        }
    }
}

Växla på strängar

En pilbaserad switch fungerar med värden av typen String precis som den gamla syntaxen. Jämförelserna använder internt equals, så de är skiftlägeskänsliga.

public class Main {
    public static void main(String[] args) {
        String fruit = "apple";
        switch (fruit) {
            case "apple" -> System.out.println("Red or green");
            case "banana" -> System.out.println("Yellow");
            default -> System.out.println("Unknown fruit");
        }
    }
}

default-grenen

Grenen default hanterar alla värden som inte täcks av andra case. Det är god praxis att alltid ta med en sådan, så att oväntad indata hanteras på ett bra sätt.

public class Main {
    public static void main(String[] args) {
        int level = 99;
        switch (level) {
            case 1 -> System.out.println("Beginner");
            case 2 -> System.out.println("Intermediate");
            default -> System.out.println("Unknown level: " + level);
        }
    }
}

Växla på enum-värden

En pilbaserad switch passar perfekt med typer av typen enum. Du kan utelämna enum-namnet framför varje etikett, vilket håller grenarna korta och tydliga.

public class Main {
    enum Color { RED, GREEN, BLUE }
    public static void main(String[] args) {
        Color c = Color.GREEN;
        switch (c) {
            case RED -> System.out.println("Stop");
            case GREEN -> System.out.println("Go");
            case BLUE -> System.out.println("Calm");
        }
    }
}

Anropa metoder i grenar

Varje pilgren kan anropa valfri metod. Det håller switch-satsen lättläst samtidigt som det egentliga arbetet delegeras till andra delar av koden.

public class Main {
    static void greet(String who) {
        System.out.println("Hello, " + who);
    }
    public static void main(String[] args) {
        int who = 1;
        switch (who) {
            case 1 -> greet("Alice");
            case 2 -> greet("Bob");
            default -> greet("Stranger");
        }
    }
}

Tydligare än if-else

En pilbaserad switch ersätter ofta långa kedjor av if-else. När du jämför en variabel med många fasta värden blir koden tydligare med switch.

public class Main {
    public static void main(String[] args) {
        int month = 4;
        switch (month) {
            case 12, 1, 2 -> System.out.println("Winter");
            case 3, 4, 5 -> System.out.println("Spring");
            case 6, 7, 8 -> System.out.println("Summer");
            default -> System.out.println("Autumn");
        }
    }
}

Endast sidoeffekter

En switch-sats (här i pilform) utför åtgärder men producerar inget värde. Om du vill returnera ett värde använder du ett switch-uttryck, som behandlas i nästa lektion.

public class Main {
    public static void main(String[] args) {
        int n = 5;
        switch (n % 2) {
            case 0 -> System.out.println(n + " is even");
            case 1 -> System.out.println(n + " is odd");
        }
    }
}

Flera värden, en gren

Flera värden kan dela på en gren genom att du separerar dem med kommatecken. Detta är en introduktion till case med flera etiketter, som behandlas senare.

public class Main {
    public static void main(String[] args) {
        char c = 'e';
        switch (c) {
            case 'a', 'e', 'i', 'o', 'u' -> System.out.println("Vowel");
            default -> System.out.println("Consonant");
        }
    }
}

Snabb kontroll

Vilken är den främsta fördelen med pilsyntax för switch jämfört med den gamla syntaxen med kolon?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig den moderna pilsyntaxen för switch:

Använd -> i stället för :
Ingen fall-through och inget behov av break
Använd klamrar { } för grenar med flera satser
Separera etiketter med kommatecken för att låta dem dela på en gren
Ta alltid med en gren för default

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 ”Pilsyntax för switch” gratis?

Ja – hela texten till ”Pilsyntax för switch” 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 ”Pilsyntax för switch”?

Använd den moderna pilsyntaxen för switch 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 ”Pilsyntax för switch”?

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