if-else em Java: instruções condicionais com exemplos

Tomando decisões com if

Os programas precisam reagir aos dados: aprovado ou reprovado, em estoque ou esgotado, válido ou não. A instrução if é como o Java escolhe qual código executar com base em uma condição.

Um if recebe uma condição booleana entre parênteses e executa o bloco entre chaves apenas quando essa condição é true:

public class Main {
    public static void main(String[] args) {
        int score = 72;

        if (score >= 60) {
            System.out.println("You passed!");
        }

        System.out.println("Done grading.");
    }
}

A condição score >= 60 é true, então a mensagem é exibida. A linha após a chave de fechamento sempre é executada: ela está fora do if. Mude score para 40 e a linha de "passed" é totalmente ignorada.

Diferente do C, o Java não deixa você colocar um número onde se espera um booleano. if (score) é um erro de compilação: a condição precisa ser uma expressão boolean real, construída a partir de comparações (>, >=, ==, !=) ou lógica booleana (&&, ||, !).

Adicionando um else

else oferece o caminho "caso contrário": código que executa apenas quando a condição é false:

public class Main {
    public static void main(String[] args) {
        int hour = 20;

        if (hour < 12) {
            System.out.println("Good morning");
        } else {
            System.out.println("Good evening");
        }
    }
}

Exatamente um dos dois blocos é executado: nunca os dois, nunca nenhum. O else não tem condição própria; ele simplesmente captura tudo o que o if não pegou.

Encadeando com else if

Quando há mais de dois resultados, encadeie condições com else if. O Java as verifica de cima para baixo e executa o primeiro bloco cuja condição é verdadeira, e então ignora o resto:

public class Main {
    public static void main(String[] args) {
        int score = 84;
        char grade;

        if (score >= 90) {
            grade = 'A';
        } else if (score >= 80) {
            grade = 'B';
        } else if (score >= 70) {
            grade = 'C';
        } else {
            grade = 'F';
        }

        System.out.println("Grade: " + grade);
    }
}

A ordem importa. Como 84 é verificado primeiro contra >= 90 (falso) e depois contra >= 80 (verdadeiro), ele para em B e nem chega a testar os limites inferiores. É por isso também que você não precisa escrever score >= 80 && score < 90: alcançar o segundo ramo já garante que score era menor que 90. Coloque primeiro a condição mais restrita ou de maior prioridade.

O else final é o seu caso geral. Omiti-lo aqui seria um erro de compilação, já que grade poderia ficar sem atribuição na hora de imprimi-la.

Comparando valores: == versus equals()

O erro mais comum com if em Java é comparar strings com ==. Para primitivos (int, double, char, boolean), == está correto. Para objetos, == pergunta "é o mesmo objeto na memória?", enquanto .equals() pergunta "eles têm o mesmo conteúdo?", e quase sempre você quer o segundo:

public class Main {
    public static void main(String[] args) {
        String input = new String("yes");

        if (input == "yes") {
            System.out.println("matched with ==");
        }

        if (input.equals("yes")) {
            System.out.println("matched with equals()");
        }
    }
}

Apenas a segunda mensagem é exibida. O new String("yes") é um objeto diferente do literal "yes", então == é false, mas o texto é idêntico, então .equals() é true. Regra geral: primitivos usam ==, objetos usam .equals().

Um truque seguro para evitar uma NullPointerException quando a variável pode ser null: coloque o literal primeiro, if ("yes".equals(input)), já que um literal nunca é null.

Combinando e aninhando condições

Você pode combinar condições com && (e), || (ou) e ! (não), ou aninhar um if dentro de outro quando uma verificação só faz sentido depois de uma anterior passar:

public class Main {
    public static void main(String[] args) {
        int age = 25;
        boolean hasLicense = true;

        if (age >= 18 && hasLicense) {
            System.out.println("Can drive");
        } else {
            System.out.println("Cannot drive");
        }

        // aninhamento: só verifica a segunda coisa se a primeira for verdadeira
        if (age >= 18) {
            if (hasLicense) {
                System.out.println("Eligible and licensed");
            }
        }
    }
}

&& e || fazem curto-circuito: em a && b, se a for falso o Java nunca avalia b. Isso é útil para se proteger de erros: if (s != null && s.length() > 0) é seguro porque a verificação de comprimento é ignorada quando s é null. Prefira combinar com && em vez de aninhar profundamente quando puder; o código plano lê-se com mais clareza do que uma pirâmide de chaves.

Uma armadilha clássica: um único = é atribuição, == é comparação. Escrever if (x = 5) é um erro de compilação para int (ótimo), mas if (flag = true) em um boolean compila e atribui silenciosamente: fique atento a isso.

O operador ternário

Quando tudo o que você quer é escolher entre dois valores, o operador ternário ?: é um compacto de uma linha. Leia condition ? a : b como "se a condição então a senão b":

public class Main {
    public static void main(String[] args) {
        int age = 15;

        String label = age >= 18 ? "adult" : "minor";
        System.out.println(label);

        int a = 7, b = 3;
        int max = a > b ? a : b;
        System.out.println("max = " + max);
    }
}

O ternário produz um valor que você pode atribuir ou passar diretamente. Reserve-o para seleção simples: se algum ramo precisa de várias instruções ou de lógica de verdade, um if-else completo continua legível onde um ternário aninhado rapidamente vira um quebra-cabeça.

Uma armadilha: as chaves opcionais

O Java deixa você omitir as chaves quando um ramo tem uma única instrução, mas isso convida a um bug sutil. A indentação engana:

if (loggedIn)
    System.out.println("Welcome");
    System.out.println("Loading dashboard");   // NOT part of the if!

Apenas a primeira linha é controlada pelo if; a segunda sempre executa, não importa o quê, apesar de a indentação sugerir o contrário. Use sempre chaves, mesmo para uma única linha, e toda essa categoria de erro desaparece.

Próximo: switch

As cadeias if-else if são perfeitas quando cada ramo testa uma condição diferente. Mas quando você está comparando um único valor com muitas possibilidades fixas (um nome de dia, uma opção de menu, um enum), uma longa escada de else if fica repetitiva. A instrução switch foi feita exatamente para isso, e é a próxima página.