cambiar, caso, defecto

"¡Hola, amigo!"

"¡Hola, Bilaabo! Qué bueno verte de nuevo. Solo tus conferencias son tan buenas y comprensibles. No como este modelo de memoria de Java".

"Sí, Bilaabo sabe cómo elegir lecciones. Hoy les voy a hablar sobre la declaración de cambio".

"Creo que alguien ya me lo contó".

"Ellie lo hizo. Entonces, ¿Amigo no quiere escuchar una lección sobre la declaración de cambio? ¿Quizás comiences a enseñar la tuya?"

"No, quiero, quiero. Escuchemos sobre la declaración de cambio".

"Está bien. En Java, hay algo llamado declaración de cambio. Es conveniente cuando necesita realizar ciertas acciones dependiendo de varios valores de alguna variable".

int i = 5;
switch(i)
{
 case 1:
  System.out.println("one");
  break;
 case 2:
  System.out.println("two");
  break;
 case 3:
  System.out.println("three");
  break;
 default:
  System.out.println("many");
}

int i = 5;
if (i == 1)
{
 System.out.println("one");
}
else if (i == 2)
{
 System.out.println("two");
}
else if (i == 3)
{
 System.out.println("three");
}
else
{
 System.out.println("many");
}

La declaración de cambio le permite saltar a la pieza de código deseada si la variable que se le pasa coincide con el valor que sigue al caso de la palabra clave.

Si i es 1, la ejecución saltará a la línea marcada como «caso 1».

Si i es 2, entonces la ejecución saltará a la línea marcada como «caso 2».

Si i es 3, la ejecución saltará a la línea marcada como «caso 3».

"Si no se salta a ninguno de los casos, entonces se ejecuta el bloque «por defecto»."

"Ya veo. ¿Y a la derecha está la misma lógica, pero implementada usando sentencias if?"

"Sí."

"¿Y qué pasa con la palabra 'romper'? ¿Dijiste que solo se puede usar en bucles?"

"Sí, y aquí. Cuando se ejecuta la instrucción break , salimos inmediatamente del interruptor ".

"Pero si se elimina la declaración de interrupción, todas las líneas dentro del interruptor se ejecutarán hasta el final".

switch(i)
{
 case 1:
  System.out.println("one");
 case 2:
  System.out.println("two");
 case 3:
  System.out.println("three");
 default:
  System.out.println("many"); }

"En realidad, case es una etiqueta en el código. En la declaración de cambio, saltamos a la siguiente etiqueta y comenzamos a ejecutar todo el código hasta el final del cambio, o hasta que encontramos una declaración de ruptura".

"Entonces, si no escribimos break, entonces la línea a la que saltamos se ejecutará, seguida de todas las demás líneas hasta la llave de cierre. ¿Es así?"

"Sí."

"Pan comido. Pero me gusta usar mejor las declaraciones if. No tienen estas declaraciones de ruptura sin sentido".

"Es cierto que las sentencias if suelen ser más compactas. Pero una sentencia switch a veces es más legible".

"Comparar:"

public String getName(int i)
{
 switch(i)
 {
  case 1:
   return "one";
  case 2:
   return "two";
  case 3:
   return "three";
  default:
   return "many";
}

public String getName(int i)
{
 if (i == 1)
  return "one";

 if (i == 2)
  return "two";

 if (i == 3)
  return "three";

return "many"
}

"No diría que es más legible".

"Está bien, pero ¿qué pasa con este ejemplo?"

public String getName(int i)
{
 switch(i)
 {
  case 1:
  case 2:
   return "one or two";
  case 3:
  case 4:
  case 5:
   return "three to five";
  default:
   return "many";
}

public String getName(int i)
{
 if (i == 1 || i == 2)
  return "one or two";

 if (i == 3 || i == 4 || i == 5)
  return "three to five";

return "many"
}

"Bilaabo, tu ejemplo no se ve muy bien. Entonces, ¿puedo omitir la instrucción break si uso return?"

"Así es. Una declaración de devolución saldrá inmediatamente del método".

"Parece que las declaraciones if siempre son más compactas. Pero la declaración switch resultó ser más legible esta vez".

"Uf, por fin".

"Una cosa más. No tienes que escribir predeterminado al final. Si no lo haces, simplemente no pasará nada si ninguna de las etiquetas coincide".

"Uh, exactamente. Como si... si no, pero legible, ¡mucho más legible!"

"Genial. Me alegra que te haya gustado mi lección".

"Oh, casi lo olvido. Inicialmente, solo podía usar tipos primitivos y enumeraciones en declaraciones de cambio. Pero ahora han agregado soporte para cadenas".

"¿Quieres decir que yo escribo esto?"

public int getNumber(String number)
{
 switch(number)
 {
  case "one":
   return 1;
  case "two":
   return 2;
  case "three":
   return 3;
  default:
   return -1;
 }
}

"Sí. Conveniente, ¿verdad?"

"Sí. ¡Las declaraciones de cambio son geniales!"