Estructuras de control en Java

Las estructuras de control en java las emplearemos para modificar el flujo secuencial de un programa. Esto es, el orden en el que se van ejecutando las instrucciones de este.

En un programa, las instrucciones se ejecutan de arriba abajo, y de izquierda a derecha, según el orden en que aparezcan las mismas. Los distintos bloques de instrucciones de nuestro programa, seguirán este flujo secuencial para ejecutar las instrucciones. Los bloques de instrucciones, estarán delimitados por corchetes:

Bloque {
instrucción 1;
instrucción 2; instrucción 3;
instrucción 4;
}

Sin embargo, van a existir ocasiones en las que necesitemos romper este flujo secuencial. Estas pueden ser de muy diverso tipo, puede que necesitemos tomar una decisión entre una o varias opciones posibles, o a lo mejor necesitamos realizar algunas instrucciones varias veces. Por tanto, necesitamos ciertas estructuras que nos permitan interrumpir el flujo secuencial del programa, y pasar a ejecutar otros bloques de código.

En este post, vamos a estudiar el funcionamiento de las siguientes estructuras de control:

  • De toma de decisión: if-then, if-then-else, switch.
  • De bucle: for, while, do-while

Estructuras de toma de decisión

Estructura if

La función “if” es probablemente la más básica de las estructuras de control de flujo. La función evalúa una condición y ejecuta un bloque de instrucciones en el caso de que la condición sea verdadera.

flujo de la estructura if

Ejercicio 1: Practicando con la estructura if

  1. Abre el compilador online:
  2. Introduce el siguiente código:
public class Div {   
public static void main(String args [ ] ){ 
   int num1,num2;
   num1 = 6; num2 = 3;
   if (num1%num2 ==0){
        System.out.println ("El resto es: "+num1%num2);
        System.out.println("El primer número es divisible por el segundo");
        }
    }
}

Línea 5: Contiene la instrucción if, que evalúa la condición: num1%num2 ==0

Si la condición es verdadera, entonces las instrucciones dentro del bloque if (líneas 6 y 7) son ejecutadas.

  1. Ejecuta el programa, el resultado debería ser:
El resto es: 0
El primer número es divisible por el segundo

Estructura if-else

La instrucción “if-else” provee un segundo camino en el caso de que la condición se evalué como falsa. Es decir, si es falsa, pasamos a ejecutar otro bloque de instrucciones.

Estructura if-else

Ejercicio 2: Practicando con la estructura if-else

  1. Abre el compilador online:
  2. Introduce el siguiente código:
public class Div {   
public static void main(String args [ ] ){ 
   int num1,num2;
   num1 = 6; num2 = 4;
   if (num1%num2 ==0){
        System.out.println ("El resto es: "+num1%num2);
        System.out.println("El primer número es divisible por el segundo");
        } 
    else {
        System.out.println("el primer número no es divisible por el segundo");
        }
    }
}

Línea 9: Esta línea es nueva sobre el programa que empleamos al explicar la sentencia if. Utilizamos la palabra reservada else para definir el bloque de instrucciones que se ejecutara cuando la evaluación de la condición del if (num1%num2 ==0)  resulte falsa.

  1. Ejecuta el programa. Deberías obtener el resultado:
el primer número no es divisible por el segundo

Estructura if-else if

Con este tipo de instrucciones, empleamos varias condiciones a chequear. La sintaxis sería:

if (condición-1)
            bloque de instrucciones-1
else if (condición-2)
            bloque de instrucciones-2
else if (condición-3)
            bloque de instrucciones-3

Ejercicio 3: Practicando con la estructura if-else-if

  1. Abre el compilador online:
  2. Introduce el siguiente código:
public class JugandoConIf{
     public static void main(String []args){
        String dia;
        dia = "Domingo";
        if (dia.equals("Lunes")){
            System.out.println("Ufff!, justo empezando la semana");
        }
        else if (dia.equals("Miercoles")){
            System.out.println("A mitad de semana");
        }
        else if (dia.equals("Viernes")){
            System.out.println("Mañana es fin de semana");
        }
        else if(dia.equals("Sabado")||dia.equals("Domingo")){
            System.out.println("Disfruta del finde");
        }
        else {
            System.out.println("que tengas un buen día");
        }
     }
}

Línea 3: Declaración de variable tipo String.

Línea 4: Inicialización de la variable dia. Usamos esta variable para practicar con las diferentes instrucciones if.

Línea 5: Primer instrucción if.

Línea 14: Esta instrucción evalúa una expresión con el operador “||” (operador lógico OR). Con este operador, es suficiente con que uno de los dos operandos sea evaluado como verdadero para que la expresión completa sea verdadera.

  1. Ahora, ejecuta el programa. El resultado será:
Disfruta del finde
  1. Vamos a teclear otro código para entender mejor como funcionan estas sentencias de control. Compararemos el uso de la sentencia “else if” con el uso de la sentencia “if” a secas:
public class JugandoConIf{
     public static void main(String []args){
        int numero;
        numero = 7;
//Usando else if
        System.out.println ("Usando la sentencia else if");
        if (numero > 2){
            System.out.println(numero + " es mayor que 2");
        }
        else if (numero >5){
            System.out.println(numero + " es mayor que 5");
        }
        else if (numero == 7){
            System.out.println("El numero es 7");
        }
//Usando solamente la sentencia if
        System.out.println ("-------------");
        System.out.println ("Usando solamente la sentencia if");
        if (numero > 2){
            System.out.println(numero + " es mayor que 2");
        }
        if (numero >5){
            System.out.println(numero + " es mayor que 5");
        }
        if (numero == 7){
            System.out.println("El numero es 7");
        }
     }
}

Línea 6 a la Línea 15: Realizamos varias comparaciones empleando la sentencia else if. Cuando una de las condiciones sea verdadera, el bloque de instrucciones de dicha condición será ejecutado y el resto de las condiciones, ni siquiera se evaluarán.

Línea 17 a 27: En esta ocasión, evaluamos las mismas condiciones que anteriormente, pero empleando únicamente la sentencia if. Se van evaluando las distintas condiciones y ejecutándose las instrucciones del bloque si la condición es verdadera. En este caso, se evalúan todas las condiciones.

  1. Si ejecutas el programa, el resultado debería ser:
Usando la sentencia else if
7 es mayor que 2
-------------
Usando solamente la sentencia if
7 es mayor que 2
7 es mayor que 5
El numero es 7

Estructura Switch

Esta sentencia se emplea para seleccionar un bloque de instrucciones a ejecutar, en función del valor de una expresión. Funciona de la siguiente manera:

  • Se evalúa la expresión de la sentencia switch.
  • El valor de la expresión es comparado con los valores de cada caso.
  • Si hay coincidencia, se ejecuta el bloque asociado.
  • Las sentencias break y default son opcionales

La sintaxis es la siguiente:

switch(expresion) {
   case x:
      bloque de instrucciones
   break;
   case y:
      bloque de instrucciones
   break;
   default:
      bloque de instrucciones
}

Veamos su funcionamiento con un ejemplo.

Ejercicio 4: Practicando con la estructura switch

  1. Abre el compilador online:
  2. Introduce el siguiente código:
public class PracticandoSwitch{
     public static void main(String []args){
        String dia;
        dia = "Domingo";
        switch (dia){
            case "Lunes":
                System.out.println("Ufff!, que la fuerza te acompañe");
            break;
            case "Miérccoles":
                System.out.println("Estamos a mitad de semana");
            break;
            case "Viernes":
                System.out.println("Mañana empieza el fin de semana");
            break;
            case "Sábado": case "Domingo":
                System.out.println("Disfruta del fin de semana");
            break;
            default:
                System.out.println("Que tengas un buen día");
            break;
        }
     }
}

Línea 5: La sentencia switch. La expresión que evalúa el valor del String dia.

Línea 7: Instrucción que sería ejecutada en caso de que dia fuera Lunes.

Línea 9: Instrucción que sería ejecutada en caso de que dia fuera Miércoles.

Línea 19: Instrucción que sería ejecutada en el caso de que ninguno de los bloques de sentencias anteriores fuera ejecutado.

  1. Si ejecutas el programa obtendrás el siguiente resultado:
Disfruta del fin de semana

Estructuras de bucles

Java dispone de algunas sentencias que ejecutan de manera recurrente un bloque de código, mientras se cumpla una cierta condición. Estas sentencias son:

  • for
  • while
  • do –while

Estructura for

La sentencia for crea un bucle que se ejecuta mientras una determinada condición sea verdadera. Maneja un iterador que cambia su valor cada vez que se ejecuta el bucle. Finalmente saldremos de este cuando la condición se haga falsa.

Flujo de la estructura for

La sintaxis:

for (inicialización del iterador ; condición ; actualización del iterador)
      <bloque de instrucciones>

Veámoslo en un ejemplo.

Ejercicio 5: Practicando con la estructura for

  1. Abre el compilador online:
  2. Introduce el siguiente código:
public class PracticaFor {
    public static void main(String args[]) {
        for (int iterador=0; iterador<10;iterador++){
            System.out.println("El iterador o contador es: "+iterador);
        }
    }
}

Línea 3: La sentencia for. Usamos la variable iterador, de tipo int. La condición que evaluamos es: iterador<10. Y el iterador es incrementado en uno cada vez que se ejecuta el bloque de instrucciones.

Línea 4: Pintamos el valor del iterador en la pantalla.

  1. Si ahora ejecutamos el Código, obtendremos el siguiente resultado:
El iterador o contador es: 0
El iterador o contador es: 1
El iterador o contador es: 2
El iterador o contador es: 3
El iterador o contador es: 4
El iterador o contador es: 5
El iterador o contador es: 6
El iterador o contador es: 7
El iterador o contador es: 8
El iterador o contador es: 9
  1. Cambia la actualización del operador. Prueba el siguiente código:
public class PracticaFor {
    public static void main(String args[]) {
        for (int iterador=0; iterador<10;iterador=iterador+3){
            System.out.println("El iterador o contador es: "+iterador);
        }
    }
}

Línea 3: La sentencia for. Hemos cambiado la actualización del iterador, ahora, cada vez que se ejecuten las instrucciones del bucle, el iterador se incrementará en 3 en lugar de en 1.

  1. Ejecuta el programa. Obtendrás:
El iterador o contador es: 0
El iterador o contador es: 3
El iterador o contador es: 6
El iterador o contador es: 9

Estructura while

La sentencia while, permanece en bucle ejecutando un bloque de código mientras una condición especifica sea verdadera.

Flujo de la estructura while
while (condición) {
     <  bloque de instrucciones >
}

Ejercicio 6: Practicando con la estructura while

  1. Abre el compilador online:
  2. Introduce el siguiente código:
public class ProbandoWhile {
    public static void main(String args[]) {
        int numero=15;
        while (numero>2){
            System.out.println("El numero es "+numero);
            numero = numero -3;
        }
    }
}

Línea 3: La variable numero se inicializa a 15.

Línea 4: La sentencia while. Se evalúa la condición numero>2, y si es verdadera se ejecutan las instrucciones dentro del bloque while. Si no lo es, salimos del bucle while.

Línea 6: El valor de la variable numero es disminuido en 3. Si no modificáramos el valor de esta variable dentro del bloque, el programa entraría en un bucle infinito, estaría siempre ejecutando las instrucciones dentro del bucle while.

  1. Si ejecutas el programa, obtendrás el resultado siguiente:
El numero es 15
El numero es 12
El numero es 9
El numero es 6
El numero es 3

Estructura do-while

Similar al bloque while, solo que el bloque de instrucciones se ejecuta al menos una vez, ya que la evaluación de la condición se hace tras cada ejecución del bloque de instrucciones.

Flujo de la estructura do-while
do  {
    <bloque de instrucciones>
} while (condición)

Para apreciar la diferencia con la sentencia while, usaremos el mismo ejemplo empleado cuando explicaba esa sentencia, pero cambiándolo a do-while.

Ejercicio 7: Practicando con la estructura do-while

  1. Abre el compilador online:
  2. Cambia el Código de la actividad realizada para la sentencia while, de manera que la condición del bucle while sea falsa desde el principio y de esta forma, nunca se ejecute el bucle while.
public class ProbandoWhile {
    public static void main(String args[]) {
        int numero=1;
        while (numero>2){
            System.out.println("El numero es "+numero);
            numero = numero -3;
        }
        System.out.println("Final");
    }
}
  1. Si ejecutamos el programa, obtenemos el resultado:
Final
  1. Constatamos que el bucle while no se ha ejecutado ninguna vez
  2. Ahora cambiamos el bucle while por un bucle do-while
public class ProbandoWhile {
    public static void main(String args[]) {
        int numero=1;
        do {
            System.out.println("El numero es "+numero);
            numero = numero -3;
        }while (numero>2);
        System.out.println("Final");
    }
}
  1. Si ejecutas el programa, obtenemos el resultado:
El numero es 1
Final
  1. Se puede apreciar que el bloque de instrucciones se ha ejecutado al menos una vez, aunque nunca se haya hecho verdadera la condición del bucle do-while

NOTA:

Este post es parte de la colección “Java” que reproduce los apuntes de la clase que imparto sobre el tema en ESIC. Puedes ver el índice de esta colección aquí.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *