Buenas,
En este tema veremos el concepto de modificador del flujo de ejecución y nos adentraremos en los tipos llamados estructuras de decisión.
Modificadores del flujo de ejecución
Los programas que hemos visto hasta este tema tienen una linea de ejecución lineal, esto quiere decir que primero se ejecutara la primera linea, luego la segunda y así sucesivamente sin excepción hasta terminar el programa.
Esto tiene dos limitaciones principales:
- No permite tomar decisiones: En un programa lineal no se pueden realizar elecciones basadas en condiciones. Por ejemplo, no se puede ejecutar una parte del código solo si cierta condición se cumple.
- No permite repetir tareas: Si necesitamos repetir una acción varias veces, tendríamos que escribir manualmente esa acción varias veces, lo cual no es eficiente.
Para superar la primera limitación usamos estructuras de decisión, las cuales se explicaran en este mismo tema.
Y para superar la segunda usamos las estructuras de repetición las cuales veremos en el siguiente tema.
If - else if - else
Esta estructura nos permite ejecutar diferentes bloques de código según un valor booleano que usualmente viene como resultado de una comparación.
La sintaxis varia en base a cuantos bloques de código tenemos y en que casos queremos que se ejecuten. veamos las diferentes sintaxis:
if
if ([valor booleano])
{
// bloque de codigo.
}
*En este caso, solo se ejecutara el bloque de código si el valor booleano (o la operación, como una comparación, que lo devuelva) sea true.
if - else
if ([valor booleano])
{
// bloque de codigo.
}
else
{
// bloque de codigo.
}
*En este caso, si le valor del if es true, se ejecutara el primer bloque de código, y si es false, pues se ejecutara el segundo.
if - else if
if ([valor booleano])
{
// bloque de codigo.
}
else if ([valor booleano])
{
// bloque de codigo.
}
...
else if ([valor booleano])
{
// bloque de codigo.
}
*En este caso, se empezaran a comprobar los diferentes valores desde el primer if siguiendo en orden a los siguientes else if, cuando uno de ellos sea ture, se ejecutara el bloque de código correspondiente y ningún otro.
Si no hay ningún valor true, no se ejecutara ningún bloque de código.
Se pueden poner todos los else if deseados, siempre después del if.
if - else if - else
if ([valor booleano])
{
// bloque de codigo.
}
else if ([valor booleano])
{
// bloque de codigo.
}
...
else if ([valor booleano])
{
// bloque de codigo.
}
else
{
// bloque de codigo.
}
*Es una combinación de los anteriores, funcionara igual que el if - else if, pero, si al terminar las comprobaciones resulta que ninguna es true, ejecutara el bloque else.
Ejemplo
Veamos un ejemplo donde un valor numérico se categoriza en una nota.
int nota = 9; // Valor que se comparara.
if (nota > 0 && nota <= 4) // Si la nota es mayor que 0 y igual o menor que 4 se ejecutara el bloque.
{
System.out.println("Suspendido.");
}
else if (nota == 5) // Si la nota es 5 se ejecutara el bloque.
{
System.out.println("Justo.");
}
else if (nota == 6) // Si la nota es 6 se ejecutara el bloque.
{
System.out.println("bien.");
}
else if (nota == 7 || nota == 8) // Si la nota es 7 o 8 se ejecutara el bloque.
{
System.out.println("Notable.");
}
else if (nota >= 9 && nota <= 10) // Si la nota es mayor o igual a 9 y menor o igual a 10 (9 o 10) se ejecutara el bloque.
{
System.out.println("Sobresaliente.");
}
else // Si ninguna de las condiciones se cumplen, se ejecutara el bloque.
{
System.out.println("Nota no valida.");
}
Switch - case - default
Mientras que la estructura if - else if - else permite tomar decisiones en base a un valor booleano el cual puede ser el resultado de múltiples operaciones o comparaciones, la estructura switch - case - default nos permite tomar decisiones en base a comparar un valor con otro para encontrar equivalentes.
Veamos la sintaxis para aclararlo un poco:
Sintaxis
switch ([valor*])
{
case [valor]:
\\ Bloque de codigo.
[break;**]
...
case [valor]:
\\ Bloque de codigo.
[break;**]
default***:
\\ Bloque de codigo.
}
* El valor del switch normalmente viene de una variable o algún otro elemento, no tendría sentido poner un valor como tal.
** El elemento break es uno de los modificadores de control de flujo que se explicaran en un siguiente tema, su función es salir de la estructura donde esta, en este caso el switch
Si no se pusiera break después de cada bloque automáticamente saltaría a ejecutar el siguiente. En algunos casos nos puede interesar.
*** El elemento default para que nos entendamos, guardando las distancias, es el equivalente a else de if. Si el valor a comparar no coincide con ningún case, entonces, default nos permite ejecutar un bloque de código.
Ejemplo
Veamos un ejemplo donde un valor numérico se categoriza en una nota.
int nota = 9; // Valor que comparara el switch.
switch (nota)
{
case 1: // Si el valor es 1 ejecuta este bloque (vacío) y salta al siguiente porque no hay break.
case 2: // Si el valor es 2 ejecuta este bloque (vacío) y salta al siguiente porque no hay break.
case 3: // Si el valor es 3 ejecuta este bloque (vacío) y salta al siguiente porque no hay break.
case 4: // Si el valor es 4 ejecuta el bloque.
System.out.println("Suspendido.");
break;
case 5: // Si el valor es 5 ejecuta el bloque.
System.out.println("Justo.");
break;
case 6: // Si el valor es 6 ejecuta el bloque.
System.out.println("bien.");
break;
case 7, 8: // Si el valor es 7 o 8 ejecuta el bloque. (a partir de Java 14)
System.out.println("Notable.");
break;
case 9: // Si el valor es 9 ejecuta este bloque (vacío) y salta al siguiente porque no hay break.
case 10: // Si el valor es 10 ejecuta el bloque.
System.out.println("Sobresaliente.");
break;
default: // Si el valor no coincide con ninguno de los anteriores se ejecutara este bloque.
System.out.println("Nota no valida.");
break;
}
Como podéis observar, hay dos formas de ejecutar el mismo bloque para diferentes valores; usar la estructura case [valor], ..., [valor]: o, usar varios case [valor]: vacíos encima del bloque que queremos ejecutar.
Calculadora en Java
Con los conocimientos que se han impartido hasta este tema, ya somos capaces de hacer el proyecto mas simple que uno hace cuando esta aprendiendo un lenguaje de programación; una calculadora.
En este caso haremos una muy simple que le permita al usuario hacer una operación entre dos elementos.
Calculadora.java
import java.util.Scanner;
/*Clase principal*/
public class Calculadora
{
/*Metodo principal*/
public static void main(String[] args)
{
Scanner entrada = new Scanner(System.in); // Declarar e inicializar objeto scanner.
// Declarar variables qu vamos a usar.
double num1;
double num2;
double resultado = 0; // El compilador nos pedirá inicializarla pues contempla que no vaya a inicializarse antes de imprimir su valor.
char operador;
// Pedir y recoger el primer numero.
System.out.print("Introduzca el primer numero: ");
num1 = entrada.nextDouble();
entrada.nextLine(); // Limpiar el Buffer de Scanner (Esta clase es un poco problemática y a veces hay que hacer chapuzas como esta).
// Pedir y recoger el operador.
System.out.print("Introduzca el operador (+, -, x, /): ");
operador = entrada.nextLine().charAt(0); // Como no existe un metodo nextChar(), debemos leer la linea completa y convertiremos el primer elemento en char.
// Pedir y recoger el segundo numero.
System.out.print("Introduzca el segundo numero: ");
num2 = entrada.nextDouble();
entrada.close(); // Cerrar objeto Scanner.
// Realizar operación segun operador.
switch (operador)
{
case '+':
resultado = num1 + num2;
break;
case '-':
resultado = num1 - num2;
break;
case 'x':
resultado = num1 * num2;
break;
case '/':
// En Java, al dividir entre 0, salta una excepción, por eso nos aseguraremos de que num2 no es 0.
if (num2 != 0)
{
resultado = num1 / num2;
}
else
{
resultado = 0;
}
break;
default: // Si el operador que recibimos no es ninguno de los que hemos previsto, imprimiremos un mensaje de error.
System.out.println("! Error: Operador inesperado: " + operador + ".");
resultado = 0;
operador = '?';
}
// Imprimpir resultado.
System.out.println(num1 + " " + operador + " " + num2 + " = " + resultado);
}
}
En el siguiente tema veremos las estructuras de repetición (for, for - each, while y do - while).