Switch Case no Java
Tomar decisões é uma parte crucial da programação. Em Java, a função Switch Case é uma das maneiras de tomar decisões com base em um valor específico. Está função permite que você especifique uma variável ou uma expressão para comparar com múltiplos valores e executar diferentes blocos de código com base no valor da variável ou condição.
É uma maneira mais simples e concisa de escrever instruções condicionais do que usar múltiplas instruções if-else. Está função é usada em muitas aplicações Java e é um conceito essencial para todo programador Java entender.
Neste artigo, iremos ver métodos do Switch Case em Java e ilustraremos exemplos para melhorar o entendimento.
MAS O QUE É SWITCH CASE JAVA?
Switch Case é usada para executar diferentes blocos de código com base no valor de uma única variável ou condição. É uma alternativa ao uso de várias condições de if-else para testar a mesma variável ou condição em relação a valores diferentes. Uma ramificação multidirecional no caso do switch permite que o valor de uma condição ou variável altere o fluxo de controle da execução do programa. A condição apresentada dentro instrução switch é avaliada apenas uma vez. O valor de cada caso é comparado ao valor da condição apresentada.
A parte correspondente do código é executada se houver uma correspondência. Para sair da instrução declarada no switch, use a instrução break. Se a instrução break não for usada, o próximo caso será executado mesmo se o valor da expressão não corresponder.
Exemplo:
Raul possui uma rotina exercícios físicos no qual:
- · Corre na Terça-Feira;
- · Malha na Quarta-Feira;
- · Nada na Quinta-Feira;
- · Joga Bola com os amigos de trabalho na Sexta-Feira;
Com base nas informações de Raul, poderíamos facilmente utilizar if-else para criamos atribuições e condições com os valores dos dias e os esportes praticados em cada um deles. Porém vamos ver como se torna mais fácil neste caso usar Switch Case. Lembrando que if-else pode ser mais flexível em algumas outras condições complexas, porém em situações mais fáceis de ler vários casos é uma maneira mais concisa se utilizar o Switch Case.
SINTAXE DO SWITCH CASE NO JAVA:
switch (condicaoValor) {
case valor1:
// o caso será executado quando = valor1
break;
case valor2:
// o caso será executado quando = valor2
break;
...
default:
// irá ser executado quando não houver nenhum caso correspondente
break;
}
O significado de todos os parâmetros usados na sintaxe acima é dado abaixo:
- condicaoValor: É a variável ou condição cujo valor queremos testar em relação a valores diferentes.
- case: cada caso especifica um valor possível da condicaoValor, juntamente com o código a ser executado se a condicaoValor for igual a esse valor.
- break: O break é usado para sair da instrução switch depois que o caso correspondente é executado.
- default: O caso default “padrão” é opcional e fornece uma opção de inicial se nenhum dos outros casos corresponder a condição especificada.
ALGUMAS REGRAS IMPORTANTES DO SWITCH CASE
Algumas regras são importantes para instruções de switch Java:
- A condição da instrução switch precisa ser de um tipo que possa ser comparado a inteiros. Isso inclui a classe String, os tipos enum e os tipos primitivos byte, short, char e int.
- Os rótulos de maiúsculas e minúsculas devem ser literais ou constantes do mesmo tipo que a expressão da instrução switch.
- Embora o uso da instrução break para sair da instrução switch uma vez que o caso desejado tenha sido executado seja opcional, é uma estratégia recomendada. Se a instrução break não for usada, o rótulo do próximo caso será executado mesmo se o valor da expressão não corresponder.
- O caso padrão não é necessário. A instrução switch passará automaticamente para a instrução a seguir se nem o caso padrão nem um rótulo de maiúsculas e minúsculas que corresponda ao valor da expressão estiverem presentes.
USO DO SWITCH CASE EM JAVA
- CÓDIGO MAIS LIMPO: Quando comparado ao emprego de várias instruções if-else aninhadas para várias situações, elas tornam o código mais legível e sustentável.
- RAMIFICAÇÕES MÚLTIPLAS: As instruções de caso de opção são usadas quando uma única variável ou expressão deve ser testada em várias situações diferentes.
- RAMIFICAÇÃO BASEADA EM VALOR: Você pode utilizar Enums e tipos integrais (int, char, byte e short) como a expressão de controle em uma instrução switch-case.
- EFICAZ: Ao lidar com muitas condições, as declarações de caso de troca são frequentemente mais eficazes do que a utilização de muitas instruções if-else.
VANTAGENS DE UTILIZAÇÃO DO SWITCH CASE
- SIMPLIFICA O CÓDIGO: Usar uma instrução switch pode ser mais simples e conciso do que usar várias instruções if-else para testar a mesma variável ou expressão em relação a valores diferentes.
- LEGIBILIDADE: As instruções Switch geralmente são mais fáceis de ler e entender do que várias instruções if-else, especialmente ao testar um grande número de valores.
- DESEMPENHO: O uso de instruções switch geralmente pode levar a tempos de execução mais rápidos do que instruções if else equivalentes, especialmente quando o número de valores que estão sendo testados é grande.
- PROPENSO A ERROS: As instruções Switch são menos propensas a erros do que o uso de várias instruções if-else porque cada caso deve ter um valor exclusivo e o caso padrão pode capturar quaisquer valores inesperados.
- MELHOR CONTROLE: As instruções Switch fornecem um fluxo de controle melhor do que as instruções if-else porque a instrução break é usada para sair da instrução switch depois que o caso correspondente é executado.
COMO FUNCIONA O SWITCH CASE?
Quando executamos a função Switch Case a condição é avaliada e irá comparar cada caso da ramificação declarado e:
- Se um caso correspondente for encontrado, o bloco de código correspondente será executado.
- Se não houver maiúsculas e minúsculas correspondentes, o código no bloco padrão será executado (se estiver definido).
A instrução break é usada para sair do bloco de switch.
FLUXOGRAMA DO SWITCH CASE :
SWITCH CASE ANINHADO
Um caso de switch aninhado é uma condição de switch contida em outra condição de switch. Em outras palavras, é uma instrução switch que é usada como uma das instruções dentro de outra instrução switch.
A sua sintaxe é muito semelhante à de um caso de switch normal, com a adição de uma condição de um switch interno do dentro de um dos blocos de códigos do switch externo.
SINTAXE DO CASE ANINHADO:
switch (questao) {
case questaoCaso1:
// realiza operação
switch (interacao) {
case interacaoCaso1:
// realiza operação
break;
case interacaoCaso2:
// realiza operação
break;
default:
// realiza operação
break;
}
// realiza operação
break;
case questaoCaso2:
// do realiza operação
default:
// realiza operação
break;
}
Nessa sintaxe, questao é a variável que está sendo avaliada na condição do switch case questao e questaoCaso1, questaoCaso2, etc., são os diferentes casos que a instrução switch pode corresponder.
Dentro de um dos blocos de códigos do switch externo, há uma instrução de switch interno que avalia o valor de interacao. interacaoCaso1, interacaoCaso2, etc., são os diferentes casos que a instrução do switch interno pode corresponder.
Cada bloco de caso nas instruções de switch externo e interno pode conter instruções a serem executadas quando esse caso for correspondido. Ambas as instruções de switch terminam com uma instrução break para sair do bloco de switch.
Tomemos um exemplo:
Neste exemplo, temos uma instrução de switch externo que avalia o valor de questionVar. Se questionVar for igual a 2, então temos uma instrução de switch aninhada que avalia o valor de stateVar.
Exemplificação de código no Java:
public class SwitchCaseTest {
public static void main(String[] args) {
int questionVar = 2;
int stateVar = 1;
switch (questionVar) {
case 1:
System.out.println("Question-case 1");
break;
case 2:
switch (stateVar) {
case 1:
System.out.println("State-case 1");
break;
case 2:
System.out.println("State-case 2");
break;
default:
System.out.println("Invalid state case");
break;
}
break;
case 3:
System.out.println("Question -case 3");
break;
default:
System.out.println("Invalid question case");
break;
}
}
}
Saída:
State-case 1
Detalhamento do código acima:
- Se stateVar for igual a 1, a instrução do switch interno corresponderá ao primeiro caso e imprimirá "State Case 1".
- Caso contrário, se stateVar for igual a 2, a instrução do switch interno corresponderá ao segundo caso e imprimirá "State Case 2".
- Se stateVar não for 1 ou 2, a instrução do switch interno corresponderá ao caso padrão e imprimirá "Invalid state case".
- Se questionVar não for 2, a instrução do switch externo verifica os outros casos e imprime as mensagens correspondentes.
UTILIZANDO STRING
Podemos utilizar e executar diferentes ações com base nos valores de strings utilizando o Switch Case com uma string. Abaixo iremos exemplificar como utilizar a declaração de strings utilizando switch case.
public class StringSwitch{
public static void main(String[] args) {
String day = "Tuesday";
switch (day) {
case "Monday":
System.out.println("It's Monday!");
break;
case "Tuesday":
System.out.println("It's Tuesday!");
break;
case "Wednesday":
System.out.println("It's Wednesday!");
break;
case "Thursday":
System.out.println("It's Thursday!");
break;
case "Friday":
System.out.println("It's Friday!");
break;
default:
System.out.println("It's a weekend day or an invalid day.");
break;
}
}
}
Saída:
It's Tuesday!
