Las estructuras condicionales en java permiten modificar el flujo de ejecución de un programa. Ya sabemos que, cuando un programa empieza a ejecutarse, lo hace de izquierda a derecha y de arriba hacia abajo.
Gracias a estas estructuras podemos modificar el flujo de ejecución de un programa.
La cláusula «if«, podemos traducirla por un sí condicional. Además, ya habíamos hablado en este artículo que las estructuras condicionales, siempre van encerradas entre una llave de apertura y otra de cierre.
Partes de las estructuras condicionales en java.
La cláusula «if«, siempre irá acompañada de un paréntesis de apertura y uno de cierre, entre los cuales irá incluida una condición. Una vez colocada la condición entre esos paréntesis, incluiremos las correspondientes llaves que delimitan la estructura. Veamos varios ejemplos de como construir estructuras condicionales en java.
Estructuras condicionales con un sólo if.
package arranque;
public class Principal {
public static void main(String[] args) {
// Creamos una estructura if
if(condicion) {
// sentencia 1;
// sentencia 2;
// sentencia 3;
// ....
// ....
// ....
// ....
// ....
//sentencia n;
}
// sentencia x;
// sentencia y;
// sentencia z;
}
}
En este ejemplo, vemos como se construye esta estructura. Pero, ¿cómo se interpreta?
En este caso el programa empezará a ejecutarse. El programa se encuentra con una estructura condicional por lo que evaluará la condición que se encuentra entre paréntesis. Con esta condición puede ocurrir dos cosas:
- Que sea verdad, es decir, verdadera (true).
- Que sea mentira, es decir, falsa (false).
Si la condición es verdad (true), el programa ejecutará las sentencias 1, 2, 3… hasta las sentencia n, ya que estas sentencias se encuentran dentro de la estructura if. A continuación, ejecutará las sentencias x, y, z, que se encuentran fuera de esta estructura.
En caso de que la condición no se cumpla, es decir, sea falsa (false), el programa no ejecutará ninguna de las sentencias que se encuentren dentro de la estructura condicional, de forma que sólo ejecutando las sentencias x, y, z.
La cláusula else dentro de un condicional.
Las estructuras condicionales en java, pueden incluir de manera opcional, la palabra reservada «else«. Esta palabra reservada podemos traducirla por «en caso contrario…«.
Cuando utilizamos esta palabra reservada, estamos construyendo otro bloque que también irá entre llaves, pero que realmente forma parte de la estructura condicional. Veamos un ejemplo combinando un if con un else.
package arranque;
public class Principal {
public static void main(String[] args) {
// Creamos una estructura if con else
if(condicion) {
// sentencia 1;
}
else {
// sentencia 2;
}
// sentencia 3;
}
}
Como podemos ver en este otro ejemplo, construimos un if… else. Esto quiere decir que cuando el programa comienza, evaluará una condición.
- Si la condición es verdadera o true, ejecutará las instrucciones 1 que es la que forma parte del bloque if, y luego la sentencia 3 que es la que se encuentra fuera de la estructura condicional.
- En caso contrario, es decir «else», es decir, si la condición no se cumple o es falsa, el programa ejecutará las sentencias 2 y 3. Por lo tanto ejecutará la sentencia 2 porque está dentro del bloque «else», y después la sentencia que continúa por debajo de la estructura condicional, la sentencia 3.
Condicionales y estructuras if anidadas en java.
Para finalizar con la palabra reservada if y la cláusula else, referente a los condicionales en java, podemos crear estructuras para evaluar varias condiciones. De esta forma, evaluaremos una condición, si esta primera condición, no se cumple, se evaluará otra condición, si además, esta segunda condición no se cumple, podemos evaluar otra tercera condición, y así sucesivamente.
Esto lo haremos combinando varios bloque if con la palabra reservada else y un if. Veamos un ejemplo de como se construye esta estructura.
package arranque;
public class Principal {
public static void main(String[] args) {
// Creamos una estructura if anidada
if(condicion1) {
// sentencia 1;
}
else if(condicion2) {
// sentencia 2;
}
else if(condicion3) {
// sentencia 3;
}
else {
// sentencia 4;
}
// sentencia 5;
}
}
Si nos fijamos en el ejemplo anterior, ocurre igual que en los dos anteriores. El programa java, comienza la ejecución y evaluará una condición.
- Si la condición uno se cumple, ejecutará la sentencia 1 y después saltará al final de la estructura, ejecutando a continuación la sentencia 5.
- En caso de que la condicion uno, no se cumpla, saltará al siguiente bloque y evaluará la condición dos. Si esa se cumple ejecutará la sentencia 2.
- Por el contrario, si la condicion dos, no se cumpla, saltará al siguiente bloque y evaluará la condición tres. Si esa se cumple ejecutará la sentencia 3.
- Para finalizar, si no se cumple ninguna de las tres condiciones, el programa entrará en el bloque del «else«, de forma que ejecutará la sentencia 4.
Se debe tener en cuenta que una vez que se ejecute alguna de las sentencias, el programa saltará al final de la estructura condicional anidada y siempre ejecutará lo que haya a continuación de esta estructura. Por tanto, ejecutará siempre la sentencia 5.
Sin embargo, esta ultima opción para crear condicionales, no suele ser muy utilizada, ya que podemos optar con otro tipo de estructura que nos permite dejar nuestro código java más limpio.
La estructura switch en java.
Esta estructura se utiliza se utiliza cuando queremos evaluar varias diferentes valores que puede tomar una variable.
La estructura switch, podemos traducirla como «seleccionar un caso u otro«.
Para utilizar esta estructura, usaremos, la palabra reservada switch, la palabra reservada «break» y la palabra reservada «default«.
Vamos a ver un ejemplo de como se construye esta estructura.
package arranque;
public class Principal {
public static void main(String[] args) {
// Creamos una estructura switch
switch (valorDeLaVariable) {
case 1:
// sentencia 1;
break;
case 2:
// sentencia 2;
break;
case 3:
// sentencia 3;
break;
default:
//sentencia 4;
break;
}
// sentencia 5;
}
}
En este caso, el programa empezará a ejecutarse y entrará dentro de la estructura switch una vez que una variable tome un valor determinado.
Si la variable toma el valor 1, se ejecutará las sentencias que haya programadas en este bloque del caso 1. Una vez ejecutadas, el programa se encontrará con la palabra reservada «break«. Esta cláusula break, lo que hará será que el flujo de ejecución del programa salga de la estructura switch, ejecutando a continuación todo lo que haya después de esta estructura.
En caso de que la variable tome el valor 2 o el valor 3, actuará de la misma forma que en el caso anterior. Sin embargo, si el valor de la variable no es ni 1, ni 2, ni 3, ejecutará las sentencias programadas dentro del default.
Hay que tener en cuenta que para realizar este tipo de estructuras, generalmente el usuario le da un valor a la variable que se introduce por teclado. Por este motivo, es importante saber como se introducen datos por teclado y se debe saber utilizar por un lado la clase Scanner, y si fuese necesario por otro lado, como limpiar el buffer de datos.
Puedes ver algunos ejemplos prácticos en este artículo y más información sobre las clases de java en la API correspondiente.