Curso de Java. Condicional switch.
El condicional swich es una sentencia que nos permite al igual que la sentencia if else, tratar esos casos donde se deban evaluar varias condiciones, pero a diferencia de if else la síntexis empleada es bastante menos laboriosa.
La única pega es que el resultado de la condición o expresión evaluada debe ser un entero. (A partir de Java 7, se permiten resultados tipo String.) La síntexis empleada es la siguiente:
switch ( ExprPrincpl. ) {
case Expr1:
Sentencias;
case Expr2:
Sentencias;
case Expr3:
Sentencias;
case Expr4:
Sentencias;
case Expr5:
Sentencias;
default :
Sentencias;
}
veamos un ejemplo para ver su funcionamiento:
Tenemos dos variables declaradas e inicializadas:
int a = 10;
int b = 14;
Aplicamos la instrucción switch ():
switch ( b – a ) {
case 1:
System.out.println
(«El resultado está en el ‘primer case’.»);
case 2:
System.out.println
(«El resultado está en el ‘segundo case’.»);
case 4:
System.out.println
(«El resultado está en el ‘tercer case’.»);
}
Este ejemplo es muy sencillo de entender, veamos, tenemos declaradas dos variables tipo int a las que hemos asignado unos valores. Luego hemos utilizado como expresión la diferencia de «b» menos «a», que dará un valor determinado, en concreto da como resultado «4», aunque bien podiamos no saberlo y dejar a la instrucción que buscase entre los «case» haber si coincide alguno (Esta es otra forma de utilizarlo.). Por otro lado hemos incluido en cada case una simple sentencia, que permite ver por consola una cadena de texto.
Trás la ejecución del programa, el único case que coincide con el resultado «4» es el tercer case case 4:,
por tanto se ejecutaría el código que este tenga en su bloque, que sería:
System.out.
println («El resultado está en el ‘tercer case’.»);
Ahora bién, que ocurriría si tras el último case tubiesemos otro case, por ejemplo así:
Tenemos dos variables declaradas e inicializadas:
int a = 10;
int b = 14;
Aplicamos la instrucción switch ():
switch ( b – a ) {
case 1:
System.out.println («El resultado está en el ‘primer case’.»);
case 2:
System.out.println («El resultado está en el ‘segundo case’.»);
case 4:
System.out.println («El resultado está en el ‘tercer case’.»);
case 5:
System.out.println («El resultado está en el ‘cuarto case’.»);
}
el resultado sería que se ejecutarían la sentencia del tercer case cas 4: y la del case o cases que le siguiesen, en este caso case 5:
System.out.println («El resultado está en el ‘tercer case’.»);
System.out.println («El resultado está en el ‘cuarto case’.»);
Esto que en principio podemos considerar como un error, no lo es tanto, ya que dependiendo del resultado en consola buscado, nos puede interesar que a partir de cierto case, se ejecuten las sentencias de todos los case que le sigan. En cualquier caso podemos evitar que esto ocurra, es decir, que solo se ejecute el case que realmente coincida con el resultado de la primera expresión o condición del switch, añadiendo la instrucción break; al final de la última instrucción del bloque de cada case, de esta manera:
Tenemos dos variables declaradas e inicializadas:
int a = 10;
int b = 14;
Aplicamos la instrucción switch ():
switch ( b – a ) {
case 1:
System.out.println («El resultado está en el ‘primer case’.»);
break;
case 2:
System.out.println («El resultado está en el ‘segundo case’.»);
break;
case 4:
System.out.println («El resultado está en el ‘tercer case’.»);
break;
case 5:
System.out.println («El resultado está en el ‘cuarto case’.»);
}
De esta manera nos asegurariamos de que solo se ejecute las sentencias del case que realmente coincide con el resultado de la condició del switch. En el último case no es necesario poner un break.
Si os fijais dentro de esa cadena hay marcado con comillas simples (‘) las cadenas ‘primer case’,’segundo case’…Esto lo he planteado
con la intención de que veamos como debemos incluir el texto dentro o junto a otra cadena de texto, para que el compilador de java no muestre error de compilación.
Hay varias formas posibles de incluir un texto entrecomillado dentro de otro texto son:
- System.out.println («El resultado está en el ‘primer case’.»); // Con comillas simples.
- System.out.println («El resultado está en el» + » ‘primer case’. » «);// Utilizando el operador de concatenación + y envolviendo las comillas simples en otras dobles, lo cual no tiene sentido práctico alguno, pero nos ha servido para conocer otra forma de utilizar el operador +, para concatenar cadenas de texto.
Si lo que se desea es presentar texto entre comillas dobles (» …….») y que estas aparezcan en consola, también hay varias formas:
Declaramos tres variables una de tipo char:
int a = 10;
int b = 14;
char c = ‘ » ‘; // Incluimos el caracter que queremos presentar, entre comillas simples.
Aplicamos la instrucción switch ():
switch ( b – a ) {
case 1:
System.out.println («El resultado está en el»+c+‘primer case’+c+«.»);
case 2:
System.out.println («El resultado está en el»+c+‘segundo case’+c+«.»);
case 4:
System.out.println («El resultado está en el»+c+‘tercer case’+c+«.»);
}
Otra forma de hacerlo sería así:
Declaramos tres variables todas de tipo int:
int a = 10;
int b = 14;
int c = 34; // 34 es el valor decimal del caracter («).
Aplicamos la instrucción switch ():
switch ( b – a ) {
case 1:
System.out.println («El resultado está en el»+(char)c+«primer case»+ (char)c+«.»);
case 2:
System.out.println («El resultado está en el»+(char)c+«segundo case»+ (char)c+«.»);
case 4:
System.out.println («El resultado está en el»+ (char)c+«tercer case»+(char)c+«.»);
// Aplicando un «(cash)» a la variable tipo int «c» para convertirla en tipo «char».
}
Esto es solo un pequeño aperitivo del trabajo con cadenas, que he querido incluir aquí, para que os vayais familiarizando con ellas.