Java Academy · Lekcja

Słowo kluczowe yield

Generuj wartości z bloków switch

Słowo kluczowe yield to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Gdy jedna linia nie wystarcza

Gałąź strzałkowa, taka jak case 1 -> 42;, zwraca wartość bezpośrednio. Co jednak zrobić, gdy gałąź wymaga kilku instrukcji przed zwróceniem wartości? Właśnie wtedy przydaje się yield.

Słowo kluczowe yield

Wewnątrz gałęzi blokowej { } słowo kluczowe yield dostarcza wartość zwracaną przez wyrażenie switch. Można myśleć o nim jak o return, ale używanym dla gałęzi switch.

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 wewnątrz bloku

Przed wywołaniem yield można wykonać w bloku dowolną logikę. Ostatnią czynnością bloku powinno być przekazanie wartości za pomocą yield.

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);
    }
}

Łączenie gałęzi strzałkowych i blokowych

Pojedyncze wyrażenie switch może łączyć proste gałęzie strzałkowe z gałęziami blokowymi używającymi yield. Dla każdego przypadku należy użyć formy, która najlepiej do niego pasuje.

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);
    }
}

Obliczenia przed yield

Gałęzie blokowe są idealne, gdy wartość wymaga obliczenia. W tym przykładzie cyfry są sumowane przed przekazaniem wyniku za pomocą yield.

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 a return

yield kończy tylko bieżącą gałąź switch i przekazuje wartość. return zakończyłby działanie całej metody. W bloku wyrażenia switch należy używać 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 w starym stylu z dwukropkiem

Instrukcja switch w stylu z dwukropkiem również może być wyrażeniem, jeśli użyje się yield zamiast break. Każda sekcja z etykietą przekazuje swoją wartość za pomocą 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);
    }
}

Warunkowe yield

Gałąź blokowa może zawierać logikę if i zwracać różne wartości na różnych ścieżkach. Każda ścieżka musi przekazać wartość za pomocą yield.

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);
    }
}

Zwracanie obiektów

yield działa z dowolnym typem, także z obiektami. W tym przykładzie gałąź tworzy wynik typu StringBuilder i przekazuje go jako String.

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);
    }
}

Wskazówka dotycząca czytelności

Jeśli wystarcza pojedyncza wartość, należy preferować proste gałęzie strzałkowe. Po blok i yield warto sięgać tylko wtedy, gdy gałąź rzeczywiście wymaga dodatkowych instrukcji. Dzięki temu kod switch pozostaje uporządkowany.

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);
    }
}

Kompletny przykład

Połączmy wszystko: mapper statusów w stylu HTTP, który używa zarówno gałęzi strzałkowych, jak i blokowych.

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);
    }
}

Szybkie sprawdzenie

Jakie słowo kluczowe dostarcza wynikową wartość wewnątrz wieloinstrukcyjnej gałęzi wyrażenia switch?

Podsumowanie

Poznali Państwo słowo kluczowe yield:

yield zwraca wartość z gałęzi blokowej
Działa podobnie do return, ale tylko dla gałęzi switch
Gałęzie strzałkowe i blokowe można dowolnie łączyć
Każda ścieżka wykonania w bloku musi używać yield
Bloków należy używać tylko wtedy, gdy potrzebne są dodatkowe instrukcje

Często zadawane pytania

Czy lekcja „Słowo kluczowe yield” jest bezpłatna?

Tak — pełny tekst „Słowo kluczowe yield” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Słowo kluczowe yield”?

Generuj wartości z bloków switch Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Słowo kluczowe yield”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy