En esta nueva entrega de los tutoriales de Java dirigidos a Android, veremos las estructuras de control. Estas son las que permiten modificar el flujo de instrucciones de un programa. Esto nos sirve, por ejemplo, cuando necesitamos ejecutar un comando un número de veces. En vez de escribir repetidamente la misma linea, usaremos una estructura de control (en este caso el for, lo veremos más adelante) y así también optimizar el programa. Para saber más de ellas continua leyendo.

Las estructuras de control, como mencionamos arriba, nos permiten cambiar el orden de las declaraciones en nuestros programas. Hay dos tipos de estructuras de control:

1. Estructuras de selección; Nos permite ejecutar una sección específica a partir de una condición.
2. Estructuras de iteración; Nos permite ejecutar código una determinada cantidad de veces (un ejemplo sería el for, como mencioné en la cabecera).

Estructuras de selección

Son declaraciones que nos permiten seleccionar y ejecutar blockes específicos mientras otras partes son ignoradas. Dependiendo de si la condición (lógica) se cumple o no.

if

"If simple", en este if, el código solamente se ejecuta si la condición se cumple. Si no se cumple, simplemente lo ignora.

if (Condicion_Booleana)
    ...[Código si la condición se cumple]...;
 
//o...
 
if (Condicion_booleana) {
   ...[Código si la condición se cumple]...;
}

"if + else". En este if, si se cumple la condición, se ejecuta sólo el código que esta adentro del if (no la del else). Y si no se cumple, se ejecuta la del else (y no la del if).

if (Condicion_Booleana) {
    ...[Código si se cumple la condición]...
} else {
   ...[Código si no se cumple la condición del if]...
}
 
// Ejemplo:
 
if (x >= 10) {
    System.out.println("x es mayor o igual a 10!");
} else {
    System.out.println("x es menor a 10");
}

Y finalmente, el "if + else if + [else]". En este, podemos controlar más de una excepción. Por ejemplo, si 10 es mayor a x, si 10 es igual a x o si 10 es menor a x. En este, podremos controlar tantas excepciones como queramos (Cuantas más excepciones controlamos, menos posibilidad de que falle el programa hay). También, al final de todo podemos poner un else, por si no se cumple ninguna de las condiciones previas.

if (x > 10) {
    System.out.println("x es mayor a 10");
} else if (x < 10) {
    System.out.println("x es menor a 10");
} else if (x == 10) {
    System.out.println("x es igual a 10");
}
 
// Que es lo mismo a...
 
if (x > 10) {
    System.out.println("x es mayor a 10");
} else if (x < 10) {
    System.out.println("x es menor a 10");
} else {
    System.out.println("x es igual a 10");
}

switch

También esta el "switch", una sentencia muy parecida al if. Esta puede manejar un número infinito de posibilidades con más facilidad que el if.También se diferencian que la expresión en el switch puede ser byte, char, short o int. Cuando en el if sólo bool. Cuando el switch evalúa la expresión, busca por una constante igual a ella. Si la encuentra, ejecuta la sentencia hasta encontrar un break. Si no encuentra ninguna equivalente, busca la linea default. Si la encuentra, ejecuta la sentencia en ella. Sino, simplemente continúa la ejecución del programa (como se deduce, la linea default es opcional).

Ejemplo de la declaración del switch:

switch (expresión) {
    case 1:
        Sentencia_1;
        break;
    case X:
        SentenciaX;
        break;
    default:
        Sentencia;
        break;
}

Aquí un pequeño ejemplo del uso del switch:

int x = 5;
switch(x) {
    case 1:
        System.out.println("x vale 1");
        break;
    case 2:
        System.out.println("x vale 2");
        break;
    case 5:
        System.out.println("x vale 5");
        break;
    default:
        System.out.println("x no es equivalente a ninguna de las anteriores...");
        break;
}

Y un snippet para que vean que el break es opcional y entiendan mejor como funciona:

System.out.print ("x es... ");
switch (x){
  case 0:
    System.out.print ("cero y \n");
  case 2:
    System.out.print ("primo y \n");
  case 4:
  case 6:
    System.out.print ("par\n");
  break;
  case 1:
    System.out.print ("uno e \n");
  case 3:
  case 5:
    System.out.print ("impar\n");
  break;
  default:
    System.out.println ("muy grande\n");
  break;
}
 
//Code by joserc87

Estructuras de iteración

Son las que nos permiten ejecutar secciones específicas de código una cantidad determinada de veces. De este modo, podemos optimizar la velocidad y desempeño del programa (y el código también). Hay 3:

1. El while
2. El while-do
3. Y el for

while

El bucle while nos permite ejecutar un código determinado hasta que la condición sea falsa. Ejemplo de declaración de un while:

while (Exprecion_booleana) {
   ...
}

Ejemplo de uso:

int x = 0;
 
while (x < 10) {
    System.out.println("x = " + x);
    x++;
}

Ese código lo que hace es escribir el valor de x hasta que sea equivalente a 10. Una vez que eso ocurra, se continuará normalmente con la ejecución del programa.

do-while

También esta el bucle do-while. Este bucle tiene la característica de que si la expreción del while es falsa, el código se ejecutará una vez antes de continuar. La sintaxis de este bucle es la siguiente:

do {
   ...
} while (exprecion_booleana);

Un ejemplo de su uso podría ser:

int x = 0;
 
do {
    System.out.println("x = " + x);
    x++;
} while (x < 10);

Ese código, al igual que el ejemplo del bucle while, escribirá el valor de x mientras sea menor a 10.

Y un ejemplo de si no se cumple la expresión:

int x = 0;
 
do {
    System.out.println("x = " + x);
    x++;
while (x == 100);

Solamente escribiría "x = 0" una vez antes de continuar con el código.

for

El bucle for nos permite ejecutar un bloque de código un número determinado de veces. Al igual que el do-while, el bucle for suele ser más compacto que un while. Sintaxis del bucle y un ejemplo de su uso:

for (inicializacion; condición; actualizacion) {
   ...
}
 
// Ejemplo:
 
int i;
 
for (i = 0; i < 10; i++) {
    System.out.println("Este bucle se ha repetido " + i + " veces...");
}

Esas han sido las estructuras de control, ahora que ya las conocemos, podemos dar un paso más adelante en el estudio de Java y pronto poder hacer nuestras propias aplicaciones por nuestra propia cuenta :D. Nos vemos en el próximo tutorial!