Controles de decisão

If, Else, Else-If e Switch

Bom galera! Vocês já se depararam com esse tipo de instrução em códigos por aí? Se permaneceu alguma dúvida sobre o assunto, vou tentar sanar agora!

O básico

if é uma condição (“se”) e else é o “se não”. Você está literalmente dando uma ordem ao computador:

se (condicao) {
    // se for verdadeira, faça isso
} senão {
    // faça isso
}

O que devemos sempre nos atentar é à condição: ela precisa retornar um valor booleano (true ou false). Caso contrário, não vai funcionar.

Um exemplo claro (com temática Dragon Ball Z 😎)

int gokuForca = 100;
int vegetaForca = 98;

if (gokuForca < vegetaForca) {
    System.out.println("Vegeta é mais forte!");
} else {
    System.out.println("Goku é mais forte!");
}

Aqui estou comparando a força entre Goku e Vegeta. A condição literalmente pergunta: “A força de Goku é menor que a de Vegeta?”. Como 100 não é menor que 98, a saída é “Goku é mais forte!”.

Mas Marin, o booleano entra onde?

Na própria condição! Quando usamos um operador relacional (como <, >, ==), o retorno em Java, Python ou JavaScript sempre será um booleano.

Operadores Relacionais

Operadores Lógicos

Outros operadores que você vai usar muito em condições são os Operadores Lógicos, que servem para combinar ou inverter expressões booleanas. O retorno também é sempre true ou false.

São três:

• ! → NOT (Negação): inverte o valor.
• && → AND (E): só é true se ambas as condições forem true.
• || → OR (OU): é true se pelo menos uma das condições for true.

Tabela verdade

Considere 0 = false e 1 = true.

Lendo a tabela linha a linha

!A (negação — depende apenas de A)

• Quando A = 0 (false), !A = 1 (true).
• Quando A = 1 (true), !A = 0 (false).
• Resumindo: a negação simplesmente inverte o valor.

A && B (AND — precisa dos dois verdadeiros)

• 0 && 0 → ambos falsos → 0
• 0 && 1 → um falso → 0
• 1 && 0 → um falso → 0
• 1 && 1 → ambos verdadeiros → 1

A || B (OR — basta um verdadeiro)

• 0 || 0 → ambos falsos → 0
• 0 || 1 → um verdadeiro → 1
• 1 || 0 → um verdadeiro → 1
• 1 || 1 → ambos verdadeiros → 1

💡 Resumão pra gravar:

• ! → inverte o valor.
• && → só retorna true se todas as condições forem true.
• || → retorna true se pelo menos uma condição for true.

Curiosidade: Short-circuit (curto-circuito)

Em Java, JavaScript e Python, && e || usam avaliação em curto-circuito: o segundo operando só é avaliado se for necessário.

if (usuario != null && usuario.isAtivo()) {
    // se usuario for null, isAtivo() nem é chamado — evita NullPointerException
}

E o else if?

Usamos else if quando queremos aninhar outra condição, já que o else puro não aceita uma expressão. Isso evita encher o código de ifs soltos.

int nota = 75;

if (nota >= 90) {
    System.out.println("A");
} else if (nota >= 80) {
    System.out.println("B");
} else if (nota >= 70) {
    System.out.println("C");
} else {
    System.out.println("Reprovado");
}

O fluxo é simples: as condições são avaliadas de cima para baixo, e a primeira que for true executa — as demais são ignoradas.

Bônus: Operador Ternário

Para if/else simples que apenas atribuem um valor, existe uma forma mais enxuta — o operador ternário:

String resultado = (gokuForca > vegetaForca) ? "Goku é mais forte!" : "Vegeta é mais forte!";

Funciona em Java, JavaScript e (com sintaxe diferente) Python:

resultado = "Goku é mais forte!" if goku_forca > vegeta_forca else "Vegeta é mais forte!"

Switch

⚠️ Pequeno aviso: o switch é uma estrutura de seleção (parente do if/else), e não de repetição. Como é comum confundir, vale incluir aqui.

Ele é útil quando você quer executar tarefas diferentes com base no valor de uma variável — especialmente quando há vários caminhos possíveis.

Switch clássico

public class Main {

    public static void main(String[] args) {
        int opcao = 1;
        switch (opcao) {
            case 1:
                goku();
                break;
            case 2:
                vegeta();
                break;
            case 3:
                gohan();
                break;
            default:
                System.out.println("Opção inválida!");
        }
    }

    public static void goku()   { System.out.println("Oi, eu sou o Goku!"); }
    public static void vegeta() { System.out.println("O miserável é um gênio!"); }
    public static void gohan()  { System.out.println("Eu não vou deixar vocês destruírem o futuro!"); }
}

💡 Importante: o switch não avalia true/false — ele compara igualdade entre o valor passado e cada case. E o break é essencial: sem ele, ocorre o famoso fall-through, onde o código continua executando os próximos cases, mesmo que não correspondam.

Switch moderno (Java 14+) com arrow syntax

int opcao = 1;
switch (opcao) {
    case 1 -> goku();
    case 2 -> vegeta();
    case 3 -> gohan();
    default -> System.out.println("Opção inválida!");
}

Sem break, sem fall-through — muito mais limpo.

Switch expression (retorna valor!)

A partir do Java 14, o switch pode retornar um valor:

String frase = switch (opcao) {
    case 1 -> "Oi, eu sou o Goku!";
    case 2 -> "O miserável é um gênio!";
    case 3 -> "Eu não vou deixar vocês destruírem o futuro!";
    default -> "Opção inválida!";
};

System.out.println(frase);

Esse formato combina muito bem com enums, mas isso fica pra um próximo artigo. 😉

Boas práticas

• Sempre use chaves { }, mesmo em ifs de uma linha só. Evita bugs sutis.
• Evite aninhamento excessivo — se você tem if dentro de if dentro de if, considere refatorar.
• Use early return quando possível, em vez de um else longo:

  if (usuario == null) return;
  // resto do código

• Prefira nomes claros nas variáveis booleanas: isAtivo, temPermissao, estaVazio — fica óbvio ler a condição.

Conclusão

• if, else e else if são a base da tomada de decisão em qualquer linguagem. Entenda os operadores relacionais, lógicos e a tabela verdade — esses conceitos vão te acompanhar literalmente em todo código que você escrever.

• Já o switch entra em cena quando você tem vários caminhos possíveis baseados no valor de uma única variável — é uma alternativa mais limpa do que vários else if empilhados.

Até a próxima! 🚀