Tutorial de Fluxo de Controle em Java: Condicionais e Laços | Laboratório Prático

Introdução

Neste laboratório, você mergulhará no mundo das estruturas de controle de fluxo em Java. Estas são ferramentas essenciais que permitem que seus programas tomem decisões e repitam ações. Abordaremos três conceitos principais:

Declarações if-else para tomada de decisões
Laços for (for loops) para repetir ações um número conhecido de vezes
Laços while (while loops) para repetir ações quando você não sabe quantas vezes precisará repetir

Não se preocupe se esses termos parecem desconhecidos - explicaremos cada um em detalhes. Ao final deste laboratório, você será capaz de escrever programas Java que podem tomar decisões e repetir ações, abrindo um mundo totalmente novo de possibilidades em sua jornada de codificação!

Entendendo as Declarações If-Else

Imagine que você está criando um programa que dá conselhos sobre o clima. Você quer que ele sugira coisas diferentes com base na temperatura. É aqui que as declarações if-else são úteis!

Abra o arquivo WeatherAdvisor.java no WebIDE. Você verá este código:
```
public class WeatherAdvisor {
    public static void main(String[] args) {
        int temperature = 28; // Temperatura em Celsius

        System.out.println("A temperatura é " + temperature + "°C.");

        // TODO: Adicione declarações if-else aqui para fornecer conselhos sobre o clima
    }
}
```
Aqui está uma análise do código:
1. public class WeatherAdvisor:
  - Esta linha declara uma classe pública chamada WeatherAdvisor.
  - Em Java, todo programa deve ter pelo menos uma classe, e o nome da classe deve corresponder ao nome do arquivo (neste caso, WeatherAdvisor.java).
2. public static void main(String[] args):
  - Este é o método principal, que é o ponto de entrada de qualquer programa Java.
  - public: Este método pode ser acessado de fora da classe.
  - static: Este método pertence à própria classe, não a nenhuma instância específica da classe.
  - void: Este método não retorna nenhum valor.
  - main: Este é o nome do método. Java procura um método chamado "main" para começar a executar o programa.
  - (String[] args): Isso permite que o método aceite argumentos de linha de comando (embora não estejamos usando-os neste exemplo).
3. int temperature = 28;:
  - Esta linha declara uma variável inteira chamada temperature e a inicializa com o valor 28.
  - int é o tipo de dados para números inteiros em Java.
  - O comentário // Temperatura em Celsius explica o que este valor representa.
4. System.out.println("A temperatura é " + temperature + "°C.");:
  - Esta linha imprime uma mensagem no console.
  - System.out.println() é um método que gera texto e move para uma nova linha.
  - O operador + é usado aqui para concatenação de strings, combinando o texto com o valor da variável temperature.
  - O °C no final adiciona o símbolo Celsius à saída.
Esta estrutura básica configura um programa que define uma temperatura e a imprime. Ele fornece uma base para adicionar uma lógica mais complexa, como as declarações if-else que adicionamos mais tarde para dar conselhos sobre o clima com base no valor da temperatura.
Substitua o comentário TODO pelo seguinte código:
```
if (temperature > 30) {
    System.out.println("Está um dia quente. Lembre-se de se manter hidratado!");
} else if (temperature > 20) {
    System.out.println("Está um dia agradável e quente. Aproveite o clima!");
} else if (temperature > 10) {
    System.out.println("Está um pouco frio. Você pode precisar de um casaco leve.");
} else {
    System.out.println("Está frio. Use roupas quentes!");
}
```
Vamos analisar isso:
- A declaração if verifica se a temperatura está acima de 30°C.
- Se não estiver, ela passa para o primeiro else if e verifica se está acima de 20°C.
- Isso continua até encontrar uma condição que seja verdadeira ou atinja o else no final.
- Apenas um desses blocos será executado - assim que uma condição for verdadeira, Java ignora todo o resto.
Salve o arquivo. Na maioria das IDEs, incluindo o WebIDE, você pode salvar pressionando Ctrl+S (ou Cmd+S no Mac).
Agora vamos compilar o programa. No terminal na parte inferior do seu WebIDE, digite:
```
javac ~/project/WeatherAdvisor.java
```
Este comando diz ao Java para compilar seu código. Se você não vir nenhuma saída, isso é bom! Significa que não houve erros.
Para executar o programa, digite:
```
java -cp ~/project WeatherAdvisor
```
A parte -cp ~/project diz ao Java onde encontrar seu código compilado.
Você deve ver esta saída:
```
A temperatura é 28°C.
Está um dia agradável e quente. Aproveite o clima!
```
Isso corresponde ao nosso código porque 28°C está acima de 20°C, mas não acima de 30°C.
Vamos experimentar! Altere o valor da temperature no código para 35, depois salve, compile e execute novamente. Você deve ver:
```
A temperatura é 35°C.
Está um dia quente. Lembre-se de se manter hidratado!
```
Tente alterar a temperatura para 15 e 5, compilando e executando cada vez. Observe como a saída muda!

Parabéns! Você acabou de escrever um programa que toma decisões. Este é um conceito fundamental em programação que você usará o tempo todo.

Trabalhando com Laços For

Agora, vamos aprender sobre laços for (for loops). Eles são ótimos quando você deseja repetir algo um número específico de vezes - como criar uma tabela de multiplicação!

Abra o arquivo MultiplicationTable.java no WebIDE. Você verá:

public class MultiplicationTable {
    public static void main(String[] args) {
        int number = 5;
        System.out.println("Tabela de multiplicação para " + number + ":");

        // TODO: Adicione um laço for aqui para imprimir a tabela de multiplicação
    }
}

Substitua o comentário TODO por este laço for:
```
for (int i = 1; i <= 10; i++) {
    int result = number * i;
    System.out.println(number + " x " + i + " = " + result);
}
```
Vamos analisar isso:
- for (int i = 1; i <= 10; i++) é a declaração do laço for:
  - int i = 1 cria uma variável i e a define como 1. Isso acontece uma vez no início.
  - i <= 10 é a condição. O laço continua enquanto isso for verdadeiro.
  - i++ incrementa i em 1 cada vez que o laço termina.
- Dentro do laço, multiplicamos number por i e imprimimos o resultado.
- Isso se repetirá 10 vezes, com i indo de 1 a 10.
Salve o arquivo.

Compile o programa:

javac ~/project/MultiplicationTable.java

Execute o programa:
```
java -cp ~/project MultiplicationTable
```

Você deve ver a tabela de multiplicação para 5:

Tabela de multiplicação para 5:
5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50

Viu como ele imprimiu a tabela de 1 a 10? Esse é o nosso laço for em ação!

Vamos experimentar! Altere a variável number para 7, depois salve, compile e execute novamente. Você deve ver a tabela de multiplicação para 7.
Quer ver mais? Tente alterar i <= 10 para i <= 15 no laço for. Isso fará com que a tabela vá até 15 em vez de 10.

Os laços for são incrivelmente úteis quando você sabe exatamente quantas vezes deseja repetir algo. Você os usará muito em sua jornada de programação!

Explorando Laços While

Os laços while (while loops) são perfeitos para situações em que você não sabe com antecedência quantas vezes precisa repetir algo. Vamos usar um para criar um jogo de adivinhação de números!

Abra o arquivo GuessTheNumber.java no WebIDE. Você verá:

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

public class GuessTheNumber {
    public static void main(String[] args) {
        Random random = new Random();
        int numberToGuess = random.nextInt(100) + 1; // Número aleatório entre 1 e 100
        Scanner scanner = new Scanner(System.in);
        int guess;
        int attempts = 0;

        System.out.println("Estou pensando em um número entre 1 e 100. Você consegue adivinhá-lo?");

        // TODO: Adicione um laço while aqui para implementar o jogo de adivinhação

        scanner.close();
    }
}

Este código configura um número aleatório para o jogador adivinhar e um scanner para ler a entrada do jogador.

Substitua o comentário TODO por este laço while:

while (true) {
    System.out.print("Digite seu palpite: ");
    guess = scanner.nextInt();
    attempts++;

    if (guess < numberToGuess) {
        System.out.println("Muito baixo! Tente novamente.");
    } else if (guess > numberToGuess) {
        System.out.println("Muito alto! Tente novamente.");
    } else {
        System.out.println("Parabéns! Você adivinhou o número em " + attempts + " tentativas.");
        break;
    }
}

Vamos analisar isso:

while (true) cria um laço infinito. Ele continuará até que digamos para parar.
Dentro do laço, pedimos um palpite e aumentamos o contador de tentativas.
Usamos declarações if-else para verificar se o palpite é muito baixo, muito alto ou correto.
Se o palpite estiver correto, imprimimos uma mensagem de parabéns e usamos break para sair do laço.

Salve o arquivo.
Compile o programa:
```
javac ~/project/GuessTheNumber.java
```
Execute o programa:
```
java -cp ~/project GuessTheNumber
```
Agora jogue o jogo! Continue digitando números até adivinhar corretamente. O programa dirá se você está muito alto ou muito baixo.

Este laço while continua até que o número correto seja adivinhado. Não sabemos quantas tentativas serão necessárias, e é por isso que um laço while é perfeito aqui.

Combinando Estruturas de Controle

Para nosso desafio final, combinaremos declarações if-else, laços for e laços while para criar um localizador de números primos!

Abra o arquivo PrimeNumberFinder.java no WebIDE. Você verá:

import java.util.Scanner;

public class PrimeNumberFinder {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int count = 0;
        int number = 2;

        System.out.print("Quantos números primos você quer encontrar? ");
        int maxPrimes = scanner.nextInt();

        System.out.println("Primeiros " + maxPrimes + " números primos:");

        // TODO: Implemente a lógica de encontrar números primos aqui

        scanner.close();
    }
}

Substitua o comentário TODO por este código:
```
while (count < maxPrimes) {
    boolean isPrime = true;

    for (int i = 2; i <= Math.sqrt(number); i++) {
        if (number % i == 0) {
            isPrime = false;
            break;
        }
    }

    if (isPrime) {
        System.out.print(number + " ");
        count++;
    }

    number++;
}
```
Isso parece complexo, mas vamos analisar:
- Usamos um laço while para continuar encontrando primos até termos a quantidade desejada.
- Para cada número, usamos um laço for para verificar se ele é primo.
- Usamos Math.sqrt(number) como uma otimização - só precisamos verificar até a raiz quadrada do número.
- Se encontrarmos um divisor, sabemos que o número não é primo, então definimos isPrime como false e interrompemos o laço interno.
- Se isPrime ainda for verdadeiro após o laço for, imprimimos o número e aumentamos nossa contagem.
- Sempre aumentamos number no final para passar para o próximo número.
Salve o arquivo.
Compile o programa:
```
javac ~/project/PrimeNumberFinder.java
```
Execute o programa:
```
java -cp ~/project PrimeNumberFinder
```
Quando solicitado, insira um número (como 10) para encontrar essa quantidade de números primos. Você deve ver uma saída como:
```
Quantos números primos você quer encontrar? 10
Primeiros 10 números primos:
2 3 5 7 11 13 17 19 23 29
```

Este programa demonstra o quão poderoso o Java pode ser quando você combina diferentes estruturas de controle. Agora você é capaz de criar programas que podem tomar decisões, repetir ações e resolver problemas complexos!

Resumo

Trabalho fantástico! Neste laboratório, você dominou alguns dos conceitos mais importantes da programação Java:

Declarações If-else: Você as usou para tomar decisões em seu programa de consultoria meteorológica.
Laços For: Você os usou para criar uma tabela de multiplicação, repetindo uma ação um número específico de vezes.
Laços While: Você os usou em seu jogo de adivinhação, repetindo uma ação até que uma condição fosse atendida.
Combinando estruturas de controle: Você juntou tudo para criar um localizador de números primos.

Essas estruturas de fluxo de controle são os blocos de construção de programas complexos. Com elas, você pode criar programas que tomam decisões, repetem ações e resolvem problemas intrincados.

Lembre-se, a prática leva à perfeição. Tente modificar esses programas ou criar novos usando esses conceitos. Você pode criar um programa que dá conselhos diferentes para cada dia da semana? Ou um que imprima uma tabuada para qualquer número até 100? As possibilidades são infinitas!

Continue codificando, continue aprendendo e, o mais importante, divirta-se! Você está no caminho certo para se tornar um especialista em Java.