Programación en Java / Sentencia if-else 1

Programación en Java /Sentencia if-else

Queremos realizar una división de enteros. Es fácil, ya sabemos como hacerlo, utilizando variables y operadores.
Pero nos queda un mal recuerdo con 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 cara de cero. Disponemos de dos opciones : realizar o no
la división. También una condición: el divisor sea distinto de cero. Esto se parece mucho a una selección simple.
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 booleana. La sentencia se ejecuta solamente si la expresión booleana es verdadera.
Retomando el problema de la división, incorporamos 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 cociente. La condición es una
expresión que arroja un valor booleano. En este caso se utiliza un operador relacional que verifica si y es distinto de
0. Si esta condición se cumple realiza la división. En caso contrario se saltea la división y solo imprime el valor de z,
que hemos inicializado convenientemente 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;

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;
else System.out.println("Atención! se pretende dividir por
0");
Programación en Java / Sentencia if-else 2

System.out.println("El resultado es : " + z);

}
}

El programa nos quedó mas completo. Con la cláusula else incluimos otra alternativa de acción. Pero algo anda
suelto. Este programa siempre muestra un resultado, se cumpla o no la condición. El mensaje por pantalla no está
incluido en la estructura de selección. Tendremos que colocarlo dentro del sector de sentencias que se ejecutarán
cuando la condición sea verdadera. 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

public class DivisionSegura {

public static void main(String args[]){
int x = 12;
int y = 2;
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 por
0");
}
}
}

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ógicos. Recuerden que siempre debe dar como resultado un valor booleano.
Supongamos que deseamos saber si un año es bisiesto. Sabemos que debe ser múltiplo de 4. Para esto tendremos que
verificar si el módulo es igual a cero.

año % 4 == 0

Pero no debe ser múltiplo de 100.

( año % 4 == 0 ) && ( año % 100 != 0 )

A menos que sea múltiplo de 400.

((( año % 4 == 0 ) && ( año % 100 != 0 )) || ( año % 400 == 0 ))

Programación en Java / Sentencia if-else 3

Formamos una proposición compuesta con conectores lógicos. Ahora vamos a incorporarlo en una estructura se
selección.

if ((( año % 4 == 0 ) && ( año % 100 != 0 )) || ( año % 400 ==

0 )) {
System.out.println("Es bisiesto");
} else {
System.out.println("No es bisiesto");
}

Los conectores lógicos nos permiten simplificar la estructura. Sin ellos nos veríamos en la necesidad de anidar las
sentencias. Veamos que ocurre si en elejemplo anterior descartamos el AND y el OR.

if ( x % 4 == 0 ) {
if ( x % 100 == 0 ) {
if ( x % 400 == 0 ) {
System.out.println("Es bisiesto");
} else {
System.out.println("No es bisiesto");
}
} else {
System.out.println("Es bisiesto");
}
} else {
System.out.println("No es bisiesto");
}

Parece complicado, pero nos demuestra muchas cosas. En primer lugar observamos que se pueden anidar las
sentencias if-else. Cada resultado de una condición puede caer en una nueva comprobación para formar una
estructura compleja de selección.
También vemos que hay cierta 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;
}
}
Programación en Java / Sentencia if-else 4

Negación

if ( ! condición1) { if ( condición1) {
sentencia1; sentencia2;
} else { } else {
sentencia2; sentencia1;
} }
Fuentes y contribuyentes del artículo 5

Fuentes y contribuyentes del artículo

Programación en Java / Sentencia if- else  Fuente: http://es.wikibooks.org/w/index.php?oldid=130513  Contribuyentes: Dferg, Pirenne, 1 ediciones anónimas

Licencia
Creative Commons Attribution-Share Alike 3.0 Unported
http:/ / creativecommons. org/ licenses/ by-sa/ 3. 0/