El declaración de cambio en Java es una declaración de rama multidireccional. En palabras simples, la declaración de cambio de Java ejecuta una declaración a partir de múltiples condiciones.

es como un si-si no-si declaración de escalera. Proporciona una manera sencilla de enviar la ejecución a diferentes partes del código según el valor de la expresión. La expresión puede ser una byte , corto , carbonizarse , o En t tipo de datos primitivo. Pone a prueba la igualdad de variables frente a múltiples valores.

Nota: La expresión de cambio de Java debe ser byte, short, int, long (con su tipo Wrapper), enumeraciones y cadena. A partir de JDK7, también funciona con tipos enumerados ( Enumeraciones en java), el Cadena clase, y Envoltura clases.

Sintaxis

switch(expression) {  case value1 :  // Statements  break; // break is optional    case value2 :  // Statements  break; // break is optional  ....  ....  ....  default :   // default Statement }>

Ejemplo:

Ejemplo de tamaño de impresora

public class SizePrinter {  public static void main(String[] args) {  int sizeNumber = 2; // Replace with your desired size (1, 2, 3, 4, or 5)  switch (sizeNumber) {  case 1:  System.out.println('Extra Small');  break;  case 2:  System.out.println('Small');  break;  case 3:  System.out.println('Medium');  break;  case 4:  System.out.println('Large');  break;  case 5:  System.out.println('Extra Large');  break;  default:  System.out.println('Invalid size number');  }  } }>

Producción:

Small>

Algunas reglas importantes para las declaraciones de cambio de Java

1. Puede haber cualquier cantidad de casos que simplemente impongan la verificación de condiciones, pero recuerde que no se permiten valores de casos duplicados.
2. El valor de un caso debe ser del mismo tipo de datos que la variable en el conmutador.
3. El valor de un caso debe ser constante o literal. No se permiten variables.
4. La declaración break se utiliza dentro del interruptor para terminar una secuencia de declaraciones.
5. La declaración de ruptura es opcional. Si se omite, la ejecución continuará en el siguiente caso.
6. La declaración predeterminada es opcional y puede aparecer en cualquier lugar dentro del bloque de cambio. En caso de que no esté al final, se debe mantener una declaración de interrupción después de la declaración predeterminada para omitir la ejecución de la siguiente declaración de caso.

  Note: Until Java-6, switch case argument cannot be of String type but Java 7 onward we can use String type argument in Switch Case.>

Diagrama de flujo de la declaración Switch-Case

Este diagrama de flujo muestra el flujo de control y el funcionamiento de las declaraciones de cambio:

lista de programas de Python

Nota: La declaración de cambio de Java es una declaración de caída que significa que ejecuta todas las declaraciones si romper palabra clave no se utiliza, por lo que es muy esencial utilizar la palabra clave break dentro de cada caso.

Ejemplo: Día de búsqueda

Considere el siguiente programa Java, declara un int llamado día cuyo valor representa un día (1-7). El código muestra el nombre del día, según el valor del día, utilizando la instrucción switch.

// Java program to Demonstrate Switch Case // with Primitive(int) Data Type // Class public class GFG {  // Main driver method  public static void main(String[] args)  {  int day = 5;  String dayString;  // Switch statement with int data type  switch (day) {  // Case  case 1:  dayString = 'Monday';  break;  // Case  case 2:  dayString = 'Tuesday';  break;  // Case  case 3:  dayString = 'Wednesday';  break;  // Case  case 4:  dayString = 'Thursday';  break;  // Case  case 5:  dayString = 'Friday';  break;  // Case  case 6:  dayString = 'Saturday';  break;  // Case  case 7:  dayString = 'Sunday';  break;  // Default case  default:  dayString = 'Invalid day';  }  System.out.println(dayString);  } }>

Friday>

Declaraciones de rotura en la caja del interruptor

A declaración de ruptura es opcional. Si omitimos la pausa, la ejecución continuará en el siguiente caso.

A veces es deseable tener varios casos sin romper declaraciones entre ellos. Por ejemplo, consideremos la versión actualizada del programa anterior, que también muestra si un día es entre semana o fin de semana.

Ejemplo:

Cambiar programa de declaración sin múltiples interrupciones

// Java Program to Demonstrate Switch Case // with Multiple Cases Without Break Statements // Class public class GFG {  // main driver method  public static void main(String[] args)  {  int day = 2;  String dayType;  String dayString;  // Switch case  switch (day) {  // Case  case 1:  dayString = 'Monday';  break;  // Case  case 2:  dayString = 'Tuesday';  break;  // Case  case 3:  dayString = 'Wednesday';  break;  case 4:  dayString = 'Thursday';  break;  case 5:  dayString = 'Friday';  break;  case 6:  dayString = 'Saturday';  break;  case 7:  dayString = 'Sunday';  break;  default:  dayString = 'Invalid day';  }  switch (day) {  // Multiple cases without break statements  case 1:  case 2:  case 3:  case 4:  case 5:  dayType = 'Weekday';  break;  case 6:  case 7:  dayType = 'Weekend';  break;  default:  dayType = 'Invalid daytype';  }  System.out.println(dayString + ' is a ' + dayType);  } }>

Tuesday is a Weekday>

Declaraciones de cambio anidado de Java

Podemos usar un cambiar como parte de la secuencia de declaraciones de un interruptor exterior. Esto se llama un interruptor anidado . Dado que una declaración de cambio define su bloque, no surgen conflictos entre las constantes de caso en el interruptor interno y las del interruptor externo.

Ejemplo:

Declaración de cambio anidado

// Java Program to Demonstrate // Nested Switch Case Statement // Class public class GFG {  // Main driver method  public static void main(String[] args)  {  // Custom input string  String Branch = 'CSE';  int year = 2;  // Switch case  switch (year) {  // Case  case 1:  System.out.println(  'elective courses : Advance english, Algebra');  // Break statement to hault execution here  // itself if case is matched  break;  // Case  case 2:  // Switch inside a switch  // Nested Switch  switch (Branch) {  // Nested case  case 'CSE':  case 'CCE':  System.out.println(  'elective courses : Machine Learning, Big Data');  break;  // Case  case 'ECE':  System.out.println(  'elective courses : Antenna Engineering');  break;  // default case  // It will execute if above cases does not  // execute  default:  // Print statement  System.out.println(  'Elective courses : Optimization');  }  }  } }>

elective courses : Machine Learning, Big Data>

Enumeración de Java en la declaración de cambio

Las enumeraciones (enums) son una manera poderosa y clara de representar un conjunto fijo de constantes con nombre en Java.

Las enumeraciones se utilizan en declaraciones Switch debido a su seguridad de tipo y legibilidad.

Ejemplo:

Uso de Enum en Switch

// Java Program to Illustrate Use of Enum // in Switch Statement // Class public class GFG {  // Enum  public enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat }  // Main driver method  public static void main(String args[])  {  // Enum  Day[] DayNow = Day.values();  // Iterating using for each loop  for (Day Now : DayNow) {  // Switch case  switch (Now) {  // Case 1  case Sun:  System.out.println('Sunday');  // break statement that hault further  // execution once case is satisfied  break;  // Case 2  case Mon:  System.out.println('Monday');  break;  // Case 3  case Tue:  System.out.println('Tuesday');  break;  // Case 4  case Wed:  System.out.println('Wednesday');  break;  // Case 5  case Thu:  System.out.println('Thursday');  break;  // Case 6  case Fri:  System.out.println('Friday');  break;  // Case 7  case Sat:  System.out.println('Saturday');  }  }  } }>

Sunday Monday Tuesday Wednesday Thursday Friday Saturday>

declaración predeterminada en Java Switch Case

El caso predeterminado en el caso Switch especifica qué código ejecutar si ningún caso coincide.

Se prefiere escribir el caso predeterminado al final de todos los casos posibles, pero se puede escribir en cualquier lugar de las declaraciones de cambio.

Ejemplo:

Escribir valor predeterminado en medio de declaraciones de cambio:

/*package whatever //do not write package name here */ import java.io.*; class GFG {  public static void main (String[] args) {  int i=2;  switch(i){  default:  System.out.println('Default');  case 1:  System.out.println(1);  break;  case 2:  System.out.println(2);  case 3:  System.out.println(3);    }  } }>

2 3>

Ejemplo:

Escritura predeterminada al inicio de declaraciones de cambio

import java.io.*; class GFG {  public static void main(String[] args)  {  int i = 5;  switch (i) {  default:  System.out.println('Default');  case 1:  System.out.println(1);  break;  case 2:  System.out.println(2);  case 3:  System.out.println(3);  }  } }>

Default 1>

Variaciones de etiquetas de casos

La etiqueta del caso y los argumentos de cambio pueden ser una expresión constante. El argumento de cambio puede ser una expresión variable.

Ejemplo:

Usando argumento de cambio de variable.

import java.io.*; class GFG {  public static void main(String[] args)  {  int x = 2;  switch (x + 1) {  case 1:  System.out.println(1);  break;  case 1 + 1:  System.out.println(2);  break;  case 2 + 1:  System.out.println(3);  break;  default:  System.out.println('Default');  }  } }>

3>

Una etiqueta de caso no puede ser una variable o una expresión de variable. Debe ser una expresión constante.

diferencia entre hielo y nieve

import java.io.*; class GFG {  public static void main(String[] args)  {  int x = 2;  int y = 1;  switch (x) {  case 1:  System.out.println(1);  break;  case 2:  System.out.println(2);  break;  case x + y:  System.out.println(3);  break;  default:  System.out.println('Default');  }  } }>

./GFG.java:16: error: constant expression required  case x+y:  ^ 1 error>

Contenedor de Java en declaraciones de cambio

Java proporciona cuatro clases contenedoras a utilizar: entero, corto, byte y largo en sentencias de cambio.

Ejemplo:

Java Wrapper en caja de interruptor.

public class WrapperSwitchExample {  public static void main(String[] args) {  Integer age = 25;  switch (age.intValue()) { // Extract primitive value for switch  case 25:  System.out.println('You are 25.');  break;  case 30:  System.out.println('You are 30.');  break;  default:  System.out.println('Age not matched.');  }  } }>

Producción:

You are 25.>

Nota:

Independientemente de su ubicación, el caso predeterminado sólo se ejecuta si no se cumple ninguna de las otras condiciones del caso. Por lo tanto, ponerlo al principio, en el medio o al final no cambia la lógica central (a menos que estés usando una técnica menos común llamada caída).

Ejemplo: En este código identificaremos el día de la semana mediante números (1-7).

import java.util.Scanner; public class Main {  public static void main(String[] args) {  Scanner scanner = new Scanner(System.in);  System.out.print('Enter a day number (1-7): ');  int day = scanner.nextInt();  switch (day) {  default:  System.out.println('Not a valid weekday.');  break;  case 1:  System.out.println('It's Monday!');  break;  case 2:  System.out.println('It's Tuesday!');  break;  case 3:  System.out.println('It's Wednesday!');  break;  case 4:  System.out.println('It's Thursday!');  break;  case 5:  System.out.println('It's Friday!');  break;  case 6:  System.out.println('It's Saturday!');  break;  case 7:  System.out.println('It's Sunday!');  break;  }  } }>

Producción

Enter a day number (1-7): 8 Not a valid weekday.>

Leer más:

• Uso de palabras clave Enum y Switch en Java
• Cadena en Switch Case en Java
• Tutorial de Java

Ejercicio

Para practicar las declaraciones de cambio de Java, puede visitar la página: Práctica de declaración de caso de cambio de Java

Conclusión

Las declaraciones de cambio en Java son estructuras de flujo de control que le permiten ejecutar cierto bloque de código en función del valor de una sola expresión. Pueden considerarse como una alternativa a las declaraciones if-else-if en programación.

Declaraciones de cambio de Java: preguntas frecuentes

Cómo utilizar declaraciones de cambio en Java

Para utilizar la declaración de cambio en Java, puede utilizar la siguiente sintaxis:

cómo inyectar una clase abstracta simulada

cambiar (expresión) {
valor de caso1:
// código a ejecutar si la expresión es igual a valor1
romper;
valor de caso2:
// código a ejecutar si la expresión es igual a valor2
romper;
// …más casos
por defecto:
// código a ejecutar si ninguno de los casos anteriores coincide
}

¿Podemos pasar nulo a un interruptor?

No, no puede pasar NULL a una declaración de cambio ya que requieren una expresión constante en su caso.

¿Puedes volver a una declaración de cambio?

No, las declaraciones de cambio crean un flujo de control en el programa, por lo que no puede regresar después de salir de un caso de cambio.