Java Academy · Lezione

La keyword yield

Produca valori dai blocchi switch

La keyword yield è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Quando una riga non basta

Un ramo con freccia come case 1 -> 42; restituisce direttamente un valore. Ma cosa succede se un ramo richiede diverse istruzioni prima di produrre il proprio valore? È qui che entra in gioco yield.

La parola chiave yield

All'interno di un ramo a blocco { }, la parola chiave yield fornisce il valore prodotto dall'espressione switch. Lo si può considerare come return, ma per un ramo di 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 all'interno di un blocco

È possibile eseguire qualsiasi logica nel blocco prima di chiamare yield. L'ultima operazione del blocco dovrebbe essere un yield di un valore.

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

Combinare rami con freccia e rami a blocco

Una singola espressione switch può combinare semplici rami con freccia e rami a blocco che usano yield. Usi la forma più adatta a ciascun caso.

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

Calcolo prima di yield

I rami a blocco sono ideali quando è necessario calcolare un valore. Qui si sommano le cifre prima di usare yield per restituire il totale.

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

yield esce solo dal ramo di switch e restituisce un valore. return uscirebbe dall'intero metodo. All'interno del blocco di un'espressione switch, si usa 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 nel vecchio stile con i due punti

Anche switch nello stile con i due punti può essere un'espressione, usando yield invece di break. Ogni sezione con etichetta restituisce il proprio valore con 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);
    }
}

yield condizionale

Un ramo a blocco può contenere una logica if e restituire valori diversi lungo percorsi diversi. Ogni percorso deve restituire un valore con 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);
    }
}

Restituire oggetti con yield

yield funziona con qualsiasi tipo, inclusi gli oggetti. Qui un ramo costruisce e restituisce con yield un risultato StringBuilder come 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);
    }
}

Consiglio per la leggibilità

Preferisca semplici rami con freccia quando è sufficiente un singolo valore. Ricorra a un blocco e a yield solo quando un ramo richiede davvero istruzioni aggiuntive. In questo modo il switch resta ordinato.

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

Un esempio completo

Mettiamo insieme i concetti: un mapper di codici di stato in stile HTTP che usa sia rami con freccia sia rami a blocco.

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

Verifica rapida

All'interno di un ramo di un'espressione switch con più istruzioni, quale parola chiave fornisce il valore risultante?

Riepilogo

Ha imparato la parola chiave yield:

yield produce un valore da un ramo a blocco
È simile a return, ma solo per un ramo di switch
Combini liberamente rami con freccia e rami a blocco
Ogni percorso del codice in un blocco deve usare yield
Usi i blocchi solo quando sono necessarie istruzioni aggiuntive

Domande Frequenti

La lezione «La keyword yield» è gratuita?

Sì — il testo completo di «La keyword yield» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «La keyword yield»?

Produca valori dai blocchi switch Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «La keyword yield»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy