7.5. Controle de fluxo (if, else, switch, loops): Operadores lógicos

7.5. Controle de Fluxo em Java: Operadores Lógicos e Estruturas de Decisão

O controle de fluxo em Java é um dos pilares fundamentais para o desenvolvimento de programas eficazes. Através do uso inteligente de estruturas de decisão como if, else, switch e laços de repetição como for, while e do-while, é possível criar lógicas complexas e robustas. Neste capítulo, exploraremos o uso de operadores lógicos e estruturas de controle de fluxo, que são essenciais para qualquer desenvolvedor Java que deseje progredir do nível básico ao avançado.

Operadores Lógicos

Operadores lógicos são usados para formar expressões booleanas complexas, que resultam em um valor true ou false. Os principais operadores lógicos em Java são:

• AND (&&): Retorna true se ambas as expressões forem verdadeiras.
• OR (||): Retorna true se pelo menos uma das expressões for verdadeira.
• NOT (!): Inverte o valor da expressão, de true para false e vice-versa.

Combinando esses operadores, podemos construir condições mais complexas para controlar o fluxo do nosso programa.

Estrutura de Decisão if

A estrutura if é a forma mais básica de controle de fluxo. Ela permite que o programa execute um bloco de código apenas se uma condição específica for verdadeira. Por exemplo:

if (condicao) {
    // Bloco de código que será executado se a condição for verdadeira
}

Estrutura else

O else é usado em conjunto com if para executar um bloco de código alternativo quando a condição do if não é satisfeita.

if (condicao) {
    // Executa se a condição for verdadeira
} else {
    // Executa se a condição for falsa
}

Estrutura else if

Para testar múltiplas condições, podemos encadear várias estruturas if com else if:

if (primeiraCondicao) {
    // Executa se a primeira condição for verdadeira
} else if (segundaCondicao) {
    // Executa se a segunda condição for verdadeira
} else {
    // Executa se nenhuma das condições anteriores for verdadeira
}

Estrutura switch

O switch é uma alternativa ao if que pode tornar o código mais legível quando temos muitas condições baseadas no mesmo valor. Cada caso é definido pela palavra-chave case, seguida de um valor e um break para evitar a execução dos casos subsequentes.

switch (variavel) {
    case valor1:
        // Executa se variavel == valor1
        break;
    case valor2:
        // Executa se variavel == valor2
        break;
    default:
        // Executa se nenhum dos casos acima for verdadeiro
}

Laços de Repetição

Laços de repetição são usados para executar um bloco de código várias vezes. Java fornece várias estruturas de laço:

• for: Executa um bloco de código um número determinado de vezes.
• while: Executa um bloco de código enquanto uma condição for verdadeira.
• do-while: Semelhante ao while, mas garante que o bloco de código seja executado pelo menos uma vez.

Laço for

for (inicializacao; condicao; incremento) {
    // Bloco de código a ser repetido
}

Laço while

while (condicao) {
    // Bloco de código a ser repetido
}

Laço do-while

do {
    // Bloco de código a ser repetido
} while (condicao);

Exemplos Práticos

Vejamos alguns exemplos de como essas estruturas podem ser usadas em um programa Java:

// Exemplo de if-else
int nota = 75;
if (nota >= 70) {
    System.out.println("Aprovado");
} else {
    System.out.println("Reprovado");
}

// Exemplo de switch
char grade = 'B';
switch (grade) {
    case 'A':
        System.out.println("Excelente");
        break;
    case 'B':
    case 'C':
        System.out.println("Bem feito");
        break;
    case 'D':
        System.out.println("Você passou");
        break;
    case 'F':
        System.out.println("Melhor tentar novamente");
        break;
    default:
        System.out.println("Nota inválida");
}

// Exemplo de for
for (int i = 0; i < 5; i++) {
    System.out.println("i = " + i);
}

// Exemplo de while
int i = 0;
while (i < 5) {
    System.out.println("i = " + i);
    i++;
}

// Exemplo de do-while
int j = 0;
do {
    System.out.println("j = " + j);
    j++;
} while (j < 5);

Entender e aplicar corretamente os operadores lógicos e estruturas de controle de fluxo é essencial para qualquer desenvolvedor Java. Com a prática, essas ferramentas se tornam intuitivas e permitem a construção de programas complexos e eficientes.