ricardotecpro.github.io

☕ Java e Orientação a Objetos: Estruturas Repetitivas

Este material aborda as estruturas de repetição em Java, essenciais para executar blocos de código múltiplas vezes. Veremos como depurar seu código e as aplicações das estruturas while, for e do-while.

🐞 Depuração (Debug) em Java

Depurar código é o processo de encontrar e corrigir erros (bugs) em seus programas. Uma ferramenta de depuração permite executar o código passo a passo, inspecionar variáveis e entender o fluxo de execução.

Como Depurar seu Código

A maioria dos Ambientes de Desenvolvimento Integrado (IDEs) modernos oferece funcionalidades de depuração robustas. Abaixo, veja como realizar as operações básicas de depuração no VS Code e no IntelliJ IDEA.

Conceitos Básicos:

No VS Code (com a extensão “Language Support for Java™ by Red Hat” e “Debugger for Java”):

No IntelliJ IDEA:

Exemplo de Código para Depuração

Vamos considerar um exemplo simples para praticar a depuração. O programa abaixo calcula a área e o preço de um terreno.

import java.util.Locale;
import java.util.Scanner;

public class ProgramaTerreno { // Classe renomeada de Main para ProgramaTerreno

    public static void main(String[] args) {
        Locale.setDefault(Locale.US); // Define o locale para entrada de dados com ponto decimal
        Scanner sc = new Scanner(System.in);

        System.out.print("Digite a largura do terreno: ");
        double largura = sc.nextDouble();

        System.out.print("Digite o comprimento do terreno: ");
        double comprimento = sc.nextDouble();

        System.out.print("Digite o valor do metro quadrado: ");
        double valorMetroQuadrado = sc.nextDouble(); // Variável renomeada de metroQuadrado para valorMetroQuadrado

        double area = largura * comprimento;
        double precoTotal = area * valorMetroQuadrado; // Variável renomeada de preco para precoTotal

        System.out.printf("ÁREA = %.2f m²%n", area); // Mensagem traduzida e unidade adicionada
        System.out.printf("PREÇO = R$ %.2f%n", precoTotal); // Mensagem traduzida e unidade monetária adicionada

        sc.close();
    }
}

Você pode definir breakpoints nas linhas onde as variáveis largura, area ou precoTotal são calculadas para observar seus valores durante a execução.

🔁 Estrutura Repetitiva while (Enquanto)

A estrutura while (que significa “enquanto” em português) é um controle de fluxo que permite repetir um bloco de comandos continuamente, enquanto uma determinada condição permanecer verdadeira.

Quando usar: É ideal quando não se sabe previamente o número exato de vezes que o bloco de comandos precisa ser repetido. A repetição depende de uma condição que pode mudar durante a execução do laço.

Problema Exemplo: Fazer um programa que lê números inteiros fornecidos pelo usuário. O programa deve parar de ler quando o usuário digitar o número zero. Ao final, o programa deve mostrar a soma de todos os números lidos (exceto o zero).

Entrada:

5
2
4
0

Saída Esperada:

11

Sintaxe da Estrutura while

while (condição) {
    // Bloco de comandos a ser repetido
    // Comando 1
    // Comando 2
    // ...
}
// Próximo comando após o laço

Regra de Funcionamento:

  1. A condição (uma expressão booleana) é avaliada.
  2. Se a condição for verdadeira (V):
    • O bloco de comandos dentro do while é executado.
    • Ao final do bloco, o controle retorna para o passo 1 (reavaliação da condição).
  3. Se a condição for falsa (F):
    • O bloco de comandos é ignorado e a execução do programa continua com o primeiro comando após o laço while.

Importante: É crucial que alguma instrução dentro do laço modifique as variáveis envolvidas na condição, de forma que ela eventualmente se torne falsa. Caso contrário, o laço se tornará um laço infinito, e o programa não terminará.

Solução do Problema Exemplo com while

import java.util.Scanner;

public class SomaAteZero {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("Digite números inteiros (digite 0 para parar):");
        int numero = sc.nextInt();
        int soma = 0;

        while (numero != 0) {
            soma = soma + numero; // ou soma += numero;
            numero = sc.nextInt(); // Lê o próximo número
        }

        System.out.println("Soma dos números lidos: " + soma);

        sc.close();
    }
}

✏️ Exercícios de Teste de Mesa com while

“Teste de mesa” (ou desk checking) é uma técnica para simular a execução de um algoritmo manualmente, passo a passo, para verificar sua lógica.

Exemplo 1:

// Código Original:
// x = 5;
// y = 0;
// while (x > 2) {
//     System.out.print(x);
//     y = y + x;
//     x = x - 1;
// }
// Tela: 543

// Código Adaptado para Execução e melhor entendimento:
public class TesteMesaWhile1 {
    public static void main(String[] args) {
        int x = 5;
        int y = 0;
        System.out.print("Saída: ");
        while (x > 2) {
            System.out.print(x);
            y = y + x;
            x = x - 1;
        }
        System.out.println("\nValor final de y: " + y); // Para vermos o resultado de y
    }
}

Saída na Tela:

Saída: 543
Valor final de y: 12

🔢 Estrutura Repetitiva for (Para)

A estrutura for (que significa “para” em português) é outra forma de controle de fluxo que repete um bloco de comandos. Ela é particularmente útil quando se sabe de antemão o número de repetições necessárias ou quando se quer iterar sobre um intervalo definido de valores.

Quando usar: É a escolha ideal quando o número de iterações é conhecido ou facilmente determinável antes do início do laço. Frequentemente usada para contagens (progressivas ou regressivas) ou para percorrer coleções de dados como arrays.

Problema Exemplo: Fazer um programa que lê um valor inteiro N. Em seguida, o programa deve ler N números inteiros fornecidos pelo usuário. Ao final, o programa deve mostrar a soma dos N números lidos.

Entrada:

3  // Valor de N
5  // 1º número
2  // 2º número
4  // 3º número

Saída Esperada:

11 // Soma dos N números

Sintaxe da Estrutura for

for (inicialização; condição; incremento) {
    // Bloco de comandos a ser repetido
    // Comando 1
    // Comando 2
    // ...
}

Regra de Funcionamento:

  1. Inicialização: Executada apenas uma vez, no início da execução do laço. Geralmente, declara-se e/ou inicializa-se uma variável de controle (contador).
  2. Condição: Avaliada antes de cada iteração (incluindo a primeira).
    • Se a condição for verdadeira (V):
      • O bloco de comandos dentro do for é executado.
      • Em seguida, a expressão de incremento é executada.
      • O controle retorna para o início do passo 2 (reavaliação da condição).
    • Se a condição for falsa (F):
      • O bloco de comandos é ignorado e a execução do programa continua com o primeiro comando após o laço for.
  3. Incremento (ou Decremento): Executado ao final de cada iteração, após o bloco de comandos ter sido executado e antes da condição ser reavaliada. Comumente usado para modificar a variável de controle.

Solução do Problema Exemplo com for

import java.util.Scanner;

public class SomaNNumeros {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Quantos números você vai digitar? ");
        int n = sc.nextInt();
        int soma = 0;

        for (int i = 0; i < n; i++) { // i começa em 0 e vai até n-1 (total de n vezes)
            System.out.print("Digite o " + (i + 1) + "º número: ");
            int numero = sc.nextInt();
            soma = soma + numero; // ou soma += numero;
        }

        System.out.println("Soma dos números lidos: " + soma);

        sc.close();
    }
}

Importante: for para Contagens

A estrutura for é excelente para realizar contagens.

Contagem Progressiva: Este código imprimirá os valores de i de 0 a 4.

public class ContagemProgressiva {
    public static void main(String[] args) {
        // i começa em 0; continua enquanto i < 5; incrementa i em 1 a cada passo
        for (int i = 0; i < 5; i++) {
            System.out.println("Valor de i: " + i);
        }
    }
}

Resultado na tela:

Valor de i: 0
Valor de i: 1
Valor de i: 2
Valor de i: 3
Valor de i: 4

Contagem Regressiva: Este código imprimirá os valores de i de 4 a 0.

public class ContagemRegressiva {
    public static void main(String[] args) {
        // i começa em 4; continua enquanto i >= 0; decrementa i em 1 a cada passo
        for (int i = 4; i >= 0; i--) {
            System.out.println("Valor de i: " + i);
        }
    }
}

Resultado na tela:

Valor de i: 4
Valor de i: 3
Valor de i: 2
Valor de i: 1
Valor de i: 0

✏️ Exercícios de Teste de Mesa com for

🔄 Estrutura Repetitiva do-while (Faça-Enquanto)

A estrutura do-while é menos utilizada em comparação com while e for, mas possui uma característica distintiva importante: o bloco de comandos associado a ela é executado pelo menos uma vez, pois a condição de repetição é verificada no final da iteração.

Quando usar: É adequada para situações onde você precisa que um conjunto de ações ocorra ao menos uma vez, e a decisão de repetir ou não só pode ser tomada após essa primeira execução. Um exemplo clássico é a validação de entrada de dados, onde o usuário deve fornecer um dado pelo menos uma vez antes que ele possa ser validado.

Sintaxe da Estrutura do-while

do {
    // Bloco de comandos a ser repetido
    // Comando 1
    // Comando 2
    // ...
} while (condição); // Ponto e vírgula é obrigatório aqui

Regra de Funcionamento:

  1. O bloco de comandos dentro do do-while é executado.
  2. Ao final do bloco, a condição (uma expressão booleana) é avaliada.
  3. Se a condição for verdadeira (V):
    • O controle retorna para o passo 1 (o bloco de comandos é executado novamente).
  4. Se a condição for falsa (F):
    • A execução do programa continua com o primeiro comando após o laço do-while.

Problema Exemplo com do-while

Fazer um programa para ler uma temperatura em Celsius e mostrar o equivalente em Fahrenheit. Após cada conversão, o programa deve perguntar ao usuário se ele deseja repetir a operação (respondendo com ‘s’ para sim ou ‘n’ para não). O programa deve continuar repetindo enquanto o usuário digitar ‘s’.

Fórmula de conversão: F = ((9C/5) + 32)

Exemplo de Interação:

Digite a temperatura em Celsius: 30.0
Equivalente em Fahrenheit: 86.0
Deseja repetir (s/n)? s
Digite a temperatura em Celsius: 21.0
Equivalente em Fahrenheit: 69.8
Deseja repetir (s/n)? n

Solução do Problema Exemplo com do-while

import java.util.Locale;
import java.util.Scanner;

public class ConversorTemperatura { // Classe renomeada de Main para ConversorTemperatura

    public static void main(String[] args) {
        Locale.setDefault(Locale.US);
        Scanner sc = new Scanner(System.in);
        char resposta; // Variável renomeada de resp para resposta

        do {
            System.out.print("Digite a temperatura em Celsius: ");
            double celsius = sc.nextDouble(); // Variável renomeada de C para celsius

            double fahrenheit = 9.0 * celsius / 5.0 + 32.0; // Variável renomeada de F para fahrenheit

            System.out.printf("Equivalente em Fahrenheit: %.1f%n", fahrenheit);

            System.out.print("Deseja realizar outra conversão (s/n)? "); // Mensagem traduzida e melhorada
            resposta = sc.next().charAt(0); // Lê o primeiro caractere da próxima entrada

        } while (resposta == 's' || resposta == 'S'); // Continua se a resposta for 's' ou 'S'

        System.out.println("Programa finalizado.");
        sc.close();
    }
}

Este exemplo demonstra bem o uso do do-while: a conversão da temperatura e a pergunta sobre a repetição ocorrem pelo menos uma vez. Somente após essa primeira execução é que a resposta do usuário (resposta) é verificada para decidir se o processo deve ser repetido.

📚