Nesta aula, continuaremos explorando as estruturas de controle em Java, abordando comandos para manipular o fluxo dentro de loops e a estrutura switch-case para múltiplas condições.
A estrutura switch-case é uma alternativa ao if-else-if quando precisamos verificar múltiplas condições para uma única variável.
public class EstruturaSwitch {
public static void main(String[] args) {
int diaDaSemana = 3;
// Usando switch para determinar o dia da semana
switch (diaDaSemana) {
case 1:
System.out.println("Domingo");
break;
case 2:
System.out.println("Segunda-feira");
break;
case 3:
System.out.println("Terça-feira");
break;
case 4:
System.out.println("Quarta-feira");
break;
case 5:
System.out.println("Quinta-feira");
break;
case 6:
System.out.println("Sexta-feira");
break;
case 7:
System.out.println("Sábado");
break;
default:
System.out.println("Valor inválido para dia da semana");
break;
}
// Switch com char
char opcao = 'B';
switch (opcao) {
case 'A':
System.out.println("Opção A selecionada");
break;
case 'B':
System.out.println("Opção B selecionada");
break;
case 'C':
System.out.println("Opção C selecionada");
break;
default:
System.out.println("Opção inválida");
break;
}
}
}
Terça-feira
Opção B selecionada
Nota: A instrução break é usada para sair do switch após a execução do bloco correspondente. Se o break for omitido, a execução "cai" para o próximo caso, continuando a execução a partir dali.
Quando o break é omitido em um case, a execução continua para os próximos cases até encontrar um break ou o fim do switch. Isso é chamado de "fall-through".
public class SwitchSemBreak {
public static void main(String[] args) {
int dia = 3;
// Switch sem break para categorizar dias
System.out.print("O dia " + dia + " é ");
switch (dia) {
case 1:
case 7:
System.out.println("final de semana.");
break;
case 2:
case 3:
case 4:
case 5:
case 6:
System.out.println("dia útil.");
break;
default:
System.out.println("inválido.");
break;
}
// Outro exemplo de fall-through para mostrar notas
char nota = 'B';
System.out.print("Nota " + nota + ": ");
switch (nota) {
case 'A':
System.out.print("Excelente! ");
// Cai para o próximo case
// Se char nota = 'A'; O resultado seria “Excelente! Muito bom! Bom.”
// Acumula respostas até encontrar o break.
case 'B':
System.out.print("Muito bom! ");
// Cai para o próximo case
case 'C':
System.out.print("Bom. ");
break;
case 'D':
System.out.print("Regular. ");
break;
case 'F':
System.out.print("Reprovado. ");
break;
default:
System.out.print("Nota inválida. ");
}
}
}
O dia 3 é dia útil.
Nota B: Muito bom! Bom.
Dica: O comportamento de "fall-through" (queda) do switch pode ser útil quando você deseja que múltiplos casos tenham o mesmo comportamento ou quando você quer combinar comportamentos.
A partir do Java 7, a estrutura switch também pode usar Strings como expressão de controle.
public class SwitchComString {
public static void main(String[] args) {
String mes = "Abril";
switch (mes) {
case "Janeiro":
System.out.println("Mês 1");
break;
case "Fevereiro":
System.out.println("Mês 2");
break;
case "Março":
System.out.println("Mês 3");
break;
case "Abril":
System.out.println("Mês 4");
break;
case "Maio":
System.out.println("Mês 5");
break;
default:
System.out.println("Mês desconhecido");
break;
}
// Outro exemplo: comandos de um jogo
String comando = "AJUDA";
switch (comando.toLowerCase()) { // Convertendo para minúsculas para comparação não sensível a caso
case "iniciar":
System.out.println("Iniciando o jogo...");
break;
case "pausar":
System.out.println("Jogo pausado");
break;
case "ajuda":
System.out.println("Comandos disponíveis: iniciar, pausar, sair, ajuda");
break;
case "sair":
System.out.println("Saindo do jogo...");
break;
default:
System.out.println("Comando desconhecido. Digite 'ajuda' para ver os comandos disponíveis.");
}
}
}
Mês 4
Comandos disponíveis: iniciar, pausar, sair, ajuda
O comando break é usado para interromper a execução de um loop (for, while, do-while) ou de um switch.
public class ComandoBreak {
public static void main(String[] args) {
// Usando break para sair de um loop for
System.out.println("Procurando o número 5:");
for (int i = 1; i <= 10; i++) {
System.out.print(i + " ");
if (i == 5) {
System.out.println("\nEncontrei o 5! Saindo do loop...");
break; // Sai do loop quando i é igual a 5
}
}
// Usando break para sair de um loop while
System.out.println("\nProcurando o primeiro número divisível por 7:");
int contador = 1;
while (contador <= 20) {
if (contador % 7 == 0) {
System.out.println("Encontrei: " + contador);
break; // Sai do loop quando encontrar o primeiro número divisível por 7
}
contador++;
}
// Exemplo prático: procurando um elemento em um array
int[] numeros = {10, 20, 30, 40, 50, 60};
int busca = 40;
int posicao = -1; // -1 indica que o elemento não foi encontrado
for (int i = 0; i < numeros.length; i++) {
if (numeros[i] == busca) {
posicao = i;
break; // Ao encontrar o elemento, não precisa continuar a busca
}
}
if (posicao != -1) {
System.out.println("\nO elemento " + busca + " foi encontrado na posição " + posicao);
} else {
System.out.println("\nO elemento " + busca + " não foi encontrado no array");
}
}
}
Procurando o número 5:
1 2 3 4 5
Encontrei o 5! Saindo do loop...
Procurando o primeiro número divisível por 7:
Encontrei: 7
O elemento 40 foi encontrado na posição 3
O comando continue é usado para pular a iteração atual de um loop e continuar com a próxima iteração.
public class ComandoContinue {
public static void main(String[] args) {
// Imprimindo apenas números ímpares
System.out.println("Números ímpares de 1 a 10:");
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) {
continue; // Pula números pares
}
System.out.print(i + " ");
}
// Pulando uma iteração específica
System.out.println("\n\nContagem de 1 a 10 (exceto o 7):");
for (int i = 1; i <= 10; i++) {
if (i == 7) {
continue; // Pula o número 7
}
System.out.print(i + " ");
}
// Exemplo com while: somando apenas números positivos
int[] valores = {5, -3, 10, -7, 8, 0, 4};
int soma = 0;
int i = 0;
System.out.println("\n\nSomando apenas números positivos:");
while (i < valores.length) {
if (valores[i] <= 0) {
i++;
continue; // Pula números negativos ou zero
}
soma += valores[i];
System.out.println("Adicionando " + valores[i] + " à soma: " + soma);
i++;
}
System.out.println("Soma total dos valores positivos: " + soma);
}
}
Números ímpares de 1 a 10:
1 3 5 7 9
Contagem de 1 a 10 (exceto o 7):
1 2 3 4 5 6 8 9 10
Somando apenas números positivos:
Adicionando 5 à soma: 5
Adicionando 10 à soma: 15
Adicionando 8 à soma: 23
Adicionando 4 à soma: 27
Soma total dos valores positivos: 27
Diferença entre break e continue:
É possível ter um loop dentro de outro loop. Isso é útil para trabalhar com estruturas bidimensionais, como matrizes, ou para processar dados de forma mais complexa.
public class LoopsAninhados {
public static void main(String[] args) {
// Imprimindo uma matriz 3x3
// Matriz será estudado mais adiante.
System.out.println("Matriz 3x3:");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.print("(" + i + "," + j + ") ");
}
System.out.println(); // Nova linha após cada linha da matriz
}
// Imprimindo um padrão de asteriscos (triângulo)
System.out.println("\nTriângulo de asteriscos:");
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= i; j++) {
System.out.print("* ");
}
System.out.println();
}
// Imprimindo a tabuada de multiplicação de 1 a 5
System.out.println("\nTabuada de multiplicação (1 a 5):");
for (int i = 1; i <= 5; i++) {
System.out.println("Tabuada do " + i + ":");
for (int j = 1; j <= 10; j++) {
System.out.println(i + " x " + j + " = " + (i * j));
}
System.out.println(); // Linha em branco entre tabuadas
}
}
}
Matriz 3x3:
(0,0) (0,1) (0,2)
(1,0) (1,1) (1,2)
(2,0) (2,1) (2,2)
Triângulo de asteriscos:
*
* *
* * *
* * * *
* * * * *
Tabuada de multiplicação (1 a 5):
Tabuada do 1:
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
1 x 5 = 5
1 x 6 = 6
1 x 7 = 7
1 x 8 = 8
1 x 9 = 9
1 x 10 = 10
Tabuada do 2:
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18
2 x 10 = 20
[... restante da saída omitido ...]
O comando return é usado para encerrar a execução de um método e, opcionalmente, retornar um valor para o chamador.
public class ComandoReturn {
public static void main(String[] args) {
// Chamando um método que retorna um valor
int soma = somar(5, 7);
System.out.println("A soma é: " + soma);
// Chamando um método que retorna um valor condicional
int maior = encontrarMaior(10, 8);
System.out.println("O maior número é: " + maior);
// Chamando um método que retorna antecipadamente
verificarIdade(15); // Menor de idade
verificarIdade(18); // Pode entrar
// Exemplo mais complexo: encontrar um elemento em um array
int[] numeros = {10, 20, 30, 40, 50};
int posicao = buscarNumero(numeros, 30);
if (posicao != -1) {
System.out.println("Número encontrado na posição: " + posicao);
} else {
System.out.println("Número não encontrado no array.");
}
}
// Método que soma dois números e retorna o resultado
public static int somar(int a, int b) {
return a + b; // Retorna o resultado da soma
}
// Método que retorna o maior de dois números
public static int encontrarMaior(int a, int b) {
if (a > b) {
return a; // Retorna a se a for maior
} else {
return b; // Retorna b se b for maior ou igual
}
}
// Método que usa return para sair antecipadamente
public static void verificarIdade(int idade) {
System.out.println("Verificando idade: " + idade);
if (idade < 18) {
System.out.println("Menor de idade, entrada não permitida.");
return; // Sai do método antecipadamente
}
// Este código só será executado se idade >= 18
System.out.println("Idade verificada, entrada permitida.");
}
// Método que busca um número em um array
public static int buscarNumero(int[] array, int numero) {
for (int i = 0; i < array.length; i++) {
if (array[i] == numero) {
return i; // Retorna a posição do número quando encontrado
}
}
return -1; // Retorna -1 se o número não for encontrado
}
}
A soma é: 12
O maior número é: 10
Verificando idade: 15
Menor de idade, entrada não permitida.
Verificando idade: 18
Idade verificada, entrada permitida.
Número encontrado na posição: 2
Observações sobre o comando return:
void, o return sem valor pode ser usado para sair antecipadamente.return deve ser acompanhado por um valor do tipo especificado na assinatura do método.return, nenhum código do método será executado.Teste seus conhecimentos sobre estruturas de controle avançadas em Java:
Reforce o conteúdo desta aula com mais dois exercícios práticos: