Estructuras de

selección en Java
“If-Else”

Escritura de condiciones en los algoritmos de java.

21/01/2010
A menudo nos encontremos con programas o algoritmos en donde las acciones se
ejecutarán de acuerdo a una condición. Tenemos dos o más alternativas de acción y solo
una de estas tendrá lugar.

Por ejemplo, supongamos que estamos conduciendo un vehículo y en un cruce de calles nos
encontramos con un semáforo. Si la luz del semáforo es roja nos detenemos. De otro modo
seguiremos manteniendo la velocidad. Aquí se nos presentan dos alternativas: continuar
con la marcha o frenar. Estas acciones se realizarán según una condición: si la luz del
semáforo es roja. Podemos especificar este ejemplo mediante un pseudolenguaje que
describa la condición.

Si luz_del_semáforo = rojo

Entonces

velocidad_del_vehículo = 0
Estamos frente a una selección simple: tenemos dos alternativas. Este tipo de selección la
condición toma un valor lógico de verdadero o falso. Se tienen que especificar las acciones
que deben ocurrir si la condición es verdadera. Opcionalmente se puede indicar que debe
ocurrir si la condición es falsa. Para lo último veamos un ejemplo.

Si luz = rojo

Entonces

Frenar

De otro modo

Seguir con la misma velocidad.

 Sentencia if-else

Queremos realizar una división de enteros. Es fácil, ya sabemos cómo hacerlo, utilizando
variables y operadores. Pero queda un problema, la división por cero. Podemos establecer
una condición que permita la división para todos los números y que rechace cualquier
divisor con cero en el divisor. Disponemos de dos opciones: realizar o no la división.
También se puede realizar otra condición que el divisor sea distinto de cero.

La estructura de selección simple en Java se realiza mediante la sentencia if (si, en ingles).

La sintaxis es la siguiente:

if (condición) sentencia;

La condición es una expresión booleana1. La sentencia se ejecuta solamente si la expresión

booleana es verdadera.

Retomando el problema de la división, se puede incorporar una estructura de selección para

realizar la operación libre de ceros.

public class DivisionSegura {

public static void main(String args[]){
int x = 12;
int y = 0;
int z = 0;
if(y != 0){
z = x / y;
System.out.println("El resultado es: " + z);}
}
}

En el programa, la variable x tiene el valor del dividendo, la y el divisor y la z el resultado.

La condición es una expresión que arroja un valor booleano. En este caso se utiliza un
operador de relación que verifica si y es distinto de 0. Si esta condición se cumple realiza la
división. En caso contrario se salta la división y solo imprime el valor de z, que hemos
inicializado convenientemente con un valor de 0 antes de la operación.

¿Qué ocurre si la condición no se cumple? En este caso nada. Podemos agregar una serie de
instrucciones que se ejecutarán solo si la condición no se cumple. Para esto tendremos que
agregar la sentencia else. La estructura de selección quedará así:

if (condición){ sentencia 1;}

else{ sentencia 2;}

1
Una expresión booleana es una sucesión de símbolos que incluye 0,1, algunas variables x, y, z y
las operaciones booleanas (and, or, etc.)
Si la condición es verdadera se ejecuta la sentencia 1 en caso contrario se ejecuta la
sentencia 2. Ambas sentencias nunca se ejecutarán al mismo tiempo, son excluyentes.

Ahora ampliemos el programa para mostrar una advertencia en el caso que se encuentre
cara a cara con un cero siniestro.

public class DivisionSegura {

public static void main(String args[]){
int x = 12;
int y = 0;
int z = 0;
if( y != 0 ){
z = x / y;
System.out.println("El resultado es: " + z);}
else{
System.out.println("Atención! se pretende
dividir y por 0");}
}
}

El programa quedó más completo. Con la cláusula else incluimos otra alternativa de acción.
Para agrupar las sentencias se utilizan las llaves { } Indicarán el inicio y el fin de un bloque
de sentencias.

Probemos como queda con un bloque

Las buenas prácticas en defensa de un código mantenible han dictaminado que utilicemos
las llaves en todo momento, aún en el caso que utilicemos una sola sentencia.

if(condición) {
Sentencia;
}
else {
Sentencia;
}

Lamentablemente no siempre nos encontraremos con condiciones tan sencillas. Muchas

veces tendremos que recurrir a proposiciones compuestas para formar una condición. Para
ello podemos recurrir a operadores relacionales o lógicos2. Recuerden que siempre debe
dar como resultado un valor booleano.

2
Los operadores relacionales, también denominados operadores binarios lógicos y de comparación, se
utilizan para comprobar la veracidad o falsedad de determinadas propuestas de relación (en realidad se
trata respuestas a preguntas).
 OPERADORES LÓGICOS
OPERADOR Símbolo
Menor que
<
Mayor que
>
Menor o igual que
<=
Mayor o igual que
>=
Igual que (identidad)
==
Desigual que (desigualdad)
!=
La forma en que se escriben las condiciones es:

Expresión de relación < Expresión

Expresión de relación > Expresión
Expresión de relación <= Expresión
Expresión de relación >= Expresión
Expresión de relación == Expresión
Expresión de relación != Expresión

CONDICIONES DOBLES

Relación entre conectores lógicos y la estructura.

Conjunción
if (condición1 && condición2){ if ( condición1 ) {
sentecia1; if ( condición2 ) {
} else { sentencia1;
sentencia2; } else {
} sentencia2;
}
} else {
sentencia2;
}
 Disyunción
if ( condición1 || condición2 ) { if ( condición1 ){
sentencia1; sentencia1;
} else { } else {
sentencia2; if ( condición2 ) {
} sentencia1;
} else {
sentencia2;
}
}

Negación
if ( ! condición1) { if ( condición1) {
sentencia1; sentencia2;
} else { } else {
sentencia2;
}