image

Accede a bootcamps ilimitados y a más de 650 cursos

50
%OFF
Article image
Igor Silva
Igor Silva17/10/2025 06:25
Compartir

Estruturas de Controle e Repetição em Java: while, do-while, if, else e switch case

  • #Java

No desenvolvimento em Java, é essencial compreender como funcionam as estruturas de controle e repetição, pois são elas que determinam o fluxo lógico do programa. Entre as principais estruturas estão: while, do-while, if, else e switch case.

Estrutura de repetição: while

A estrutura while é utilizada quando se deseja executar repetidamente um bloco de código enquanto uma condição for verdadeira. O teste lógico é feito antes da execução, o que significa que, se a condição for falsa desde o início, o bloco não será executado nenhuma vez.

Exemplo:

int i = 1;


while (i <= 5) {
  System.out.println(i);
  i++;
}

Saída Esperada:

1
2
3
4
5
  • O loop será executado enquanto i for menor ou igual a 5.
  • A cada repetição, i é incrementado.
  • Quando i chega a 6, a condição se torna falsa e o laço termina.

Estrutura de repetição: do-while

O do-while tem comportamento semelhante ao while, mas com uma diferença importante: o bloco de código é executado pelo menos uma vez, independentemente da condição, a verificação da condição ocorre após a execução.

Exemplo:

int i = 1;


do {
  System.out.println(i);
  i++;
} while (i <= 5);
  • Primeiro o código dentro do do é executado.
  • Em seguida, o Java verifica se a condição (i <= 5) é verdadeira.
  • Caso seja, o bloco é executado novamente; caso contrário, o loop termina.

Estrutura condicional: if

A estrutura if é utilizada para tomar decisões no código. Ela executa um bloco de instruções apenas se a condição especificada for verdadeira.

Exemplo:

int idade = 18;


if (idade >= 18) {
  System.out.println("Você é maior de idade.");
}
  • Se a variável idade for maior ou igual a 18, a mensagem será exibida.
  • Caso contrário, o bloco if será ignorado.

Estrutura condicional: else

O else complementa o if, permitindo que o programa execute um caminho alternativo caso a condição testada seja falsa.

Exemplo:

int idade = 16;


if (idade >= 18) {
  System.out.println("Maior de idade.");
} else {
  System.out.println("Menor de idade.");
}
  • Se a condição idade >= 18 for verdadeira, o primeiro bloco é executado.
  • Caso contrário, o código dentro de else é executado.

Estrutura condicional: switch case

A estrutura switch case é usada quando se deseja comparar uma variável com vários valores possíveis, oferecendo uma alternativa mais organizada ao uso de múltiplos if-else.

Exemplo:

switch (opcao) {
  case 1:
      System.out.println("Você escolheu a opção 1.");
      break;
  case 2:
      System.out.println("Você escolheu a opção 2.");
      break;
  case 3:
      System.out.println("Você escolheu a opção 3.");
      break;
  default:
      System.out.println("Opção inválida.");
}
  • O valor da variável opção é comparado com cada case.
  • Quando o valor coincide, o bloco correspondente é executado.
  • O comando break é utilizado para interromper o fluxo, evitando que os próximos casos sejam executados.
  • O default funciona como um else, sendo executado quando nenhum dos casos é verdadeiro.

Conclusão

Compreender e saber aplicar corretamente as estruturas while, do-while, if, else e switch case é essencial para qualquer programador Java. Essas estruturas controlam o fluxo lógico da aplicação, tornando o código mais dinâmico, funcional e eficiente. O domínio desses conceitos é a base para avançar em tópicos mais complexos, como estruturas de dados, funções e programação orientada a objetos.

Referência:

JDK 21 Documentation - Home

Compartir
Recomendado para ti
PcD Tech Bradesco - Java & QA Developer
Riachuelo - Primeiros Passos com Java
GFT Start #7 - Java
Comentarios (3)
José Lucas
José Lucas - 17/10/2025 15:00

muito bem gostei do artigo


Igor Silva
Igor Silva - 17/10/2025 12:54

O maior desafio para um desenvolvedor ao trabalhar com o padrão MVC (Model-View-Controller) não está em compreender sua teoria, mas em manter a disciplina arquitetural na prática, especialmente à medida que o projeto cresce.

No início, tudo parece simples:

  • Model: representa os dados e a lógica de negócio.
  • View: exibe as informações ao usuário.
  • Controller: recebe as ações e coordena o fluxo entre Model e View.


Com o tempo, porém, as fronteiras entre essas camadas tendem a se confundir.

Na pressa de “fazer funcionar”, o desenvolvedor pode acabar inserindo lógica de negócio no Controller ou misturando regras de exibição na View.

Esse tipo de desvio gera acoplamento, e o MVC deixa de cumprir seu propósito.

O código até “funciona”, mas se transforma em uma armadilha técnica, difícil de evoluir e refatorar.

Quando a separação de responsabilidades é negligenciada, o projeto perde sua estrutura.

As consequências incluem:

  • Aumento do acoplamento.
  • Dificuldade de manutenção.
  • Baixa testabilidade.
  • Menor reutilização.
  • Efeito cascata.


Para manter o baixo acoplamento e garantir a saúde do projeto ao longo do tempo, é essencial respeitar a função de cada camada e adotar práticas que reforcem a independência entre elas.

Algumas abordagens fundamentais incluem:

  • Definir responsabilidades claras.
  • Evitar dependências diretas.
  • Aplicar o princípio da inversão de dependência.
  • Automatizar testes e revisões de código.


Em geral, a separação de responsabilidades e o baixo acoplamento não são apenas boas práticas de organização, mas investimentos na longevidade e na qualidade do software.

São esses princípios que garantem que o projeto permaneça escalável, legível e sustentável.

DIO Community
DIO Community - 17/10/2025 09:41

Excelente, Igor! Que artigo incrível e super completo sobre Estruturas de Controle e Repetição em Java! É fascinante ver como você aborda o tema, mostrando que o domínio dessas estruturas é essencial para que o programa consiga tomar decisões e repetir ações (o fluxo lógico do código).

Qual você diria que é o maior desafio para um desenvolvedor ao trabalhar com um projeto que usa o padrão MVC, em termos de manter a separação de responsabilidades e de evitar o acoplamento entre as três camadas, em vez de apenas focar em fazer a aplicação funcionar?