1. Lógica de Decisão

Em qualquer linguagem de programação, o fluxo linear padrão é frequentemente modificado pela necessidade de executar trechos específicos baseados em condições lógicas ou repetir tarefas. No Java, essas capacidades são fornecidas através de operadores de escolha e laços.

1.1 Operadores Condicionais (If)

A estrutura condicional permite que o programa avalie expressões booleanas para determinar o próximo bloco de execução.

Síntese das Formas de Utilização

• Condicional Básica: Verifica uma única condição. Se verdadeira, executa;
• Condicional Composta (Else): Oferece um caminho alternativo caso a condição principal falhe;
• Cadeia de Decisões (Else If): Permite avaliar múltiplas condições sequenciais até encontrar um correspondente.

public class LogicaDecisao {
    public static void main(String[] args) {
        // Exemplo 1: Verificação simples
        double tempCelsius = 38.5;
        
        if (tempCelsius > 37.5) {
            System.out.println("Atenção: Febre detectada.");
        }

        // Exemplo 2: Alternativa (If-Else)
        int saldoBanco = 50;
        if (saldoBanco >= 90) {
            System.out.println("Transação realizada com sucesso.");
        } else {
            System.out.println("Saldo insuficiente para esta operação.");
        }

        // Exemplo 3: Múltiplas Faixas (Else If)
        double pontuacaoFuncionario = 85;
        
        if (pontuacaoFuncionario >= 90 && pontuacaoFuncionario <= 100) {
            System.out.println("Nível: Excelente");
        } else if (pontuacaoFuncionario >= 70 && pontuacaoFuncionario < 90) {
            System.out.println("Nível: Regular");
        } else if (pontuacaoFuncionario >= 0 && pontuacaoFuncionario < 70) {
            System.out.println("Nível: Crítico");
        } else {
            System.out.println("Dados inválidos inseridos.");
        }
    }
}

Nota: Em blocos de código curtos onde há apenas uma linha após a condição, as chaves '{}' podem ser omitidas, mas sua utilização explícita é recomendada para evitar erros futuros e manter a legibilidade.

1.2 Comando Switch

O switch é ideal para comparações exatas de valor contra diversas opções constantes. Sua performance costuma ser superior em cenários de muitas escolhas discretas.

Mecanismo de Funcionamento

1. O valor da expressão é calculado;
2. O comparativo ocorre linha a linha nas opções case;
3. Se houver correspondência, os comandos assocaidos são executados até encontrar um break;
4. A opção default captura valores que não coincidem com nenhum case definido.

public class MenuOpcoes {
    public static void main(String[] args) {
        String diaDaSemana = "quarta";
        
        switch(diaDaSemana) {
            case "segunda":
                System.out.println("Início intenso das atividades.");
                break;
            case "terca":
            case "quarta":
            case "quinta":
                // Código compartilhado entre várias opções usando 'fall-through'
                System.out.println("Rotina constante.");
                break;
            case "sexta":
                System.out.println("Preparação para o fim de semana.");
                break;
            default:
                System.out.println("Opção fora do intervalo previsto.");
        }
    }
}

Restrições Técnicas Importantes

• O tipo de dado da expressão deve ser compatível: byte, short, char, int, String (JDK 7+), ou Enumerações (JDK 5+).
• Valores flutuantes (double ou float) não são permitidos devido à imprecisão computacional.
• O rótulo de cada case deve ser uma constante literal, não uma variável mutável.
• A ausência de break provoca a execução cascata (penetração) até o próximo ponto de parada ou final do bloco.

2. Estruturas de Repetição

Para automatizar operações iterativas, o Java oferece três tipos de laços. A escolha depende se o número de repetições é conhecido previamente.

2.1 Laço For

Utilizado quando a quantidade de iterações é definida antes do início. Composto por inicialização, condição de parada e incremento/decrescimento.

public class IteracaoControlada {
    public static void main(String[] args) {
        // Exibe uma mensagem fixa por 5 vezes
        for (int i = 0; i < 5; i++) {
            System.out.println("Execução: " + i);
        }

        // Cálculo de soma progressiva
        int total = 0;
        for (int num = 1; num <= 10; num++) {
            total += num;
        }
        System.out.println("Somatório: " + total);
    }
}

2.2 Laço While

Ideal quando o término da execução depender de uma condição dinâmica que só será satisfeita durante a rotina.

public class LoopCondicional {
    public static void main(String[] args) {
        int indice = 0;
        
        while (indice < 5) {
            System.out.println("Processando índice: " + indice);
            indice++;
        }
    }
}

Diferença Prática: Enquanto for exige verificação de condição antes da primeira execução, o do-while garante pelo menos uma ituação, pois a validação ocorre após o bloco de código rodar.

2.3 Laço Do-While

public class DoWhileDemo {
    public static void main(String[] args) {
        int x = 0;
        
        // O bloco roda pelo menos uma vez
        do {
            System.out.println("Primeira execução garantida.");
            x++;
        } while (x < 0); 
    }
}

3. Controle Interno dos Laços

Dentro de estruturas repetitivas, podemos manipular o fluxo normal.

• Break: Interrompe completamente o laço e salta para o código posterior ao mesmo.
• Continue: Ignora a iteração corrente e inicia imediatamente a próxima ciclo.

public class ManejoCiclo {
    public static void main(String[] args) {
        // Uso de Break: Para na metade
        for (int n = 1; n <= 10; n++) {
            if (n == 5) {
                break; 
            }
            System.out.print(n + " "); // 1 2 3 4
        }
    }
}

4. Geração de Números Aleatórios

A classe java.util.Random permite criar números pseudoaleatórios dentro de intervalos definidos.

4.1 Método Principal

O método nextInt(int n) retorna um valor aleatório entre 0 (inclusivo) e n (exclusivo).

import java.util.Random;
import java.util.Scanner;

public class GeradorAleatorio {
    public static void main(String[] args) {
        Random sorteio = new Random();
        
        // Gera número de 0 a 99
        int numeroSorteado = sorteio.nextInt(100);
        
        Scanner entrada = new Scanner(System.in);
        
        // Jogo simples de adivinhação
        while(true) {
            System.out.print("Digite um número (0-99): ");
            int tentativa = entrada.nextInt();
            
            if (tentativa > numeroSorteado) {
                System.out.println("O número secreto é menor.");
            } else if (tentativa < numeroSorteado) {
                System.out.println("O número secreto é maior.");
            } else {
                System.out.println("Acertou! Fim de jogo.");
                break;
            }
        }
    }
}

4.2 Fórmulas para Intervalos Específicos

Para obter valores em faixas diferentes (ex: 10 a 20), utiliza-se a fórmula matemática min + (max - min) * random.nextDouble(), ou via nextInt: min + r.nextInt(max - min + 1).