Java Academy · Aula

A Palavra-chave yield

Produza valores a partir de blocos switch

A Palavra-chave yield é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Quando uma linha não basta

Um ramo de seta como case 1 -> 42; retorna um valor diretamente. Mas e se um ramo precisar de várias instruções antes de produzir seu valor? É nesse momento que yield entra em ação.

A palavra-chave para produzir valores

Dentro de um ramo de bloco { }, a palavra-chave yield fornece o valor produzido pela expressão switch. Pense nela como return, mas para um ramo de 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);
    }
}

Produzindo um valor dentro de um bloco

Você pode executar qualquer lógica no bloco antes de chamar yield. A última ação do bloco deve ser produzir um valor com 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);
    }
}

Misturando ramos de seta e de bloco

Uma única expressão switch pode misturar ramos simples de seta com ramos de bloco que usam yield. Use a opção mais adequada para cada 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);
    }
}

Cálculo antes de produzir o valor

Os ramos de bloco são ideais quando um valor precisa ser calculado. Aqui, somamos os dígitos antes de produzir o total.

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

Produzir valor versus retornar

yield sai apenas do ramo de switch e devolve um valor. return sairia do método inteiro. Dentro de um bloco de expressão switch, use 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));
    }
}

Produção de valor no estilo antigo com dois-pontos

O switch no estilo com dois-pontos também pode ser uma expressão, usando yield em vez de break. Cada seção rotulada produz seu valor.

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

Produção condicional de valores

Um ramo de bloco pode conter lógica if e produzir valores diferentes em caminhos diferentes. Todo caminho deve produzir um valor.

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

Produzindo objetos

yield funciona com qualquer tipo, inclusive objetos. Aqui, um ramo cria e produz um resultado StringBuilder como 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);
    }
}

Dica de legibilidade

Prefira ramos simples de seta quando um único valor for suficiente. Use um bloco e yield somente quando um ramo realmente precisar de instruções adicionais. Isso mantém seu switch organizado.

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

Um exemplo completo

Juntando tudo: um mapeador de status no estilo de requisições da Web que usa ramos de seta e de bloco.

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ção rápida

Dentro de um ramo de expressão switch com várias instruções, qual palavra-chave fornece o valor resultante?

Recapitulação

Você aprendeu a palavra-chave yield:

yield produz um valor a partir de um ramo de bloco
Ela funciona como return, mas apenas para um ramo de switch
Misture livremente ramos de seta e de bloco
Todo caminho de código em um bloco deve usar yield
Use blocos somente quando forem necessárias instruções adicionais

Perguntas Frequentes

A aula “A Palavra-chave yield” é grátis?

Sim — o texto completo de “A Palavra-chave yield” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “A Palavra-chave yield”?

Produza valores a partir de blocos switch Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “A Palavra-chave yield”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy