Fundamentos de programación Tema 2
Condicionales y bucles
Funciona en el IDE online. Todo lo de esta sección funciona en el IDE online: pulsa Pruébalo en cualquier ejemplo, o abre el IDE y escribe el tuyo. Sin instalar nada.
Concepto#
Las estructuras de control permiten modificar el flujo de ejecución de un programa. Con ellas podemos, especialmente:
- Tomar decisiones (seleccionar si se ejecuta un código u otro en función de un valor o condición).
- Repetir bloques de código (bucles).
Según el teorema de la programación estructurada (Böhm y Jacopini), todo programa puede construirse únicamente con:
- Secuencia: instrucciones ejecutadas en orden.
- Selección: permite bifurcaciones en función de condiciones.
- Iteración: repite un bloque de instrucciones.
Operadores#
Los operadores son símbolos que se utilizan habitualmente para comprobar condiciones.
Operadores de comparación#
Operadores para comparar datos. Dan siempre true o false. En los ejemplos, int a = 5; e int b = 3;:
| Operador | Significa | Ejemplo | Resultado |
|---|---|---|---|
== | Igual que | a == b | false |
!= | Distinto de | a != b | true |
> | Mayor que | a > b | true |
< | Menor que | a < b | false |
>= | Mayor o igual que | a >= 5 | true |
<= | Menor o igual que | a <= 4 | false |
Importante
Para comparar se usan dos iguales, ==. Uno solo, =, no compara: guarda un valor en la variable.
Operadores lógicos#
Operadores para hacer más de una comprobación a la vez.
&&→ AND (true si ambas condiciones son verdaderas)||→ OR (true si al menos una condición es verdadera)!→ NOT (niega la condición)
Todas las combinaciones posibles (la llamada tabla de verdad):
A | B | A && B | A || B | !A |
|---|---|---|---|---|
true | true | true | true | false |
true | false | false | true | false |
false | true | false | true | true |
false | false | false | false | true |
Por ejemplo, edad >= 16 && edad < 18 solo es true si la edad es 16 o 17.
Comparar textos: equals#
Los textos (String) no se comparan con ==, sino con .equals(). Con == Java no mira las letras: mira si las dos variables apuntan al mismo texto en la memoria, y dos textos con las mismas letras pueden estar en sitios distintos. Por eso == a veces funciona y a veces no, que es lo peor que puede pasar:
import java.util.Scanner; // arriba del todo, antes de la clase
Scanner sc = new Scanner(System.in);
System.out.print("¿Quieres continuar? (si/no) ");
String respuesta = sc.nextLine();
if (respuesta.equals("si")) {
System.out.println("Seguimos");
}
if (respuesta.equalsIgnoreCase("SI")) {
System.out.println("También vale SI, Si o sI");
}String respuesta = IO.readln("¿Quieres continuar? (si/no) ");
if (respuesta.equals("si")) {
IO.println("Seguimos");
}
if (respuesta.equalsIgnoreCase("SI")) {
IO.println("También vale SI, Si o sI");
}| Para… | Se escribe |
|---|---|
| ¿Son iguales dos textos? | texto.equals("si") |
| ¿Iguales sin mirar mayúsculas? | texto.equalsIgnoreCase("si") |
| ¿Son distintos? | !texto.equals("si") |
¿Es la primera letra una s? | texto.charAt(0) == 's' (un char sí se compara con ==, entre comillas simples) |
Estructuras condicionales en Java#
Condicional simple – if#
Cuando solo queremos comprobar si se cumple una condición para realizar una acción.
if (edad >= 18) {
// programación si se cumple
}Condicional doble – if-else#
Cuando queremos realizar una acción si se cumple la condición, y otra acción si no se cumple.
if (edad >= 18) {
// programación si se cumple
} else {
// programación si no se cumple
}Condicional múltiple – if-else if-else#
Cuando queremos realizar diferentes acciones en función del resultado de la condición.
if (edad >= 18) {
// programación que se ejecuta si tiene 18 años o más
} else if (edad >= 16) { // aquí ya sabemos que edad < 18
// programación que se ejecuta si tiene 16 o 17 años
} else {
// programación que se ejecuta si no ha cumplido ninguna de las anteriores condiciones (en este caso, si es menor de 16 años)
}Condicional múltiple – switch#
Permite ejecutar un código u otro en función del valor que tenga una variable. Similar al if-else if-else, pero solo comprueba si la variable es igual a cada valor (no admite <, >…). Funciona con int, char y String, no con double ni boolean.
String estacion = "Verano";
switch (estacion) {
case "Verano":
System.out.println("hace calor");
break;
case "Invierno":
System.out.println("hace frío");
break;
default:
System.out.println("no se reconoce esa estación"); // Valores distintos a los anteriores
}Operador ternario#
Es una forma corta de escribir un if-else cuando lo único que hace es elegir entre dos valores:
variable = (condición) ? valor_si_verdadero : valor_si_falso;int edad = 15;
String tipo = (edad >= 18) ? "adulto" : "menor";
System.out.println(tipo); // menorEs lo mismo que:
int edad = 15;
String tipo;
if (edad >= 18) {
tipo = "adulto";
} else {
tipo = "menor";
}
System.out.println(tipo); // menorÚsalo solo para elegir un valor. Si en cada caso hay que hacer varias cosas, un if-else se lee mejor.
Estructuras iterativas (bucles)#
Bucle for#
Se usa cuando se conoce el número exacto de iteraciones (Ejemplo: repetir 10 veces).
for (int i = 0; i < 10; i++) {
// programación que se repetirá 10 veces
}En este bucle podemos ver:
int i = 0: creamos la variable contadori < 10: decimos que se repita mientras la i sea menor que 10i++: decimos que laivaya aumentando de 1 en 1.
Bucle while#
Se trata de un bucle que se repite mientras se cumpla una determinada condición. Deja de repetirse la instrucción cuando la condición deje de cumplirse. Es decir, es un mientras, no un hasta.
while (puntos > 0) {
// programación que se repetirá mientras puntos sea mayor que cero
}Bucle do-while#
Exactamente igual que el bucle while, con la única diferencia de que primero ejecuta la instrucción que tiene en su interior, y después comprueba si la condición se cumple. Esto asegura que las instrucciones internas se ejecuten al menos una vez.
do {
// programación que se ejecuta una vez y se repite mientras puntos sea mayor que cero
} while (puntos > 0);Sentencias de salto#
Un bucle (y, en el caso de break, también un switch) puede interrumpirse con estas instrucciones:
| Instrucción | Qué hace |
|---|---|
break | Interrumpe el bucle (o el switch) y sigue con lo que haya después |
continue | Se salta lo que queda de esta vuelta y pasa a la siguiente |
return | Termina la función entera, y con ella el bucle (lo verás en el tema de funciones) |
for (int i = 1; i <= 10; i++) {
if (i == 3) {
continue; // el 3 no se escribe
}
if (i == 6) {
break; // al llegar al 6, se acaba el bucle
}
System.out.print(i + " "); // 1 2 4 5
}Repetir hasta que: while (true) y break#
A veces la condición para salir se sabe en medio del bucle, no al principio: por ejemplo, pedir números hasta que se escriba un 0. Se escribe un bucle que se repite siempre, while (true), y se sale con break cuando toca:
import java.util.Scanner; // arriba del todo, antes de la clase
Scanner sc = new Scanner(System.in);
while (true) {
System.out.print("Escribe un número (0 para terminar): ");
int n = Integer.parseInt(sc.nextLine());
if (n == 0) {
break; // sale del bucle
}
System.out.println("El doble es " + (n * 2));
}
System.out.println("Adiós");while (true) {
int n = Integer.parseInt(IO.readln("Escribe un número (0 para terminar): "));
if (n == 0) {
break; // sale del bucle
}
IO.println("El doble es " + (n * 2));
}
IO.println("Adiós");Ese 0 que marca el final se llama centinela. Sin el break, el bucle no terminaría nunca.
Contadores y acumuladores#
Dos variables que aparecen en casi todos los ejercicios con bucles:
| Variable | Para qué | Empieza en | En cada vuelta |
|---|---|---|---|
| Contador | Contar cuántas veces pasa algo | 0 | contador++ |
| Acumulador | Ir sumando valores | 0 | suma += valor |
int pares = 0; // contador
int suma = 0; // acumulador
for (int i = 1; i <= 10; i++) {
suma += i;
if (i % 2 == 0) {
pares++;
}
}
System.out.println("Suma: " + suma); // Suma: 55
System.out.println("Pares: " + pares); // Pares: 5Importante
El contador y el acumulador se crean antes del bucle. Si los creas dentro, vuelven a valer 0 en cada vuelta.
Bucles anidados#
Un bucle puede ir dentro de otro. Por cada vuelta del de fuera, el de dentro da todas las suyas. Así se recorren tablas de filas y columnas:
for (int fila = 1; fila <= 3; fila++) {
for (int col = 1; col <= 4; col++) {
System.out.print("*");
}
System.out.println(); // salto de línea al acabar cada fila
}
// ****
// ****
// ****Y la tabla de multiplicar del 1 al 3:
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 10; j++) {
System.out.println(i + " x " + j + " = " + (i * j));
}
}Equivalencias entre bucles#
Todos los bucles (while, do-while, for) son equivalentes en potencia. Esto quiere decir que un mismo problema podrá resolverse con diferentes bucles. Se recomienda elegirlos según el problema:
| Bucle | Cuándo usarlo | Comprueba la condición… | Mínimo de veces que se ejecuta |
|---|---|---|---|
for | Sabes cuántas veces se repite | antes de cada vuelta | 0 |
while | Se repite mientras se cumpla una condición | antes de cada vuelta | 0 |
do-while | Igual que while, pero tiene que hacerse al menos una vez (por ejemplo, un menú) | después de cada vuelta | 1 |
Pausas: Thread.sleep#
Para hacer una cuenta atrás, o para que el texto no salga todo de golpe, el programa tiene que esperar. Thread.sleep(…) lo para el tiempo que le digas, en milisegundos: 1000 son 1 segundo.
for (int i = 5; i >= 1; i--) {
System.out.println(i);
try {
Thread.sleep(1000); // espera 1 segundo
} catch (InterruptedException e) {
// si algo interrumpe la espera, seguimos sin más
}
}
System.out.println("¡Despegue!");¿Por qué el try y el catch? Mientras el programa espera, otra parte de él podría despertarlo antes de tiempo. Es raro, pero puede pasar, y Java obliga a decir qué hacer en ese caso: si escribes Thread.sleep(1000); sin más, el programa ni siquiera compila.
| Parte | Cómo se lee | Qué va dentro |
|---|---|---|
try { … } | «Intenta esto» | La pausa: Thread.sleep(1000); |
catch (InterruptedException e) { … } | «Si interrumpen la pausa, haz esto en vez de pararte» | Normalmente nada: el programa sigue con lo siguiente |
Es la primera vez que controlas una excepción, un error que surge al ejecutar. Ya viste otras, como NumberFormatException; la diferencia es que esta Java obliga a controlarla. Las verás con más calma al trabajar con ficheros, donde pasa lo mismo cuando un fichero no existe.
Consejo
VS Code lo escribe por ti: pon el cursor sobre el Thread.sleep subrayado en rojo, pulsa la bombilla (o Ctrl + .) y elige Surround with try/catch.
Errores frecuentes#
| Mensaje o síntoma | Qué significa | Cómo se arregla |
|---|---|---|
incompatible types: int cannot be converted to boolean | Has escrito if (x = 5): con un solo = no se compara, se asigna | Usa ==: if (x == 5) |
reached end of file while parsing | Falta cerrar alguna llave } | Cuenta las llaves: cada { necesita su }. Indentar bien el código ayuda a verlo |
El if siempre se ejecuta, se cumpla o no | Hay un ; justo después del paréntesis: if (x > 0); | Quita ese ;. Detrás de la condición va la llave {, no el punto y coma |
| El programa no termina nunca (bucle infinito) | La condición del bucle nunca llega a ser false | Comprueba que dentro del bucle cambia la variable de la condición (por ejemplo, el i++ del for) |
Un switch ejecuta también los casos siguientes | Falta el break al final de un case | Pon break; al final de cada case |
unreported exception InterruptedException; must be caught or declared to be thrown | Has escrito Thread.sleep(…) sin su try y su catch | Rodéalo con try { … } catch (InterruptedException e) { }, como en Pausas |
Comparar textos con == falla (a veces da false aunque sean iguales) | En Java los String se comparan con .equals() | if (respuesta.equals("si")): mira Comparar textos |
| La suma o el contador vuelven a empezar en cada vuelta | La variable está creada dentro del bucle | Créala antes del bucle: int suma = 0; y luego el for |