Las sentencias de control de flujo en Java (if, switch, for, while, do-while, try-catch, break, continue e invocación)

Java es un lenguaje orientado a objetos donde aplicando los principios de encapsulación, herencia y polimorfismo, el código está dentro de los métodos de las clases de los objetos. El código dentro de los métodos sigue los principios de los lenguajes imperativos con una secuencia de sentencias de asignación, control de flujo, llamada a otros métodos y de repetición, más recientemente con la incorporación de las lambdas y referencias a métodos en Java 8 es posible emplear también un enfoque de programación funcional.

La orientación a objetos es una forma de organizar el código y los datos que maneja ese código de modo que se respeten los principios de encapsulación, una forma de reutilizar el código con herencia y una forma de abstraer el comportamiento dependiendo de la clase concreta que implementa el método. Pero el código de Java no es únicamente código orientado a objetos también es un lenguaje imperativo para el código de los métodos.

El código imperativo se basa en la ejecución de forma secuencial de un conjunto de sentencias. Las sentencias de un método o programa son de diferente tipo: de asignación, condicionales, de repetición, de gestión de excepciones para controlar errores y de llamadas a funciones, en el caso de los lenguajes orientados a objetos llamadas a métodos. Estas sentencias individuales se pueden anidar unas dentro de otras por ejemplo tener una sentencia de repetición dentro del bloque de sentencias de una condicional.

Cada uno de estos tipos de sentencias forman las piezas básicas de construcción de los programas, combinadas en múltiples lineas de código forman programas complejos que sirven para el propósito para que el programa fue escrito.

Sentencias de asignación

Las sentencias de asignación sirven para asignar nuevos valores y referencias a objetos a variables y propiedades de objetos. La sintaxis de la asignación consta del nombre de variable que toma el valor a la izquierda, el operador de asignación en el medio y de la expresión a la derecha. El valor de una variable o propiedad cambia con una sentencia de asignación, el valor anterior se reemplaza por el nuevo valor. El nuevo valor de la variable es el resultado de evaluar la expresión que proporciona el valor, con una asignación de inicialización es posible asignar un valor al mismo tiempo que se declara una variable o propiedad de un objeto.

Una variable tiene un valor si se trata de un tipo primitivo de datos, en caso de tener como tipo una clase contiene una referencia a una instancia de un objeto de ese tipo o la referencia nula. Una expresión devuelve como resultado un valor y este es el asignado a la variable por la sentencia de asignación.

Una expresión puede contener múltiples operadores: para datos booleanos (de lógica &&, ||, ! y de comparación ==, !=, <, >, <=, >=), aritméticos para datos numéricos (+, -, *, /, %, ++, –) o operadores para datos binarios (&, |, ^, ~, «, », »>). Otros operadores de asignación (+=, -=, *=, /=, %=, «=, »=, &=, ^=, |=) toman como primer operando el valor de la variable, esto evita repetir el nombre de la variable en la expresión y facilita la legibilidad del código.

1
2
3
4
5
6
7

variable = expresión;

int x = 1;
List list = List.of("1", "2");

x = 2;
list = List.of("3", "4");

El operador ternario ?: es una expresión condicional que devuelve el valor de la expresión según el resultado de evaluar una expresión booleana.

1
2

variable = (condicionExpresionBoleana) ? expresionTrue : expresionFalse;

Setencias condicionales (if, switch)

Las sentencias condicionales son un tipo de sentencia que evalúa una expresión booleana y dependiendo de su valor verdadero o falso ejecuta o no su su bloque de sentencias asociado para cada caso. Las sentencias a continuación de la condición se ejecutan si la sentencia if se evalúa como verdadero. La sentencia if además puede tener otro bloque de sentencias a ejecutar si la expresión booleana se evalúa como falso, el bloque de sentencias else. Las sentencias if y else se pueden encadenar.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

if (condicionExpresionBoleana)
   sentenciaTrue

if (condicionExpresionBoleana) {
   bloqueSentenciasTrue
}

if (condicionExpresionBoleana) {
   bloqueSentenciasTrue
} else {
   bloqueSentenciasFalse
}

if (condicionExpresionBoleana) {
   bloqueSentenciasTrue
} else if (condicionExpresionBoleana) {
   bloqueSentenciasTrue
} else {
    bloqueSentenciasFalse
}

int a = 3;
int b = 2;
if (a > b) {
    System.out.println("a es mayor que b");
} else {
    System.out.println("a no es mayor que b");
}

Cuando una sentencia if tiene muchas ramas y la expresión condicional comprueba en todos los casos diferentes valores de una misma variable se utiliza la sentencia switch. Si el valor de la variable coincide con el valor del bloque del caso se ejecutan las sentencias de ese bloque. Cada bloque ha de estar finalizado con sentencia break para no evaluar las sentencias del siguiente bloque. El caso default permite ejecutar un bloque de sentencias si el valor de la expresión no coincide con ninguno de los valores de los casos, siendo como la parte else de las sentencias if.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

switch (variable) {
   case 1: {
       bloqueSentencias
   } break;
   case 2: {
       bloqueSentencias
   case 3: {
       bloqueSentencias
   } break;
   default: {
       bloqueSentencias
   }
}

La sentencia if equivalente del switch anterior sería el siguiente. si es posible se prefiere usar la sentencia switch sobre la if equivalente, más si hay un varias ramas, ya que es mas sencilla, legible y no hace falta indicar en cada expresión de condición la expresión que devuelve el valor.

1
2
3
4
5
6
7
8
9

if (variable == 1) {
   bloqueSentencias
} else if (variable == 2) {
   bloqueSentencias
} else if (variable == 3) {
   bloqueSentencias
} else {
   bloqueSentencias
}

Las sentencias if se pueden anidar unas dentro de otras esto dificulta la legibilidad del código, para evitar múltiples anidaciones y crear varias ramas se utilizan guard clauses que simplifican el flujo del programa.

Sentencias de repetición (for, foreach, while, do-while, break, continue)

Las sentencias de repetición permiten ejecutar un bloque de sentencias durante un número determinado de veces o mientras se cumpla una condición. En cada iteración después de ejecutar el bloque de sentencias la condición se vuelve a evaluar si se sigue cumpliendo, si se cumple se realiza una nueva iteración si no se cumple se sale del bucle y se continua con la siguiente sentencia del programa. Esta evaluación de la condición y ejecución del bloque de sentencias se realiza hasta que la condición del bucle while no se cumpla. Hay varios tipos de bucles.

La sentencia while ejecuta un bloque de sentencias mientras se cumpla una condición, puede ocurrir el caso de que la condición de la sentencia while no se cumpla y por tanto el bloque de sentencias de repetición no se ejecute ninguna vez. La comprobación de la condición se realiza antes de entrar al bucle.

1
2
3

while (condicionExpresionBoleana) {
   sentences
}

En el bucle do-while la comprobación de la condición está después del bloque de sentencias de repetición, a diferencia del bucle while en el do-while el bloque de sentencias se ejecutan al menos una vez.

1
2
3

do {
   bloqueSentencias
} while (condicionExpresionBoleana);

La sentencia for utilizan otra sintaxis para realizar bucles, una de las 4 formas de hacer un bucle for contiene una inicialización, condición de repetición e incremento además del bloque de sentencias a ejecutar. Otras formas de bucle for son el forearch para colecciones de objetos.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

for (inicializacion; condicionExpresionBoleana; incremento) {
   bloqueSentencias
}

for (int i = 0; i < 10; ++i) {
   System.out.println(i);
}

// Foreach
Collection<Object> collection = ...;
for (Object object : collection) {
   System.out.println(object);
}

Dentro de las sentencias de bucle se pueden emplear las palabras reservadas break y continue. La sentencia break permite salir del bucle inmediatamente sin necesidad de evaluar la condición. La palabra continue dejar de ejecutar sentencias del bucle y evaluar de nuevo la condición de bucle, si se sigue cumpliendo la condición se ejecuta de nuevo el bloque de sentencias. Las sentencias break y continue normalmente se utilizan dentro de una sentencia condicional if.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// Break
for (int i = 0; i < 10; ++i) {
   if (i == 5) {
       break;
   }
   System.out.println(i);
}

// Resultado
0
1
2
3
4

// Continue
for (int i = 0; i < 10; ++i) {
   if (i == 5) {
       continue;
   }
   System.out.println(i);
}

// Resultado
0
1
2
3
4
6
7
8
9

Un bucle infinito es en un bucle que se itera contnuamente porque la condición de iteración se cumple siempre. Ejecutar continuamente un bloque de sentencias hace que el procesador consuma todos los recursos que se disponen de cómputo de procesador o una alta actividad de entrada y salida que degrada el rendimiento del sistema sin producir ningún resultado útil cuanto menos si no genera errores en el resto de programas del sistema. Suele ser por un error de programación y para resolverlo habitualmente hay que matar el proceso del programa y reiniciarlo, si no se corrige el error en el bucle en las mismas condiciones se producirá de nuevo el bucle infinito.

Setencias de control de expceciones (try-catch, throw)

Las expresiones try-catch son el mecanismo de control de errores en Java. Estas expresiones permiten tratar las excepciones lanzadas por la palabra reservada throw en los métodos invocados de su bloque de sentencias.

1
2
3
4
5

try {
   bloqueSentencias
} catch (Exception e) {
   bloqueSentenciasTratamientoExcepcion
}

Las excepciones se lanzan con la palabra reservada throw, toda excepción ha de heredar de Exception y si no hereda de RuntimeExecption ha de declararse en la firma del método para indicar que el método puede lanzar esa excepción en caso de no ser tratada dentro del mismo método con un try-catch.

1
2
3
4
5
6
7

void exception() throws Exception {
    throw new Exception();
}

void runtime() {
    throw new RuntimeException();
}

Invocación de métodos

Las funciones en los lenguajes orientados a objetos dentro de las clases, las clases encapsulan las variables y las funciones o métodos. Los métodos tiene acceso además de a los parámetros que recibe a las variables del objeto en las están contenido y otros métodos de la misma clase u otros objetos respetando los ámbitos de visibilidad de las palabras reservadas public, protected, private y default.

Las expresiones de invocación a métodos se componen del objeto que recibe la llamada a uno de sus métodos separado por un punto y nombre del método. Si el método llamado devuelve un objeto se puede encadenar otra nueva llamada a un método del objeto devuelto. El valor o referencia a objeto devuelto se puede asignar a una variable también.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

String string = "Hola Mundo!";
System.out.println(string);

// Resultado
Hola Mundo!

string = string.toUpperCase();
System.out.println(string);

// Resultado
HOLA MUNDO!