Estruturas de decisão e iteração em Java

As estruturas de decisão permitem que o programa escolha entre diferentes caminhos de execução com base em condições. As principais estruturas de decisão em Java são: if-else, switch, e o operador ternário. Nest post, conheça melhor as estruturas de decisão e iteração em Java.

Estrutura IF-ELSE

A estrutura if-else é usada para executar um bloco de código se uma condição for verdadeira e outro bloco se a condição for falsa.

public class ExemploIfElse {
    public static void main(String[] args) {
        int idade = 18;

        if (idade >= 18) {
            System.out.println("Você é maior de idade.");
        } else {
            System.out.println("Você é menor de idade.");
        }
    }
}

Estrutura IF-ELSE IF-ELSE

Quando há várias condições a serem verificadas, você pode usar a estrutura if-else if-else, que permite verificar múltiplas condições em sequência.

public class ExemploIfElseIf {
    public static void main(String[] args) {
        int nota = 85;

        if (nota >= 90) {
            System.out.println("Aprovado com A");
        } else if (nota >= 80) {
            System.out.println("Aprovado com B");
        } else if (nota >= 70) {
            System.out.println("Aprovado com C");
        } else {
            System.out.println("Reprovado");
        }
    }
}

Estrutura SWITCH-CASE

O switch-case é uma alternativa ao if-else quando você precisa comparar o valor de uma variável com vários valores diferentes. Ele é especialmente útil quando você tem muitas condições baseadas em igualdade.

public class ExemploSwitch {
    public static void main(String[] args) {
        int dia = 3;

        switch (dia) {
            case 1:
                System.out.println("Domingo");
                break;
            case 2:
                System.out.println("Segunda-feira");
                break;
            case 3:
                System.out.println("Terça-feira");
                break;
            default:
                System.out.println("Dia inválido");
        }
    }
}

Operador ternário

O operador ternário é uma forma concisa de escrever uma estrutura if-else. Ele é útil para expressões curtas.

public class ExemploTernario {
    public static void main(String[] args) {
        int idade = 18;
        String resultado = (idade >= 18) ? "Maior de idade" : "Menor de idade";
        System.out.println(resultado);
    }
}

Estruturas de iteração

As estruturas de iteração, ou loops, permitem que um bloco de código seja repetido várias vezes, até que uma condição seja satisfeita. As principais estruturas de iteração em Java são: for, while, e do-while.

1. Estrutura FOR

A estrutura for é ideal quando você sabe antecipadamente quantas vezes o loop deve ser executado. Ela consiste em três partes: inicialização, condição de continuidade e incremento.

public class ExemploFor {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("Iteração " + i);
        }
    }
}

2. Estrutura WHILE

A estrutura while executa um bloco de código enquanto uma condição for verdadeira. Ela é útil quando não se sabe ao certo quantas iterações serão necessárias, mas há uma condição que determina a continuidade.

public class ExemploWhile {
    public static void main(String[] args) {
        int contador = 0;

        while (contador < 5) {
            System.out.println("Contagem: " + contador);
            contador++;
        }
    }
}

3. Estrutura DO-WHILE

A estrutura do-while é semelhante ao while, mas a principal diferença é que o bloco de código é executado pelo menos uma vez, independentemente da condição.

public class ExemploDoWhile {
    public static void main(String[] args) {
        int contador = 0;

        do {
            System.out.println("Contagem: " + contador);
            contador++;
        } while (contador < 5);
    }
}

4. Estrutura FOR-EACH

O for-each é uma variação do for, muito útil para iterar sobre coleções ou arrays de forma simplificada, sem precisar de um índice de controle.

public class ExemploForEach {
    public static void main(String[] args) {
        int[] numeros = {1, 2, 3, 4, 5};

        for (int num : numeros) {
            System.out.println("Número: " + num);
        }
    }
}

Controlando fluxo de execução em koops

Além das estruturas básicas, Java também fornece algumas palavras-chave que ajudam a controlar o fluxo de execução dentro dos loops:

• break: Interrompe a execução do loop e sai dele;
  
  
• continue: Interrompe a iteração atual e pula para a próxima.

Exemplo com break e continue:

public class ExemploBreakContinue {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break; // Interrompe o loop quando i é igual a 5
            }
            if (i % 2 == 0) {
                continue; // Pula para a próxima iteração se o número for par
            }
            System.out.println("Número ímpar: " + i);
        }
    }
}

As estruturas de decisão e iteração são a base para criar programas que se adaptam a diferentes condições e que podem repetir tarefas de maneira eficiente.

Ao dominar o uso de if-else, switch, for, while, e do-while, você será capaz de escrever código Java mais flexível e dinâmico. Essas ferramentas oferecem controle preciso sobre como e quando o código é executado, permitindo a criação de soluções robustas e escaláveis.

Dúvidas ou sugestões sobre estruturas de decisão e iteração em Java? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: decisão iteração java