IF EN JAVA

La estructura condicional más simple en Java es el if, se evalúa una condición y en caso de que se
cumpla se ejecuta el contenido entre las llaves {} o en caso de que se omitan se ejecuta el código
hasta el primer «;» por lo tanto si no se usan los {} la condición aplica solo a la siguiente
instrucción al if.

if (condicion) {

ejecutar();

// Los {} son opcionales

if (condicion)

ejecutar();

// Y mas compacto

Sentencias Control en Java

Un programa en Java se ejecuta en orden desde la primera sentencia hasta la última.

Si bien existen las sentencias de control de flujo las cuales permiten alterar el fujo de
ejecución para tomar decisiones o repetir sentencias.
Dentro de las sentencias de control de flujo tenemos las siguientes:

• Sentencias de decisión
• Sentencias de bucle
• Sentencias de ramificación

Sentencias de Decisión
Son sentencias que nos permiten tomar una decisión para poder ejecutar un bloque de
sentencias u otro.
Las sentencias de decisión son: if-then-else y switch.
Mediante if-then-else podremos evaluar una decisión y elegir por un bloque u otro.

if (expresion) {
// Bloque then
} else {
// Bloque else
}

Mientras que con switch podremos evaluar múltiples decisiones y ejecutar un bloque
asociado a cada una de ellas.

switch (expresion) {
case valor1:
bloque1;
break;
case valor2:
bloque2;
break;
case valor3:
bloque3;
break;
…
 default:
bloque_por_defecto;
}

Sentencias de Bucle
Las sentencias de bucle nos van a permitir ejecutar un bloque de sentencias tantas
veces como queramos, o tantas veces como se cumpla una condición.
En el momento que se cumpla esta condición será cuando salgamos del bucle.
Las sentencias de bucle en Java son: while, do-while y for.
En el caso de la sentencia while tenemos un bucle que se ejecuta mientas se cumple la
condición, pero puede que no se llegue a ejecutar nunca, si no se cumple la condición la
primera vez.

while (expresion) {
bloque_sentencias;
}

Por otro lado, si utilizamos do-while, lo que vamos a conseguir es que el bloque de
sentencias se ejecute, al menos, una vez.

do {
bloque_sentencias;
} while (expresion)

La sentencia for nos permite escribir toda la estructura del bucle de una forma más
acotada. Si bien, su cometido es el mismo.

for (sentencias_inicio;expresion;incremento) {
bloque_sentencias;
}

Sentencias de ramificación
Las sentencias de ramificación son aquellas que nos permiten romper con la ejecución
lineal de un programa.
El programa se va ejecutando de forma lineal, sentencia a sentencia. Si queremos
romper esta linealidad tenemos las sentencias de ramificación.
Las sentencias de ramificación en Java son: break y continue.
En el caso de break nos sirve para salir de bloque de sentencias, mientras
que continue sirve para ir directamente al siguiente bloque.

Sentencias Decisión en Java

Las sentencias de decisión son sentencias que nos permiten tomar una decisión para
poder ejecutar un bloque de sentencias u otro.
Las sentencias de decisión son: if-then-else y switch.

if-then-else
La estructura de las sentencias if-then-else es:

if (expresion) {
// Bloque then
} else {
 // Bloque else
}

Se evalua la expresión indicada en la sentencia if. En el caso de que la expresión

sea true se ejecutará el bloque de sentencias then y en el caso de que la expresión
sea false se ejecutará el bloque de sentencias else.
La parte del else no tiene por qué existir. En este caso tendríamos una sentencia if-
then.

if (expresion) {
// Bloque then
}

De esta forma podríamos tener el siguiente código fuente:

int valor = 4;

if (valor < 10) {

System.out.println("El número es menor de 10");
} else {
System.out.println("El número es mayor de 10");
}

Las sentencias if-then-else pueden estar anidadas y así nos encontraríamos con una
sentencia if-then-elseif, la cual tendría la siguiente estructura:

if (expresion) {
// Bloque then
} else if {
// Bloque else
} else if {
// Bloque else
} else if {
// Bloque else
} ...
De esta forma podemos tener el siguiente código:

int valor = 14;

if (valor < 10) {

System.out.println("El valor es una unidad");
} else if (valor < 100) {
System.out.println("El valor es una decena");
} else if (valor < 1000) {
System.out.println("El valor es una centena");
} else if (valor < 10000) {
System.out.println("El valor es un millar");
} else {
System.out.println("Es un número grande");
}

switch
Para los casos en los que se tienen muchas ramas o caminos de ejecución en una
sentencia if tenemos la sentencia switch. La sentencia switch evalúa una expresión
y ejecutará el bloque de sentencias que coincida con el valor de la expresión.
El valor de la expresión tiene que ser numérico. Aunque a partir de Java SE 7 ya se
pueden utilizar expresiones cuya evaluación sean cadenas.
La estructura de la sentencia switch es:

switch (expresion) {
case valor1:
bloque1;
break;
case valor2:
bloque2;
break;
case valor3:
 bloque3;
break;
...
default:
bloque_por_defecto;
}

Es importante ver que se utiliza la sentencia break. La sentencia break hace que se
salga de la sentencia switch y por lo tanto no se evalúe el resto de sentencias. Por lo
tanto su uso es obligatorio al final de cada uno de los bloques.
Un ejemplo claro en el que podemos utilizar la sentencia switch es para evaluar el
valor de un mes en numérico y convertirlo a cadena. Este código quedaría de la
siguiente forma:

int iMes = 3;
String sMes;

switch (iMes) {
case 1:
sMes = "Enero";
break;
case 2:
sMes = "Febrero";
break;
case 3:
sMes = "Marzo";
break;
case 4:
sMes = "Abril";
break;
case 5:
sMes = "Mayo";
 break;
case 6:
sMes = "Junio";
break;
case 7:
sMes = "Julio";
break;
case 8:
sMes = "Agosto";
break;
case 9:
sMes = "Septiembre";
break;
case 10:
sMes = "Octubre";
break;
case 11:
sMes = "Noviembre";
break;
case 12:
sMes = "Diciembre";
break;
default:
sMes = "Mes incorrecto";
}

System.out.println(sMes);

Este mismo modelo lo podríamos haber implementado mediante una estructura if-
then-else. Si bien, como podemos ver en el código queda más complejo

if (iMes == 1){
 sMes = "Enero";
} else if (iMes == 2) {
sMes = "Febrero";
} else if (iMes == 3) {
sMes = "Marzo";
} else if (iMes == 4) {
sMes = "Abril";
} else if (iMes == 5) {
sMes = "Mayo";
} else if (iMes == 6) {
sMes = "Junio";
} else if (iMes == 7) {
sMes = "Julio";
} else if (iMes == 8) {
sMes = "Agosto";
} else if (iMes == 9) {
sMes = "Septiembre";
} else if (iMes == 10) {
sMes = "Octubre";
} else if (iMes == 11) {
sMes = "Noviembre";
} else if (iMes == 12) {
sMes = "Diciembre";
} else {
sMes = "Mes incorrecto";
}

System.out.println(sMes);

Otra cosa que tenemos que saber de la sentencia switch es que las evaluaciones case
pueden ser múltiples. La estructura en este caso sería:
switch (expresion) {
case valor1: case valor2: case valor3:
bloque1;
break;
case valor4: case valor5: case valor6:
bloque2;
break;
...
default:
bloque_por_defecto;
}

Esto podemos utilizarlo para saber los días del mes. El código sería el siguiente:

int iMes = 3;
String sDias;

switch (iMes) {
case 1: case 3: case 5: case 7: case 8: case 10: case 12:
sDias = "El mes tiene 31 días";
break;
case 4: case 6: case 9: case 11:
sDias = "El mes tiene 30 días";
break;
case 2:
sDias = "El mes tiene 28 días (o 29 días si es año bisiest
o)";
break;
default:
sDias = "Mes incorrecto";
}
Como vemos tenemos diferentes evaluaciones con la sentencia case.

Sentencias Bucle en Java

Las sentencias de bucle nos van a permitir ejecutar un bloque de sentencias tantas
veces como queramos, o tantas veces como se cumpla una condición.
Las sentencias de bucle en [Java][ManualJava] son: while, do-while y for.

while
La estructura repetitiva while realiza una primera evaluación antes de ejecutar el
bloque. Si la expresión es true pasa a ejecutar de forma repetida el bloque de
sentencias.
Cada vez que termina de ejecutar el bloque de sentencias vuelve a evaluar la expresión.
Si la expresión sigue siendo true vuelve a ejecutar el bloque. En el caso de que la
expresión sea false se saldrá del bucle.
Es por ello que dentro del bloque de sentencias deberán de existir sentencias que
modifiquen la evaluación de la expresión, ya que de no hacerse se podría entrar en un
bucle infinito.
La estructura de la sentencia while es la siguiente:

while (expresion) {
bloque_sentencias;
}

Los casos de uso de una sentencia repetitiva while son variados, pero principalmente
se utiliza para recorrer estructuras de datos o tener contadores.
Por ejemplo podemos realizar un contador de 1 a 10 de la siguiente forma:

int contador = 1;
while (contador <= 10) {
System.out.println(contador);
contador++;
}

do-while
En el caso de la estructura repetitiva do-while el funcionamiento es el mismo que el
de while. Pero con una diferencia, primero se ejecuta el bloque de sentencias y luego
se evalua la expresión. Por lo tanto siempre se ejecutará, al menos una vez, el bloque de
sentencias.
La estructura de la sentencia do-while es:

do {
bloque_sentencias;
} while (expresion)

Al igual que anteriormente, en el bloque de sentencias deberemos de modificar alguna

de las condiciones de la expresión para poder salir del bucle.
Un ejemplo claro del bucle do-while sería el ejemplo en el que le pedimos al usuario
que introduzca números por teclado, los cuales mostraremos en forma de eco por
pantalla, hasta que introduzca el cero. En ese caso saldremos del bucle.
Utilizaremos la estructura do-while en vez de la while ya que al menos vamos a
pedirle al usuario un número.
El código sería el siguiente:
Scanner reader = new Scanner(System.in);
int iNumero;

do {
System.out.println("Introduce carácter por consola");
iNumero = reader.nextInt();
System.out.println(iNumero);
} while (iNumero <> 0);

En el caso de haberlo realizado con un bucle while tendríamos que repetir la captura y
salida de datos. Veamos como quedaría para que puedas ver las diferencias.

Scanner reader = new Scanner(System.in);

int iNumero;

System.out.println("Introduce carácter por consola");

iNumero = reader.nextInt();
System.out.println(iNumero);

while (iNumero <> 0) {

System.out.println("Introduce carácter por consola");
iNumero = reader.nextInt();
System.out.println(iNumero);
}

for
Otra de las sentencias repetitivas que tenemos, a parte de los bucles while y do-
while, es la sentencia for.
La sentencia for tiene la característica de que tiene bien definido el inicio del bloque, la
evaluación de la expresión, el incremento de valor y el bloque de sentencias.
La estructura del bucle for es:

for (sentencias_inicio;expresion;incremento) {
 bloque_sentencias;
}

Tanto las sentencias_inicio, expresión como incremento son opcionales y pueden estar
o no. Aunque normalmente aparecerán en la estructura.
Esta estructura la podríamos reproducir mediante una sentencia while de la siguiente
forma:

sentencias_inicio;
while (expresion) {
bloque_sentencias;
incremento;
}

Las funcionalidades en las que utilizaremos la sentencia for serán las mismas que las
sentencias while y do-while, que serán contadores, recorrer estructuras,…
Si queremos definir un contador de 1 a 10 mediante una sentencia for utilizaremos el
siguiente código:

for (int x=1;x<=10;x++=) {

System.out.println("Valor del contador: " + x);
}

En pantalla obtendremos el siguiente resultado:

Valor del contador: 1

Valor del contador: 2
Valor del contador: 3
Valor del contador: 4
Valor del contador: 5
Valor del contador: 6
Valor del contador: 7
Valor del contador: 8
Valor del contador: 9
Valor del contador: 10</pre>
[ManualJava]: http://www.manualweb.net/tutorial-java/