Estructuras de control de flujo en Java.

Como su nombre indica son estructuras que contienen los programas para controlar el control de flujo de las acciones que trabajan dentro de él. Con estas estructuras podremos modificar el funcionamiento dependiendo de si cumplen ciertas condiciones, si nosotros elegimos una opción, etc.

Existen dos grupos, las estructuras de selección y las estructuras iterativas.

Dentro de las primeras, de selección, tenemos el if, que ya lo vimos en su propio artículo, el “if-else” y el “swich”. Como ya vimos los if son básicamente un control de condiciones y si estas se cumplen se ejecutan unas ciertas acciones. Sin embargo, el switch, podríamos decir que es una especie de menú, según la opción o expresion que elijamos o se elija automáticamente, se ejecutara una acción dentro de esta.

Y el segundo grupo, las iterativas, tenemos los conocidos bucles, el “while”, el “for” y el “do while”. Estas estructuras de control tienen la peculiaridad de que si la condición que se les pasa, no esta muy bien definidas, se pueden provocar bucles infinitos y nunca salir de él. Lo cual es fatal para un programa, la típica de quedarse pillado.

Una vez conocidos un poco vamos a ver cual es su sintaxis y un ejemplo de funcionamiento.

IF

Como crear un if en java

SWITCH

El “if” ya lo tienes en su artículo, así que de ese pasamos. La sintaxis del switch en java es la siguiente:

switch (expresión) {
    case valor 0:
       acción 0;
       break;
    case valor 1:
       acción 1;
       break;
    case 2:
       acción 2;
       break;
    default:
       expresión no reconocida;
    break;
}

Podemos ver como se inicia con la palabra reservada “switch”, dentro de los paréntesis hay que colocar un valor, tipo entero, char, un enumerado o boolean, y según será esta, hará el case que le corresponda. En este ejemplo, este puesto case 0, pero el 0 se puede sustituir por lo que convenga, ya sea un String entre comillas, un número, u otra opción. Por último, tiene un break, que rompe la ejecución del “switch”.

Hay que decir que puede tener tantos casos como se quiera, no tiene un numero limite, el límite lo pones tu.

Ahora vamos a verlo en un ejemplo de funcionamiento:

public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
        int numero;
        
        System.out.println("Intruduce un numero");
        numero = entrada.nextInt();
        switch (numero) {

            case 0:
                System.out.println("Has elegido el 0");
                break;
            case 1:
                System.out.println("Has elegido el 1");
                break;
            case 2:
                System.out.println("Has elegido el 2");
                break;
            default:
                System.out.println("No has elegido nada");
                break;
        }
}

Creamos un scanner para poder meter por teclado lo que queramos, una variable numérica para meter ahí el número. Luego le pedimos por texto que introduzca un número, que se meterá en la variable anterior y seguidamente entrará en el “switch”.

Dentro de este, se ira al caso o case que le corresponda y ejecutará la acción, en este ejemplo será imprimir una pequeña cadena de texto. Tal que así:

  • Para ir finalizando con este primero, vamos a ver algunas cosas importantes de la estructura del switch:
  • La expresión, es obligatorio que esté entre paréntesis.
  • La expresión puede dar un valor de tipo entero (cualquiera de ellos), un char, un enumerado o un boolean.
  • A partir de Java 7 se pueden usar tambien String.
  • A continuación, en cada case aparece un valor que únicamente puede ser un valor literal o una constante del mismo tipo que la expresión del switch.
  • Después de cada case se puede poner una única sentencia o un conjunto de ellas.
  • Los valores asociados en cada case se comparan en el orden en que están escritos.
  • Cuando se quiere interrumpir la ejecución de sentencias se utiliza la sentencia break que hace que termine el switch y continúe ejecutando la sentencia que se encuentre después de la llave de cierre de dicho switch. Se pondrá como instrucción final de cada case, por tanto.
  • La parte default es opcional.
  • Si ningún valor de los case coincide con el resultado de la expresión y la parte default no existe, no se ejecuta nada de la estructura switch.
  • Se puede no poner la sentencia break en algún caso, pero si hacemos esto, seguirá el flujo sin comparar el valor que no lo tenga.

FOR

Ahora pasaremos a los bucles. En primer lugar, el for tiene la siguiente sintaxis:

for (inicialización; condición; actualizacion) {
    sentencias;
}
  • Inicialización: solo se ejecutará en la primera iteración del bucle y es una sentencia que permite inicializar el buble. Puede ser la declaración e inicialización de las variables que se utilizan en el bucle.
  • Condición: en la condición para continuar la ejecución del bucle. La condición se evalúa siempre antes de empezar a ejecutar el bucle. Sila condición es cierta se ejecutan las sentencias del bucle.
  • Actualización: después de ejecutar las sentencias del bucle y antes de volver a evaluar la condición se ejecuta la actualización. Esta parte se suele utilizar para modificar el valor de las variables que forman parte de la condición.

Una vez conocidos los términos, vamos a ver un ejemplo:

public static void main(String[] args) {
      for (int i = 0; i < 5; i++) {
            System.out.println("i vale = " + (i + 1));
            System.out.println("Reparartuordenador.com");
      }
}

Se inicia con la palabra for, dentro de los paréntesis pondremos el tipo de dato primero, nombre de la variable que controlara el bucle (normalmente se pone como nombre “i”, pero se puede llamar diferente) iniciada en 0, separado por un “;” ponemos el limite de repeticiones que queremos, con un “<” seguido del número, que también podría ser un “lenght” de un array, por ejemplo, y detrás del ultimo “;”, el aumento de esta variable, normalmente con un ++, que aumente en 1 la variable.

Dentro de sentencias tenemos print, en uno veremos como el valor de i aumenta y el otro, un texto de ejemplo. Como resultado obtenemos lo siguiente:

WHILE

Vamos con el siguiente bucle, en este caso el while, a diferencia del anterior, la condición que se le pasa por paréntesis se ejecutara mientras sea verdad o true. En las sentencias de dentro del bucle se puede modificar los valores de la condición y el bucle llegara un momento que finalice. Si no se hace tendremos el conocido como bucle infinito. Su sintaxis es la siguiente:

while (condición) {
      sentencias;
}

Y ahora vamos a ver un ejemplo de uso:

public static void main(String[] args) {
int valor = 10;
int numero = 5;
int contador = 0;

     while ((valor > numero)) {
          contador++;
          valor--;
     }
     System.out.println("La diferencia entre valor y número es " + contador);
}

Como podemos ver, tenemos varias variables declaradas y dadas valor. Iniciamos el bucle con su palabra reservada y como condición le decimos que se ejecute mientras valor sea mayor que el número. Como sentencias modificaremos el valor de estas variables, primero, el contador que será, como su propio nombre indica, el que cuente las veces que se ejecutara, y después el de valor lo reducimos, esto hará que la condición llegue un momento que sea falta y terminara la ejecución.

Por último, tendremos un print que nos indica el valor del contador o lo que es lo mismo, cuantas veces se ha repetido el bucle. Tendremos como resultado lo siguiente:

DO WHILE

Por último, de momento, veremos otro bucle while, pero esta vez un poco diferente, el “do while”. Traducido será una cosa, así como, hacer esto mientras…. A diferencia del que hemos visto antes, este se ejecutara al menos una vez, y seguirá en ejecución hasta que la condición sea “false”. El anterior no entrara si no se cumple siquiera una vez. La sintaxis del do while es la siguiente:

do {
   sentencias;
} while (condicion);

Pero todo esto lo veremos mejor con un ejemplo.

public static void main(String[] args) {
int edad = 1;
    do {
        if (edad == 1) {
            System.out.println("Edad inicial: " + edad);
            edad++;
        } else if (edad > 1 && edad < 18) {
            System.out.println("Es menor de edad: " + edad);
            edad++;
        } else {
            System.out.println("Es mayor de edad: " + edad);
            edad++;
        }
    } while (edad < 19);
}

Primero iniciamos una variable que será la que controle el cotarro. Creamos el bucle, primeramente, con un do y después las sentencias. Aquí mezclamos con un if, pero bueno, así vemos algo mas sofisticado. Ira controlando el valor de edad, en la primera vuelta y al ser el mismo valor de edad que la condición del if, hace la primera sentencia, aumenta el valor de edad en 1 con el ++. Se salta las restantes y pasa a la condición del while, que en este caso sigue siendo true. Volverá arriba y ejecutara de nuevo. El primer if ya no se cumple, así que pasa al segundo, se cumple, imprime el texto y aumenta también edad.

Esto se repetirá varias veces. La ultima vuelta, en este caso, entrara esta vez en el else, aumenta otra vez edad y esta vez, al ser edad mayor que la condición de los paréntesis, no se vuelve a ejecutar de nuevo y se sale del do while. El resultado sería algo como esto:

Y con esto habríamos terminado con las estructuras de control de java. Pronto veremos mas de estas en otros lenguajes de programación, que quizás las sintaxis cambian. Y muchas mas cosas diferentes y no por ello menos entretenidas.