Está en la página 1de 6

La instrucción switch es una instrucción de múltiples vías.

Proporciona una forma sencilla de


enviar la ejecución a diferentes partes del código en función del valor de la expresión.
Básicamente, la expresión puede ser tipos de datos primitivos byte, short, char e int. A partir
de JDK7, también funciona con tipos enumerados (Enum en java), la clase String y las clases
Wrapper .

Sintaxis de Switch-case:

1. / declaración de switch
2. switch(expresión)
3. {
4. // declaración case
5. // los valores deben ser del mismo tipo de la expresión
6. case valor1 :
7. // Declaraciones
8. break; // break es opcional
9.
10. case valor2 :
11. // Declaraciones
12. break; // break es opcional
13.
14. // Podemos tener cualquier número de declaraciones de casos o case
15. // debajo se encuentra la declaración predeterminada, que se usa cuando ninguno de los casos es
verdadero.
16. // No se necesita descanso en el case default
17. default :
18. // Declaraciones
19. }

Diagrama de Flujo de Switch-case:


Algunas reglas importantes para declaraciones switch:

• Los valores duplicados de los case no están permitidos.


• El valor para un case debe ser del mismo tipo de datos que la variable en el switch.
• El valor para un case debe ser una constante o un literal. Las variables no están
permitidas.
• La declaración break se usa dentro del switch para finalizar una secuencia de
instrucción.
• La declaración break es opcional. Si se omite, la ejecución continuará en el
siguiente case.
• La instrucción default es opcional, y debe aparecer al final del switch.

2. Ejemplos de Switch case


Considere el siguiente programa java, declara un int llamado day cuyo valor representa un día
(1-7). El código muestra el nombre del día, basado en el valor del día, usando la declaración
switch.

1. // rograma Java para demostrar switch case


2. // con tipo de datos primitivos (int)
3. public class Test
4. {
5. public static void main(String[] args)
6. {
7. int day = 5;
8. String dayString;
9.
10. // instrucción switch con tipo de datos int
11. switch (day)
12. {
13. case 1: dayString = "Lunes";
14. break;
15. case 2: dayString = "Martes";
16. break;
17. case 3: dayString = "Miercoles";
18. break;
19. case 4: dayString = "Jueves";
20. break;
21. case 5: dayString = "Viernes";
22. break;
23. case 6: dayString = "Sabado";
24. break;
25. case 7: dayString = "Domingo";
26. break;
27. default: dayString = "Dia inválido";
28. break;
29. }
30. System.out.println(dayString);
31. }
32. }

Salida:

Viernes
2.1. Omitir la declaración break

Como la declaración break es opcional. Si omitimos el break, la ejecución continuará en el


siguiente case. A veces es deseable tener múltiples case sin declaraciones break entre ellos.
Por ejemplo, considere la versión actualizada del programa anterior, también muestra si un día
es un día laborable o uno de fin de semana.

1. // Programa Java para demostrar switch case


2. // con multiples casos sin declaraciones break
3. public class Test
4. {
5. public static void main(String[] args)
6. {
7. int day = 2;
8. String dayType;
9. String dayString;
10.
11. switch (day)
12. {
13. case 1: dayString = "Lunes";
14. break;
15. case 2: dayString = "Martes";
16. break;
17. case 3: dayString = "Miercoles";
18. break;
19. case 4: dayString = "Jueves";
20. break;
21. case 5: dayString = "Viernes";
22. break;
23. case 6: dayString = "Sabado";
24. break;
25. case 7: dayString = "Domingo";
26. break;
27. default: dayString = "Dia invalido";
28. }
29.
30. switch (day)
31. {
32. //multiples cases sin declaraciones break
33.
34. case 1:
35. case 2:
36. case 3:
37. case 4:
38. case 5:
39. dayType = "Dia laborable";
40. break;
41. case 6:
42. case 7:
43. dayType = "Fin de semana";
44. break;
45.
46. default: dayType= "Tipo de dia invalido";
47. }
48.
49. System.out.println(dayString+" es un "+ dayType);
50. }
51. }
Salida:

Martes es un Dia laborable

3. Declaraciones anidadas de Switch Case


Podemos usar un switch como parte de la secuencia de la declaración de un switch externo.
Esto se llama un switch anidado. Como una instrucción de switch define su propio bloque, no
surgen conflictos entre las constantes de case en el switch interno y las del switch externo. Por
ejemplo:

1. // programa de Java para demostrar


2. // declaracines switch case anidadas
3. public class Test
4. {
5. public static void main(String[] args)
6. {
7. String Branch = "CSE";
8. int year = 2;
9.
10. switch(year)
11. {
12. case 1 :
13. System.out.println("Cursos electivos: Ingles, Calculo");
14. break;
15. case 2:
16. switch (Branch) // switch anidado
17. {
18. case "CSE":
19. case "CCE":
20. System.out.println("Cursos electivos : Machine Learning, Big Data");
21. break;
22.
23. case "ECE":
24. System.out.println("Cursos electivos : Programacion");
25. break;
26.
27. default:
28. System.out.println("Cursos electivos : Ingenieria de Software");
29. }
30. }
31. }
32. }

Salida:

Cursos electivos : Machine Learning, Big Data

4. String en Switch Case


Desde JDK 7, podemos usar una cadena literal/constante para controlar una declaración switch,
lo cual no es posible en C/C++. Usar un modificador basado en cadena/string es una mejora c on
respecto al uso de la secuencia equivalente if/else.
Puntos importantes:

• Operación costosa: el “switching” de strings puede ser más costosa en términos de


ejecución que el switching de tipos de datos primitivos. Por lo tanto, es mejor activar el
switch con strings solo en casos de que los datos de control ya estén en forma de cadena.
• String no debe ser NULL: asegúrese de que la expresión en cualquier instrucción
switch no sea nula mientras se trabaja con cadenas para evitar que
una NullPointerException sea lanzada en tiempo de ejecución.
• Case Sensitive – mayúsculas/minúsculas: la instrucción switch compara el objeto
String en su expresión con las expresiones asociadas con cada etiqueta de case como si
estuviera usando el método String.equals; en consecuencia, la comparación de objetos
String en sentencias switch es sensible a mayúsculas y minúsculas.
• Mejor que if-else: el compilador Java genera bytecode generalmente más eficiente a
partir de sentencias switch que usan objetos String que de sentencias if-else anidadas.

Ejemplo:

1. // Programa Java para demostrar el uso de un


2. // string para controlar una declaracion switch
3. public class Test
4. {
5. public static void main(String[] args)
6. {
7. String str = "dos";
8. switch(str)
9. {
10. case "uno":
11. System.out.println("uno");
12. break;
13. case "dos":
14. System.out.println("dos");
15. break;
16. case "tres":
17. System.out.println("tres");
18. break;
19. default:
20. System.out.println("no coincide");
21. }
22. }
23. }

Salida:

dos
TALLER

1. Elaborar un menú de opciones con los siguientes programas:

1. Programa Barlovento de Consola


2. Programa Barlovento de manera Grafica
3. Programa de la suma de dos números
4. Programa que calcula el IVA de un valor dado.
5. Salir del Programa

2. Elaborar un programa que contenga los siguientes menús de opciones anidados:


Utilizar Switch Case Anidados

1. Inicio
1.1 Pegar
1.2 Buscar
1.3 Reemplazar
1.3.1 Buscar y Reemplazar
1.3.2 Ir a
1.3.3 Buscar
2. Insertar
2.1 Portada
2.2 Pagina en Blanco
2.3 Salto de Pagina
3. Diseño
3.1 Temas
3.2 Efectos
3.2.1 Sombras
3.2.2 Vidrio
3.2.3 Textura
3.2.4 Brillante
3.3 Marca de Agua
3.4 Color de Pagina
4. Revisar
4.1 Revisar documentos
4.2 Contar palabras
4.3 Comparar
4.3.1 Compara dos archivos
4.3.1.1 Combinar