if e else: O Programa Escolhe seu Caminho

Chegamos a um marco. Nesta aula, o seu programa aprende a decidir — a escolher entre caminhos diferentes conforme os dados que possui. Até agora, um programa era uma sequência rígida: toda instrução era executada, sempre, na mesma ordem. Com a estrutura que aprenderemos hoje, o if, algumas instruções passam a ser executadas apenas se uma condição for verdadeira, e outras podem ser executadas em seu lugar. É a diferença entre um trem em trilho único e um trem que escolhe o desvio conforme o sinal. Os booleanos e comparações da aula anterior eram a preparação; agora eles ganham propósito, tornando-se as condições que governam as escolhas do programa. Este é, talvez, o conceito que mais transforma o que você é capaz de construir.

A estrutura if: fazer algo apenas se

A palavra-chave if (em inglês, "se") introduz uma decisão. Sua forma é: a palavra if, seguida de uma condição entre parênteses, seguida de um bloco de instruções entre chaves. A regra é simples e poderosa: as instruções dentro do bloco são executadas somente se a condição for verdadeira; se for falsa, o bloco é inteiramente pulado.

int idade = 20;

if (idade >= 18)
{
    Console.WriteLine("Você é maior de idade.");
}

Console.WriteLine("Fim do programa.");

Acompanhe o fluxo. O programa avalia a condição idade >= 18. Como idade vale 20, a condição é verdadeira, então o bloco entre chaves é executado, exibindo "Você é maior de idade.". Em seguida, a execução continua normalmente para a linha de fora do if, exibindo "Fim do programa.". Agora imagine que idade valesse 15: a condição seria falsa, o bloco do if seria pulado por inteiro (a mensagem de maioridade não apareceria), e o programa saltaria direto para "Fim do programa.". Essa é a essência da decisão: um trecho de código que só roda sob certa condição.

A condição entre os parênteses precisa ser uma expressão que resulte num bool — precisamente o tipo de expressão que aprendemos a construir na aula anterior. É por isso que dedicamos uma aula inteira às comparações: elas são o combustível dos if. Qualquer pergunta de verdadeiro/falso — idade >= 18, resposta == "sim", saldo < 0, ou combinações com && e || — pode ser a condição de um if.

As chaves e o bloco

As chaves { } delimitam o bloco — o conjunto de instruções que pertencem ao if. Tudo dentro delas é executado (ou pulado) em conjunto, conforme a condição. Um bloco pode conter uma ou muitas instruções:

int saldo = -50;

if (saldo < 0)
{
    Console.WriteLine("Atenção: sua conta está negativa.");
    Console.WriteLine($"Você deve regularizar R$ {-saldo}.");
    Console.WriteLine("Procure seu gerente.");
}

As três mensagens só aparecem se o saldo for negativo, porque as três estão dentro do bloco. As chaves agrupam-nas como uma unidade sob a decisão. Recomendo fortemente que você sempre use as chaves, mesmo quando o bloco tem uma só instrução — embora o C# permita omiti-las nesse caso, mantê-las torna o código mais claro e evita uma categoria de erros sutis que surgem quando o bloco cresce depois. A clareza e a segurança que as chaves oferecem valem os dois caracteres a mais.

O else: fazer outra coisa quando a condição é falsa

Frequentemente, queremos que o programa faça uma coisa se a condição for verdadeira e outra se for falsa. Para isso existe o else (em inglês, "senão"), que se acopla a um if e fornece o caminho alternativo:

int idade = 15;

if (idade >= 18)
{
    Console.WriteLine("Você pode dirigir.");
}
else
{
    Console.WriteLine("Você ainda não pode dirigir.");
}

Agora há dois caminhos, e exatamente um deles será executado. Se a condição for verdadeira, roda o bloco do if; se for falsa, roda o bloco do else. Nunca os dois, nunca nenhum — sempre um, e apenas um. Com idade valendo 15, a condição é falsa, então roda o else, exibindo "Você ainda não pode dirigir.". O else é a bifurcação completa: dois destinos, e a condição decide qual.

Múltiplos caminhos: else if

E quando há mais de dois caminhos possíveis? Por exemplo, classificar uma nota em conceitos: excelente, bom, regular, insuficiente. Para isso, encadeamos decisões com else if, que verifica uma nova condição caso a anterior tenha sido falsa:

int nota = 75;

if (nota >= 90)
{
    Console.WriteLine("Excelente");
}
else if (nota >= 70)
{
    Console.WriteLine("Bom");
}
else if (nota >= 50)
{
    Console.WriteLine("Regular");
}
else
{
    Console.WriteLine("Insuficiente");
}

Acompanhe a lógica, que é sequencial e importante. O programa testa a primeira condição (nota >= 90); com nota 75, é falsa, então passa adiante. Testa a segunda (nota >= 70); é verdadeira, então executa esse bloco (exibindo "Bom") e ignora todo o resto — as demais condições nem são testadas. Se nenhuma das condições fosse verdadeira, o else final capturaria o caso restante. Duas observações cruciais: as condições são testadas de cima para baixo, na ordem, e apenas o primeiro bloco cuja condição é verdadeira executa. Por isso a ordem importa: escrevemos >= 90 antes de >= 70, pois uma nota 95 satisfaria ambas, e queremos que ela seja classificada como "Excelente", não "Bom". Colocar a condição mais restritiva primeiro garante a classificação correta.

Decisões dentro de decisões

Um bloco de if pode, ele próprio, conter outro if — decisões aninhadas, uma dentro da outra. Isso é útil quando uma segunda pergunta só faz sentido depois que a primeira foi respondida:

Console.Write("Você tem ingresso? (sim/não) ");
string temIngresso = Console.ReadLine();

if (temIngresso == "sim")
{
    Console.Write("Qual a sua idade? ");
    int idade = int.Parse(Console.ReadLine());

    if (idade >= 18)
        Console.WriteLine("Pode entrar no evento.");
    else
        Console.WriteLine("Evento apenas para maiores de 18.");
}
else
{
    Console.WriteLine("Você precisa de um ingresso para entrar.");
}

Aqui, a pergunta sobre a idade só é feita se a pessoa tiver ingresso — a segunda decisão está aninhada dentro do caminho verdadeiro da primeira. Aninhar decisões é natural e frequente, mas convém não exagerar: aninhamentos muito profundos tornam o código difícil de acompanhar. Quando isso acontece, muitas vezes há formas mais claras de reorganizar a lógica, que você aprenderá com a prática. Por ora, entenda que decisões podem se compor umas dentro das outras, refletindo a estrutura das perguntas do mundo real.

O programa deixou de seguir sempre o mesmo caminho. Com if, uma instrução passa a ser executada apenas sob condição; com else, existe uma alternativa para quando a condição é falsa; e com else if, uma cadeia de possibilidades pode ser avaliada em ordem até que uma delas se confirme.

As chaves ganharam um papel que vale reforçar: elas delimitam o bloco que pertence à decisão. Omiti-las quando há uma única instrução funciona, mas convida a um erro silencioso no dia em que uma segunda linha for acrescentada e ficar de fora do bloco sem que nada acuse. Usar chaves sempre é um hábito barato que evita um defeito difícil de enxergar.

Fontes e leituras recomendadas

• Instruções if e else — a referência oficial das estruturas de decisão; a base desta aula.
• A instrução if (guia) — convenções de escrita para condicionais, incluindo o uso de chaves.
• Expressões condicionais — como as condições booleanas governam o fluxo do programa.
• Blocos de instruções — o papel das chaves na delimitação de blocos de código.
• Fluxo de controle (conceito) — o panorama de como o programa decide qual caminho seguir.

Exercícios

Exercício 1

Escreva um programa que peça a idade do usuário (lida e convertida com segurança), e exiba "Maior de idade" se for 18 ou mais, e "Menor de idade" caso contrário, usando if/else. Teste com idades dos dois lados do limite.

Console.Write("Sua idade: ");
if (int.TryParse(Console.ReadLine(), out int idade))
{
    if (idade >= 18)
        Console.WriteLine("Maior de idade");
    else
        Console.WriteLine("Menor de idade");
}
else
{
    Console.WriteLine("Idade inválida.");
}

Exercício 2

Escreva um programa que peça um número e informe se ele é positivo, negativo ou zero, usando if, else if e else. Reflita sobre por que você precisa de três caminhos e não apenas dois.

Console.Write("Digite um número: ");
if (int.TryParse(Console.ReadLine(), out int n))
{
    if (n > 0) Console.WriteLine("Positivo");
    else if (n < 0) Console.WriteLine("Negativo");
    else Console.WriteLine("Zero");
}

Exercício 3

Escreva um programa que peça um número e informe se ele é par ou ímpar, usando o operador de resto (%) que aprendemos na Aula #06 dentro da condição de um if. (Lembre: um número é par quando numero % 2 == 0.)

Console.Write("Digite um número: ");
if (int.TryParse(Console.ReadLine(), out int n))
{
    if (n % 2 == 0)
        Console.WriteLine("Par");
    else
        Console.WriteLine("Ímpar");
}

Exercício 4

Reescreva o programa de classificação de notas da aula, mas inverta a ordem das condições (coloque >= 50 antes de >= 90). Teste com uma nota alta, como 95, e explique por que o resultado fica errado. O que isso ensina sobre a ordem das condições em else if?

if (nota >= 50) Console.WriteLine("Regular");
else if (nota >= 90) Console.WriteLine("Excelente");
// ...

Exercício 5

Sem código: explique, para uma cadeia de if/else if/else, quantos dos blocos são executados quando o programa roda, e por quê. O que acontece se nenhuma das condições for verdadeira e não houver um else final?