Expresiones Condicionales
Para escribir programas útiles, casi siempre necesitamos comprobar condiciones y cambiar el comportamiento del programa en consecuencia. Las declaraciones condicionales nos dan esta capacidad.
Expresión Condicional If-Else
La forma más simple es la declaración if-else:
Ejemplo:
Escribe el siguiente código en el archivo /home/labex/project/ifelseTest.java:
public class ifelseTest{
public static void main(String[] args){
int x = 1;
if (x > 0) {
System.out.println("x is positive");
}
else{
System.out.println("x is non-positive");
}
}
}
Salida:
Ejecuta el archivo ifelseTest.java utilizando los siguientes comandos en la terminal:
javac /home/labex/project/ifelseTest.java
java ifelseTest
Ver la salida:
x is positive
La expresión entre paréntesis se llama condición. Si es verdadera, entonces las declaraciones entre llaves después de if se ejecutan. Si la condición no es verdadera, se ejecutan las declaraciones entre llaves después de else. Si no hay un else pendiente y la condición if es falsa, se ejecutan las declaraciones, si las hay, después del if-else. La condición puede contener cualquiera de los operadores de comparación, también llamados operadores relacionales:
Ejemplo:
if (x == y){ } // x equals y
if (x!= y){ } // x is not equal to y
if (x > y) { } // x is greater than y
if (x < y) { } // x is less than y
if (x >= y){ } // x is greater than or equal to y
if (x <= y){ } // x is less than or equal to y
Aunque estas operaciones probablemente te resulten familiares, la sintaxis que utiliza Java es un poco diferente de los símbolos matemáticos como =, ≠ y ≤. Un error común es usar un solo signo igual (=) en lugar de dos signos iguales (==). Recuerda que = es el operador de asignación y == es un operador de comparación. Además, no existe algo como =< o =>.
Los dos lados de un operador condicional deben ser del mismo tipo. Solo puedes comparar enteros con enteros y números de punto flotante con números de punto flotante. Los operadores == y != funcionan con String, pero no hacen lo que esperas. Y, los otros operadores relacionales no operan en cadenas en absoluto.
Un ejemplo: Si el resto cuando x se divide por 2 es 0, entonces sabemos que x es par y este código imprime un mensaje al respecto. Si la condición es falsa, se ejecuta la segunda declaración de impresión. Dado que la condición debe ser verdadera o falsa, exactamente una de las alternativas se ejecutará. Si crees que quieres comprobar la paridad (paridad o imparidad) de los números con frecuencia, es posible que desees "envolver" este código en un método, como se muestra a continuación:
Ejemplo:
Escribe el siguiente código en el archivo /home/labex/project/conditionTest.java:
public class conditionTest
{
public static void printParity(int x) {
if (x%2 == 0) {
System.out.println(x + " is even");
} else {
System.out.println(x + " is odd");
}
}
public static void main(String[] args){
printParity(17);
printParity(18);
}
}
Salida:
Ejecuta el archivo conditionTest.java utilizando los siguientes comandos en la terminal:
javac /home/labex/project/conditionTest.java
java conditionTest
Ver la salida:
17 is odd
18 is even
Ahora tienes un método llamado printParity que imprimirá un mensaje adecuado para cualquier entero que desees proporcionar. En main, invocarías este método. Siempre recuerda que, cuando invocas un método, no tienes que declarar los tipos de los argumentos que proporcionas. Java puede averiguar de qué tipos son. Debes resistir la tentación de escribir cosas como: printParity(int 3). Además, también puedes anidar una condición dentro de otra.
Ejemplo:
Escribe el siguiente código en el archivo /home/labex/project/nestedConditionTest.java:
public class nestedConditionTest{
public static void main(String[] args){
int x = 0; // you can try x = 1, x = -1
if (x == 0) {
System.out.println("x is zero");
}
else {
if (x > 0) {
System.out.println("x is positive");
}
else {
System.out.println("x is negative");
}
}
}
}
Salida:
Ejecuta el archivo nestedConditionTest.java utilizando los siguientes comandos en la terminal:
javac /home/labex/project/nestedConditionTest.java
java nestedConditionTest
Ver la salida:
x is zero
Ahora hay una condición externa que contiene dos ramas. La primera rama contiene una simple declaración de impresión, pero la segunda rama contiene otra declaración condicional que tiene dos ramas propias. Ambas ramas son declaraciones de impresión, pero también podrían haber sido declaraciones condicionales.
La indentación ayuda a que la estructura sea bonita y comprensible, pero sin embargo, las condiciones anidadas se vuelven difíciles de leer muy rápidamente. Evítalas cuando puedas. Por otro lado, este tipo de estructura anidada es común y la veremos nuevamente. Así que es mejor que te acostumbres a ella.
Expresión Condicional Switch-Case
La declaración switch-case es otra expresión condicional. La sintaxis de la declaración switch-case es la siguiente:
Ejemplo:
// value type can be byte, short, int, char, String, but long type is not correct.
switch (variable or an value expression)
{
// case value must be a constant value
case value1:
// code
;
case value2:
// code
;
default:
// code
;
}
Ejemplo:
Escribe el siguiente código en el archivo /home/labex/project/switchTest.java:
public class switchTest
{
public static void main(String[] args){
// you can change i = 2, then try again
int i = 2;
switch(i)
{
case 1:
System.out.println(1);
break;
case 2:
System.out.println(2);
// if no break expression, sometimes you'll get a confusing answer.
// you can try deleting the break expression and see what happens.
break;
// if none of the above matches, execute the default statements
default:
System.out.println("default");
break;
}
}
}
Salida:
Ejecuta el archivo switchTest.java utilizando los siguientes comandos en la terminal:
javac /home/labex/project/switchTest.java
java switchTest
Ver la salida:
2
