Java Academy · Lektion

Das Schlüsselwort yield

Erzeugen Sie Werte aus switch-Blöcken

Das Schlüsselwort yield ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Wenn eine Zeile nicht ausreicht

Ein Pfeilzweig wie case 1 -> 42; gibt direkt einen Wert zurück. Was aber, wenn ein Zweig vor der Erzeugung seines Werts mehrere Anweisungen benötigt? Hier kommt yield ins Spiel.

Das Schlüsselwort yield

Innerhalb eines Blockzweigs liefert das Schlüsselwort yield den Wert, den der switch-Ausdruck erzeugt. Stellen Sie es sich wie return vor, jedoch für einen switch-Zweig.

public class Main {
    public static void main(String[] args) {
        int n = 3;
        int result = switch (n) {
            case 3 -> {
                int squared = n * n;
                yield squared;
            }
            default -> 0;
        };
        System.out.println(result);
    }
}

yield innerhalb eines Blocks

Sie können im Block beliebige Logik ausführen, bevor Sie yield aufrufen. Als letzte Aktion des Blocks sollte ein yield mit einem Wert stehen.

public class Main {
    public static void main(String[] args) {
        int amount = 250;
        String label = switch (amount / 100) {
            case 0 -> "small";
            default -> {
                System.out.println("Computing label...");
                yield "large";
            }
        };
        System.out.println(label);
    }
}

Pfeil- und Blockzweige kombinieren

Ein einzelner switch-Ausdruck kann einfache Pfeilzweige mit Blockzweigen kombinieren, die yield verwenden. Verwenden Sie für jeden Fall die passende Variante.

public class Main {
    public static void main(String[] args) {
        int code = 2;
        String msg = switch (code) {
            case 1 -> "One";
            case 2 -> {
                String s = "T" + "wo";
                yield s;
            }
            default -> "Other";
        };
        System.out.println(msg);
    }
}

Berechnung vor yield

Blockzweige eignen sich ideal, wenn ein Wert berechnet werden muss. Hier summieren wir Ziffern, bevor wir die Summe mit yield zurückgeben.

public class Main {
    public static void main(String[] args) {
        int category = 1;
        int value = switch (category) {
            case 1 -> {
                int sum = 0;
                for (int i = 1; i <= 5; i++) {
                    sum += i;
                }
                yield sum;
            }
            default -> 0;
        };
        System.out.println(value);
    }
}

yield und return

yield beendet nur den switch-Zweig und gibt einen Wert zurück. return würde die gesamte Methode beenden. Verwenden Sie innerhalb eines Blocks in einem switch-Ausdruck yield.

public class Main {
    static int classify(int n) {
        int rank = switch (n) {
            case 0 -> 0;
            default -> {
                yield (n > 0) ? 1 : -1;
            }
        };
        return rank;
    }
    public static void main(String[] args) {
        System.out.println(classify(-7));
    }
}

yield im alten Stil mit Doppelpunkt

Der switch im Stil mit Doppelpunkten kann ebenfalls ein Ausdruck sein, der yield statt break verwendet. Jeder bezeichnete Abschnitt liefert seinen Wert mit yield.

public class Main {
    public static void main(String[] args) {
        int day = 2;
        String name = switch (day) {
            case 1: yield "Mon";
            case 2: yield "Tue";
            default: yield "Other";
        };
        System.out.println(name);
    }
}

Bedingtes yield

Ein Blockzweig kann if-Logik enthalten und auf verschiedenen Pfaden unterschiedliche Werte mit yield zurückgeben. Jeder Pfad muss einen Wert liefern.

public class Main {
    public static void main(String[] args) {
        int temp = 30;
        String advice = switch (temp / 10) {
            case 3 -> {
                if (temp > 35) {
                    yield "Very hot";
                }
                yield "Warm";
            }
            default -> "Mild";
        };
        System.out.println(advice);
    }
}

Objekte mit yield zurückgeben

yield funktioniert mit jedem Typ, auch mit Objekten. Hier erstellt ein Zweig ein Ergebnis mit StringBuilder und gibt es als String zurück.

public class Main {
    public static void main(String[] args) {
        int count = 3;
        String stars = switch (count) {
            case 0 -> "";
            default -> {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < count; i++) {
                    sb.append("*");
                }
                yield sb.toString();
            }
        };
        System.out.println(stars);
    }
}

Tipp zur Lesbarkeit

Bevorzugen Sie einfache Pfeilzweige, wenn ein einzelner Wert ausreicht. Verwenden Sie einen Block und yield nur, wenn ein Zweig tatsächlich zusätzliche Anweisungen benötigt. So bleibt Ihr switch übersichtlich.

public class Main {
    public static void main(String[] args) {
        int level = 2;
        int xp = switch (level) {
            case 1 -> 100;
            case 2 -> {
                int base = 100;
                yield base * 2;
            }
            default -> 0;
        };
        System.out.println(xp);
    }
}

Ein vollständiges Beispiel

Alles zusammen: ein Mapper für HTTP-ähnliche Statuscodes, der sowohl Pfeil- als auch Blockzweige verwendet.

public class Main {
    public static void main(String[] args) {
        int status = 404;
        String message = switch (status / 100) {
            case 2 -> "Success";
            case 4 -> {
                String base = "Client error ";
                yield base + status;
            }
            case 5 -> "Server error";
            default -> "Unknown";
        };
        System.out.println(message);
    }
}

Kurze Überprüfung

Welches Schlüsselwort liefert innerhalb eines mehrzeiligen Zweigs eines switch-Ausdrucks den resultierenden Wert?

Zusammenfassung

Sie haben das Schlüsselwort yield kennengelernt:

yield erzeugt einen Wert aus einem Blockzweig
Es funktioniert ähnlich wie return, aber nur für einen switch-Zweig
Sie können Pfeil- und Blockzweige frei kombinieren
Jeder Codepfad in einem Block muss yield verwenden
Verwenden Sie Blöcke nur, wenn zusätzliche Anweisungen erforderlich sind

Häufig gestellte Fragen

Ist die Lektion „Das Schlüsselwort yield“ kostenlos?

Ja — der vollständige Text von „Das Schlüsselwort yield“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Das Schlüsselwort yield“?

Erzeugen Sie Werte aus switch-Blöcken Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Das Schlüsselwort yield“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy