====== Sentencias de Control de Flujo ====== El flujo de un programa es **el orden en el que se ejecutan las instrucciones**. Mientras no lo controlemos, siempre se ejecutará una instrucción después de otra, en el órden en el que estén escritas hasta el final del programa. **Existen ciertas instrucciones que permiten al código tomar decisiones sobre qué instrucciones vamos a ejecutar y cuáles no**. Dicho de otro modo, pueden elegir un camino en la ejecución del programa (flujo de ejcución), descartando otro camino, todo ello basado en una condición. ===== La sentencia If ===== {{ :bloque2:if_flow.png?100|}} If (si, condicional) evalúa una expresión booleana (condición) y ejecuta un bloque de instrucciones si la condición es **true**. __Solo__ si la expresión booleana es //true//, se ejecutarán las instrucciones que indiquemos dentro del bloque //if//. Un bloque de código viene delimitado por el carácter corchete { }.


if(condicion) {
   System.out.println("Se ha cumplido la condición");
   System.out.println("Y puedo ejecutar varias instrucciones");
}

System.out.println("Esto se ejecuta, se haya cumplido o no");

Si la condición se cumple se ejecutan las instrucciones del bloque //if//. Independientemente de si se cumple o no, después se continua con las instrucciones que hay después del bloque //if//. ==== La sentencia If-Else ==== {{ :bloque2:if_else_flow.png?150|}} Si queremos que se ejecuten unas instrucciones si se cumple una condición **y otras distintas** si no se cumple, usaremos la sentencia //if-else//. El bloque //else// siempre es opcional.


if(condicion){
   System.out.println("Se ha cumplido la condición");
}else{
   System.out.println("No se ha cumplido la condición");
}

System.out.println("Esto se ejecuta, se haya cumplido o no");

==== If-Else anidados ==== La sentencia if-else es una instrucción más de java. Al igual que cualquier otras instrucción, puede ser ejecutada dentro de otra sentencia if-else:


int edad = 5;

if(edad >= 18){
   System.out.println("Tienes 18 o mas.");
}
else if(edad >= 15){
   System.out.println("Tienes 15 años o mas pero menos de 18.");
}
else if(edad >= 10){
   System.out.println("Tienes 10 años o mas pero menos de 15.");
}
else{
   System.out.println("Eres un niño.");
}

===== Ámbito de una variable ===== Las variables en Java pueden ser únicamente de dos tipos atendiendo a su ámbito: * Variables Locales: Se declaran (crean) dentro de un método, o bloque { }. * Variables de Clase: Se declaran en el bloque de la Clase de Java. Se verán mas adelante. El ámbito de una variable define su alcance de uso, o lo que es lo mismo, en que secciones (bloques { }) de código esa variable estará disponible. Fuera de este ámbito, una variable no podrá ser accedida (no existe).


public static void main(String[] args){
   int numero1 = 7;
   int numero2 = 6;

   if(numero1 > numero2){
      String saludo = "Hola Mundo";
      System.out.println(saludo);
      
      //Aquí tengo acceso a las variables numero1, numero2 y saludo.
   }
   //Aquí ya no existe la variable saludo
}
//Aquí dejaron de existir todas las variables

__Las variables solo existen en el bloque en el que son **declaradas**__. ===== La sentencia Switch ===== Switch nos permite evaluar un valor y ejecutar un bloque de instrucciones dependiendo de ese valor. Actúa parecido a una serie de sentencias if-else anidadas. El switch buscará el valor de la variable entre los valores de los //cases//, y ejecutará el código del caso que coincida con dicho valor.


int variable = input.nextInt();

switch (variable) {
   case 1:
      System.out.println("Has seleccionado la opción 1");
      break;
   case 2:
      System.out.println("Has seleccionado la opción 2");
      break;
   case 15:
      System.out.println("Has seleccionado la opción 15");
      break;
...
   default: //Opcional
      System.out.println("El valor no coincide con ningún caso");
}

==== Funcionamiento ==== * Switch funciona con los tipos: ''int'', ''byte'', ''short'', ''char'' y ''String''. * El valor de cada ''case '' debe ser del mismo tipo que la variable que usa el switch. * Puede haber tantos ''cases'' como se desee. * Cada //case// es seguido del valor a comparar (expresión literal del valor). * Cuando la variable coincide con el valor de un //case// se ejecutan todas las instrucciones hasta encontrar la sentencia ''break''. * El uso del break no es obligatorio, pero si recomendable. Si un caso no tiene break, se ejecutarán todos los casos siguientes hasta encontrar un break. * Puede existir un solo caso ''default'', que se ejecutará cuando el valor de la variable no coincide con el valor de ningún caso. ===== El bucle for ===== Los bucles son bloques de código que se ejecutan repetidamente mientras se cumpla una condición booleana. El bucle **for** es el más usado, y se utiliza siempre que sepamos el número de veces que debemos repetir un bloque de código.


for (int i = 0; i < 5; i++){
   System.out.println("Esta es la repetición nº: " + i);
}

====Funcionamiento==== * La primera ejecución del bucle ejecuta la inicialización: ''int i = 0''. Solo la primera vez. Después: - Se evalúa la condición: ''i < 5'' - Si la condición es ''true'' se ejecuta el código del bloque. Si es ''false'' termina el bucle y continua en la siguiente instrucción. - Después de ejecutar el código del bloque se realiza el incremento: ''i++'' - Después de realizar el incremento se vuelve al paso 1. La variable **i** (index) se conoce como __variable de control__ del bucle. Si creamos un bucle dentro de otro, se usan como identificadores: i, j, k, l, etc. ** Las instrucciones contenidas dentro bloque del for, no deben modificar nunca el valor de la variable de control (i). Si necesito que sea así, es que no necesito un bucle for, y debo usar otro bucle** ===== El bucle While ===== Este tipo de bucle es el más sencillo de todos, tan solo necesita una condición booleana, que se evaluará antes de cada iteración; mientras esa condición sea verdadera, se ejecutará el código del bloque. ====Funcionamiento==== - Se evalúa la condición entre paréntesis ''cantidad > 2''. - Si es ''true'' se ejecutan todas las instrucciones del bloque. - Despues de la última instrucción del bloque se vuelve al paso 1.


int cantidad = 5;
while(cantidad > 2){
   //instrucciones
   cantidad = cantidad - 1; //Todo bucle debe modificar su condición de salida
}

El bucle ''while'' se usa cuando queremos repetir un bloque de instrucciones, pero sin saber cuantas veces se repetirá. **Se repite 0 o más veces**. ===== El bucle Do-While ===== Funciona de forma muy parecida al bucle ''while'' con la diferencia de que la condición se evalúa al final. Si después de ejecutar el bloque la condición sigue siendo ''true'', se continua con la iteración.


int cantidad = 0; 
do { 
   System.out.println("La cantidad es " + cantidad); 
   cantidad = cantidad + 1; //Modificamos la condición de salida
} while (cantidad < 10);

** Este bucle es el único que lleva '';'' después de la condición. ====Funcionamiento==== - Se ejecuta el bloque de código. - Se evalúa la condición '' cantidad < 10''. - Si es ''true'' se vuelve al paso 1. El bucle ''do-while'' se usa cuando debemos ejecutar una serie de instrucciones **al menos una vez**. ===== Sentencias break y continue en bucles ===== Existen dos instrucciones que permiten manejar las iteraciones del bucle desde el interior de su bloque de código: * ''break'': rompe la ejecución del bucle y nos lleva a la instrucción siguiente después del bucle. * ''continue'': cuando la ejecutamos, directamente vuelve a ejecutar el bucle desde el inicio. ===== Qué bucle usar ===== * Siempre que pueda usaré el bucle ''for'' * Si antes de la ejecución del bucle conozco el número de repeticiones: bucle ''for'' * Si el nº de repeticiones depende del código que contiene el bucle, pero debe ejecutarse al menos una vez: bucle ''do-while'' * Si el nº de repeticiones depende del código que contiene el bucle, pero puede que no se repita ninguna: bucle ''while'' ---- {{ vimeo>299450152?medium }} ---- (c) {{date> %Y}} Fernando Valdeón