Saltar navegación

Estructuras de Control: Condicional - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 15 de octubre de 2025 por Stefano C.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis, me autorizáis a grabar vuestra voz, ¿vale? 00:00:00
Entonces, hemos acabado la primera parte de Java básico, ¿vale? 00:00:07
Hemos dado los primeros pasitos en Java. 00:00:13
En realidad, hemos hecho un paso bastante grande con el operador ternario. 00:00:16
El operador ternario ya nos ha abierto el mundo a muchos ejercicios. 00:00:23
Es la razón de por qué la mayoría de los ejercicios luego se resolvían con un ternario. 00:00:26
Porque la informática sin un condicional, sin un si esto hace esto y si no hace este otro, es muy pobre, hace poco. 00:00:30
Por eso cuando hemos visto algo que podía darnos una alternativa, pues de ahí hemos sacado muchas cosas. 00:00:38
Ahora, la cosa positiva es que la primera parte de estructura y control que vamos a ver es sustancialmente lo mismo. 00:00:44
Si habéis entendido el operador ternario, el IF es muy fácil. 00:00:52
La única cosa que tenéis que entender profundamente es que el operador ternario no es una estructura de control. 00:00:58
El operador ternario es una expresión. 00:01:08
Yo evalúo el operador ternario y al final tengo un valor, tengo un literal de algo. 00:01:11
Sin embargo, el IF no se evalúa. 00:01:18
el if se ejecuta 00:01:20
dentro de un 00:01:24
condicional, de un operador ternario 00:01:27
yo tenía una condición y luego dos expresiones 00:01:30
estas expresiones, que tenían que ser del mismo tipo 00:01:32
y cosas por el estilo, no podían ser un comando 00:01:36
yo no podía, podía poner ahí dentro 00:01:39
3 más 5, operación, expresión 00:01:41
pero no podía poner system.auto.println 00:01:44
y nos puede decir, si esto es así, pues 00:01:47
escríbeme algo. ¿Vale? 00:01:50
Porque el operador ternario 00:01:52
no es una operación, no es una 00:01:54
estructura de control. Es 00:01:56
una expresión y se 00:01:58
evalúa. Tiene que dar un valor. 00:02:00
Y System.Auto.Println no da un 00:02:02
valor. 00:02:04
¿Se entiende? Pues ahora vamos a 00:02:06
ver una cosa que es igual, 00:02:08
solo que en las dos ramas, 00:02:10
si es verdadero o si es falso, 00:02:12
sí puedo 00:02:15
poner un programa entero. 00:02:16
¿Sí? Es decir, 00:02:19
que en vez de decir, si esta condición 00:02:20
es verdadera, 00:02:22
hazme una expresión, 00:02:24
si esa expresión es verdadera, haz un conjunto 00:02:26
programas, 00:02:30
de comandos, de instrucciones. 00:02:33
Y si es falsa, 00:02:36
haz otro conjunto de instrucciones, 00:02:38
que pueden ser una, dos, 00:02:40
cincuenta, siete mil. 00:02:41
¿Sí? Es sustantivamente 00:02:44
un bloque de instrucciones. 00:02:45
En un futuro se pueden llamar métodos. 00:02:47
puede hacer un montón de cosas 00:02:49
¿sí? entonces 00:02:51
¿IF y operador alternado 00:02:52
son la misma cosa? no 00:02:55
¿tienen cosas parecidas? 00:02:57
sí ¿usan los dos 00:02:59
una expresión booleana para indicar 00:03:01
si hacen una cosa u otra? sí 00:03:03
¿se pueden usar para las mismas cosas? 00:03:04
¿es más potente el IF o es más 00:03:08
potente el otro? 00:03:11
el IF probablemente es más potente 00:03:13
¿vale? pero 00:03:15
grosso modo se usan para cosas distintas esto como introducción ahora vamos a 00:03:16
hablar de esto que es una estructura de control una estructura de control son 00:03:24
elementos del lenguaje que nos permiten romper el flujo lógico de ejecución de 00:03:30
instrucción si os acordáis cuando vimos una de las 00:03:35
primeras transparencias estamos hablando del lenguaje estructurado vale en un 00:03:40
lenguaje imperativo como el nuestro, decíamos que necesitaba algunos elementos para poder 00:03:45
funcionar, ¿vale? Que eran los condicionales, eran los iterativos y eran las secuencias, ¿vale? 00:03:51
Y un lenguaje, o sea, un programa normal, básico, como los que hemos hecho ahora más o menos, 00:03:59
es secuencial. Empieza desde el principio y ejecuta todas las instrucciones una tras otra. 00:04:07
hasta cuando yo tengo un operador 00:04:14
ternario, que una parte de este operador 00:04:16
no la ejecuto, no la evalúo 00:04:19
pero en realidad estoy evaluando esa línea 00:04:20
ese comando, cada comando 00:04:23
se ejecuta 00:04:25
uno tras otro 00:04:27
hasta ahora todos nuestros ejercicios 00:04:28
han sido secuenciales 00:04:31
estábamos en la primera de las tres características 00:04:32
que hemos visto 00:04:35
todo es secuencial 00:04:36
empieza desde la primera línea del main 00:04:38
y acaba en la última línea del main 00:04:40
¿Vale? Lo básico. Por eso se llamaba Java básico. 00:04:43
Ahora, las estructuras de control son mecanismos, son elementos, son elementos del lenguaje, del lenguaje de Java, ¿se entiende? 00:04:47
Que lo que permiten es romper ese flujo normal. 00:04:58
En vez de decir, empieza aquí y acaba aquí, pues ahora el flujo de ejecución de los datos, el flujo de ejecución de las instrucciones, 00:05:04
puede que no sea tan lineal 00:05:12
secuencial 00:05:14
1, 2, 3, 4, 5 00:05:16
puede ser que haga saltos 00:05:17
puede ser que vuelva atrás 00:05:19
cuando se rompe 00:05:21
el flujo normal de 00:05:24
el flujo lógico 00:05:26
el flujo secuencial de datos 00:05:27
pues se necesita emplear 00:05:29
una estructura de control 00:05:32
que controla este flujo 00:05:34
me permite decir salta 00:05:36
me permite decir vuelve atrás 00:05:37
Se denomina flujo de ejecución 00:05:39
El orden en el que se ejecutan determinados conjuntos de instrucciones y sentencias 00:05:44
Por ahora el nuestro era secuencial básico 00:05:48
Y el flujo lógico es de arriba a abajo, de izquierda a derecha 00:05:50
¿Estamos de acuerdo hasta aquí? 00:05:55
Entonces tenemos tres tipos de sentencias de control 00:05:58
Tres grandes familias 00:06:02
Dentro de cada una de estas familias 00:06:04
Puedo tener varios mecanismos que normalmente son equivalentes. 00:06:06
Si yo me sé uno de estos tres, de estos mecanismos, puedo con más o menos esfuerzo hacer lo mismo que hacen los demás. 00:06:12
Entonces tengo los condicionales, tengo los iterativos y tengo las llamadas a métodos. 00:06:23
Los condicionales son los que me permiten decir si ejecuto o no un trozo de código 00:06:30
Entonces tendré un bloque de código y en base a algo, a una condición 00:06:38
Hemos visto la lógica booleana, entonces sabemos un true o un false 00:06:44
Ejecuto un trozo de código o no lo ejecuto 00:06:47
O ejecuto un trozo de código, un bloque de código o ejecuto otro distinto 00:06:51
Pero hay una alternativa, es un or 00:06:55
tengo en cierto momento 00:06:58
un bloque, lo voy a ejecutar 00:07:01
no lo sé, dependerá 00:07:03
de las condiciones con el que 00:07:05
el sistema, con el que mi programa 00:07:07
llega a ese bloque 00:07:09
y habrá una condición, si esta condición es verdadera 00:07:10
lo ejecuto, si esta condición es falsa 00:07:13
no lo ejecuto o ejecuto otro 00:07:14
estos son los condicionales 00:07:16
y dentro de los condicionales 00:07:19
hay tres 00:07:21
hay elifas secas 00:07:22
si esta condición es verdadera 00:07:24
ejecuta. Si no, no ejecuta. 00:07:27
Se acabó. 00:07:29
El if-else, que es su primo 00:07:31
muy cercano, que es 00:07:33
si es verdadera, ejecuta 00:07:35
una cosa. Si es falsa, ejecuta 00:07:37
otra. 00:07:39
Es parecido. De hecho, yo puedo 00:07:41
no tener el if-else 00:07:43
y hacer todo con un if. Pongo 00:07:45
if-condición, ejecuta 00:07:47
esto. If-not, misma 00:07:49
condición, pues ejecuta este otro. 00:07:51
Y he hecho un if-else. 00:07:54
No me hace falta el if-else. 00:07:55
Es cómodo tener, ¿vale? 00:07:57
Pero son equivalentes y puedo tener uno y no tener el otro. 00:08:00
Y luego está el switch, el switch case, ¿vale? 00:08:04
Se llama case. 00:08:07
Que sustancialmente sirve cuando mi condición depende de varios valores de una determinada variable. 00:08:08
Imaginaos que yo tengo una variable entera y digo que si esta variable vale 1, hace una cosa. 00:08:18
Si vale 2, hace una cosa distinta. 00:08:24
si vale 3 hace una cosa distinta. Se puede hacer lo mismo con un if, solo que normalmente cuando 00:08:26
yo intento hacer algo que iría bien con un switch case con un if, me sale un if dentro de un if, 00:08:34
dentro de otro if, dentro de otro if, cosa por el estilo. Una cosa que no se puede leer. Entonces, 00:08:42
como vieron que a veces pasaban estas cosas, dijeron ¿por qué no creamos un condicional 00:08:47
alternativo que en estos casos hace el código mucho más limpio pero sustancialmente es lo 00:08:52
mismo es una forma u otra de hacer las cosas pero es son estructuras equivalentes pero con 00:08:58
sintaxis distintas para que vosotros utilicéis la que os hace el código más leíble y esto lo 00:09:10
vamos a ver hoy, condicionales. Luego estarán los iterativos. Los 00:09:19
iterativos son los que me permiten repetir un determinado código más de una 00:09:25
vez. Son los ciclos, los bucles. Y tenemos 00:09:29
dos importantes y medio. Los dos importantes son el while y el for. 00:09:35
Lo veremos, lo repetiré. Pero cuando yo no sé cuántas veces voy a repetir 00:09:42
un ciclo, sé que me va a meter allí, y voy a repetir, pero no sé si tres, cinco o 00:09:49
veintisiete veces, pues este es un while, con su hermano menor, el do while, que es al 00:09:56
menos una vez hazlo. Mientras el while sería no sé cuántas veces, podría ser cero, 00:10:04
podrían ser mil, no lo sé, pero podría ser cero. El do while es este bloque, hazlo una 00:10:10
vez y luego a lo mejor lo repetirás o no y no sé cuántas veces. Lo veremos con más detalles cuando 00:10:18
lo veamos. El FOR en veces se utiliza cuando yo a priori sé cuántas veces voy a hacer este ciclo. 00:10:25
Ejemplos. Si yo te digo dame números hasta que ponga un cero. Dame un número, dame otro, dame otro, dame otro, 00:10:35
dame otro, si pones 0 a cabo 00:10:44
es un while on for 00:10:46
while, tú no sabes 00:10:48
cuántos números te va a dar 00:10:52
el usuario, podría ser que hoy te da 00:10:54
3, 3, 0, te ha dado 2 números 00:10:56
o puede ser que te da 1, 2, 3 00:10:58
4, 5, 6, 7, 8, 9, 10 00:11:01
12, 13, 0, pues a veces te ha dado 00:11:02
13, no sé 00:11:05
a tiempo de compilación cuántas veces 00:11:06
voy a reciclar 00:11:09
si en vez te digo 00:11:10
dame 5 números 00:11:12
cuántas veces tendré que pedir 00:11:15
dame un número 00:11:18
cinco veces 00:11:19
¿cuántas veces lo voy a hacer? 00:11:21
por lo tanto es un for 00:11:23
para que se entienda 00:11:25
¿puedo hacer lo que hace un for con un while? 00:11:27
sí, tranquilamente 00:11:33
¿puedo hacer lo que hace un while con un for? 00:11:34
sí, tranquilamente 00:11:37
son equivalentes 00:11:38
solo que hay casos 00:11:40
en el que en un while te sale una cosa bonita 00:11:42
que con un for es una cosa infernal 00:11:44
y hay otros casos que con un for 00:11:47
te sale una cosa bonita y con un while 00:11:49
es una cosa infernal que no se entiende 00:11:51
porque a un cierto momento Bob hace ese cálculo 00:11:52
de ahí, ¿vale? Entonces son dos 00:11:55
cosas que hacen lo mismo 00:11:57
son equivalentes, se pueden intercambiar 00:11:59
si tú quieres, pero 00:12:01
en determinados casos 00:12:02
es mejor una cosa 00:12:06
y en determinados casos 00:12:08
es mejor otra 00:12:10
¿sí? 00:12:11
y finalmente 00:12:12
acordaos que estamos en el concepto 00:12:15
de sentencias de control, ¿qué hace una sentencia 00:12:17
de control? 00:12:19
romper el orden lógico 00:12:24
romper el orden lógico con el que se ejecutan 00:12:25
las instrucciones, ¿os acordáis hace 3 minutos? 00:12:28
pues eso 00:12:31
pues, estas 3 00:12:32
hacen esto 00:12:35
esto lo rompe porque puede saltar 00:12:36
un trozo, esto lo rompe porque vuelve 00:12:39
a repetir algo que se había hecho antes 00:12:41
y esto lo rompe porque va a ejecutar 00:12:42
Un trozo de código que está en otro lado 00:12:45
Una llamada a método es que yo he llamado con un nombre una serie de instrucciones 00:12:48
He llamado cocodrilo 00:12:55
Entonces tengo mi main 00:12:57
En un determinado momento llamo el método cocodrilo 00:12:59
Que quiere decir, deja de hacer el main secuencialmente 00:13:03
Falta aquel bloque que yo he llamado cocodrilo 00:13:06
Ejecuta el método cocodrilo 00:13:11
o sea, las instrucciones del método cocodrilo 00:13:13
y cuando has acabado el método cocodrilo 00:13:17
vuelves al main y sigues 00:13:19
entonces ya no es secuencial, ha habido un salto raro 00:13:22
por eso rompe el flujo normal 00:13:25
¿hemos visto algún método? 00:13:30
math en concreto no, math es una clase 00:13:37
integer es otra clase 00:13:40
charact 00:13:44
charat es un método 00:13:47
random sí 00:13:49
math no 00:13:51
math es una clase 00:13:51
porque es el método random 00:13:54
de la clase math 00:13:56
como el método charat 00:13:58
lo llama sobre un string 00:14:00
nosotros todavía esto no lo entendemos bien 00:14:02
porque son cosas de 00:14:04
de objetos 00:14:06
entonces no entendemos porque a veces 00:14:08
lo llamo sobre math que es una clase 00:14:10
y a veces lo llamo sobre un string 00:14:12
que es un objeto 00:14:14
ni idea porque no lo he visto 00:14:15
pero println 00:14:18
¿qué es println? 00:14:21
es un método 00:14:26
¿escrito por quién? no lo sé 00:14:27
pero yo lo he metido en mi main 00:14:29
cuando mi main 00:14:31
llega a un println 00:14:33
se para, no sigue el main 00:14:34
se va a un código 00:14:37
que ha escrito alguien más 00:14:39
no sé dónde 00:14:41
ejecuta ese código que hace que me escriba 00:14:42
algo en pantalla 00:14:45
Y luego vuelvo a mi main y sigo adelante. 00:14:46
El next int o el next del escáner. 00:14:50
Pues mi programa va por allí. 00:14:54
Cuando llega al next, se va a un código que no he escrito yo, 00:14:56
que es un método de la clase escáner o del objeto escáner. 00:15:00
Y allí dentro ejecuta una serie de cosas que me permiten bloquear el proceso 00:15:04
y esperar que alguien teclee algo y le dé al intro. 00:15:09
Cosa que yo no tengo ni idea de cómo se hace. 00:15:12
y nadie de vosotros sabe cómo se hace 00:15:13
de verdad, pero llamando a este 00:15:16
método lo hace él solo 00:15:18
cuando ha acabado ese método 00:15:19
vuelve a mi main 00:15:22
y sigue adelante 00:15:23
pues estas son llamadas al método 00:15:24
un método se reconoce 00:15:27
porque es una palabra 00:15:30
en minúscula y luego hay paréntesis 00:15:31
system.auto.println 00:15:34
y paréntesis 00:15:38
nextint 00:15:39
paréntesis, paréntesis 00:15:41
¿sí? 00:15:43
¿qué más sabemos? charat 00:15:46
charat, paréntesis, numerito, paréntesis 00:15:48
punto equals 00:15:50
y luego lo meto entre paréntesis 00:15:52
todo eso son métodos 00:15:54
¿sí? 00:15:55
los métodos son en minúsculas 00:15:58
empiezan por minúsculas como las variables 00:16:00
pero las variables no tienen la paréntesis 00:16:02
los métodos tienen paréntesis 00:16:04
luego, ¿sobre qué se llaman? 00:16:06
si sobre un objeto, si sobre una clase 00:16:08
eso nos cuesta porque 00:16:10
Que todavía no sabemos la diferencia entre objetos y clases. 00:16:12
Veremos que nosotros la llamaremos sobre nada, 00:16:15
porque nuestros métodos serán 00:16:17
static, estáticos. 00:16:18
¿Y qué quiere decir? 00:16:20
Lo veremos en un multiverso paralelo en diciembre. 00:16:21
¿Sí? Por ahora no. 00:16:25
¡Dudas! 00:16:27
Entonces, dentro de la llamada 00:16:29
métodos, puedo llamar un método directamente, 00:16:31
puedo llamar un método sobre un objeto, 00:16:33
puedo llamar un método sobre una clase. 00:16:35
¿Qué diferencia hay? No lo sé. 00:16:37
No me interesa por ahora. 00:16:39
Por ahora nosotros usaremos esta cosa de aquí como mecanismo que se utiliza dentro del paradigma de programación estructurada, ¿vale? 00:16:40
En la programación estructurada no hay objetos sin clases y por lo tanto estos de aquí por ahora los aparcamos hasta que en un futuro, digamos, os acordáis ese transparente, pues ahora lo usamos. 00:16:52
Y en realidad lo estamos usando constantemente, repito, Math.random está haciendo esto, ¿sí? 00:17:03
y scan.nexint 00:17:09
está usando esto. 00:17:12
He creado un objeto scan, 00:17:13
scanner, scan, igual new, 00:17:16
ese new es un nuevo objeto 00:17:18
y luego está llamando scan.nexint. 00:17:19
Entonces, esto lo estamos usando constantemente 00:17:23
porque necesitamos usarlo para hacer 00:17:25
nuestros programas, pero no sabemos 00:17:27
qué es, por ejemplo. 00:17:28
¿Dudas? ¿Preguntas? 00:17:31
¿Quedan claros 00:17:37
qué es una sentencia 00:17:39
de control y una 00:17:41
estructura de control y que hay 00:17:43
tres tipos de estructura de control 00:17:45
y que cada una tiene 00:17:47
distintas implementaciones 00:17:49
de esta estructura de control, que puede 00:17:51
haber más, pero 00:17:53
que son sustancialmente equivalentes 00:17:55
solo que alguna es más cómoda en un 00:17:57
contexto, alguna en otra. 00:17:59
¿Sí? ¿Dudas? 00:18:01
Bueno, pues vamos 00:18:03
a empezar con los condicionales. 00:18:07
Sirven para proporcionar distintos caminos 00:18:08
lógicos de ejecución y después 00:18:11
continuar con el programa. Yo llego 00:18:13
un momento y tengo 00:18:15
un bivio, se dice bivio 00:18:17
¿bivio se dice? 00:18:18
¿no? ¿cómo se dice? 00:18:21
camino y bifurcación 00:18:23
tengo dos 00:18:25
vías, ¿vale? y puede decir 00:18:27
si pasar por la derecha o pasar por 00:18:29
la izquierda, ¿vale? 00:18:31
normalmente, luego estas cosas se reúnen 00:18:33
después, pero si he ido 00:18:35
a la derecha, he encontrado 00:18:37
el lobo y si he ido 00:18:39
a la izquierda, he encontrado 00:18:41
el gufo, y que me han dicho 00:18:43
pues no lo sé, gufo el búho 00:18:45
así aprendéis italiano, al final tenéis un 00:18:47
hoy hemos aprendido vídeo 00:18:51
en gufo, entran en esa 00:18:55
se valora 00:18:56
una condición 00:18:59
y en base al resultado se ejecutarán 00:19:00
unas instrucciones u otra 00:19:03
en realidad se podría decir también 00:19:04
se ejecutarán unas instrucciones 00:19:06
o no, dependiendo del if que tengo 00:19:09
el if más sencillo es 00:19:11
esto lo hace solo si es verdadera 00:19:13
la condición y ya está 00:19:15
mientras el if es un poquito más complejo, el if else es 00:19:17
si es verdadera hace una cosa 00:19:19
si es falsa hace otra 00:19:21
son dos versiones 00:19:22
parecidas 00:19:25
y aquí lo tenemos 00:19:26
¿vale? esto es 00:19:29
un diagrama de flujo 00:19:31
si veis alguna vez un diagrama 00:19:32
de flujo, no sé si lo habéis visto en otra 00:19:35
asignatura o en vuestra vida 00:19:37
o cosa por el estilo 00:19:39
normalmente en los diagramas de supos 00:19:40
el rombo es un condicional 00:19:44
es una pregunta 00:19:46
entonces si yo llego aquí 00:19:48
hay una condición 00:19:50
evalúo esta condición 00:19:51
que es una 00:19:54
una condición de lógica booleana 00:19:55
que a vosotros os encanta 00:19:58
y si es verdadera 00:19:59
ejecuto este bloque 00:20:02
si es falsa me salto el bloque 00:20:04
y luego sigo adelante 00:20:06
entonces, esta 00:20:08
parte de aquí se ejecuta 00:20:11
si y solo si las condiciones que tengo 00:20:13
ya no tengo 00:20:15
un flujo directo 00:20:16
continuo de ejecución 00:20:19
ya no puedo establecer 00:20:21
a tiempo de programación 00:20:23
si este bloque se ejecutará 00:20:25
o no, porque dependerá 00:20:27
a tiempo de ejecución 00:20:30
de si esta condición será 00:20:32
verdadera o falsa 00:20:33
dame un número, y si el número es 3 00:20:34
hace algo, si no, no. Y no puedo 00:20:37
saber si el usuario es bondad 3 o no. 00:20:39
¿Entiendes? 00:20:43
La otra alternativa 00:20:45
que es el if-fails. 00:20:47
Llego a la condición. Si es 00:20:48
verdadero, hay un bloque. 00:20:50
Y luego sigo. Si es 00:20:53
falso, hay un bloque distinto. 00:20:54
Y luego sigo. Son alternativas. 00:20:56
Es un pseudor. 00:20:59
O esto o esto. 00:21:00
Este de aquí es 00:21:03
o esto o nada. 00:21:04
Y este de aquí es o bloque 1 o bloque 2. 00:21:06
son equivalentes no son lo mismo son muy parecidos porque a veces tú dices sí 00:21:08
tienes que hacer un pago entonces tú tienes tu cuenta del banco y lo que tienes que hacer es 00:21:33
quitarse el dinero del banco y cuando llegas aquí dices oye si el pago es mayor que cero 00:21:39
entonces ejecuta pero si el listo me ha dicho cuánto te pago te pago menos 20 euros entonces 00:21:46
no lo hagas porque si no le sumas 20 euros a la cosa porque harás menos menos 20 me explico 00:21:54
en este caso esto a lo mejor es distinto lo quieres hacer así si es si el pago es correcto 00:22:02
hazlo, si no, no. Y ya está. 00:22:10
Entonces, no usa el silly fetch. 00:22:12
Pero magari puedes decir que si 00:22:14
el pago lo hace, porque es correcto, 00:22:16
lo haces, y si no, 00:22:18
le mandas 00:22:22
un mensaje de error. O 00:22:22
llamas a la policía y le dices, 00:22:24
me han intentado timar. Pues entonces 00:22:26
usarías este de la derecha. Son casos 00:22:28
un poquito distintos. En realidad 00:22:30
esto podría ser en un while, 00:22:32
pero lo veremos en un futuro, que es 00:22:34
si no me das un valor correcto, 00:22:36
Te digo no y te lo vuelvo a pedir 00:22:38
Pasita a pasita 00:22:40
Son muy parecidos 00:22:44
De hecho yo puedo hacer todo lo que pueda hacer con el de la izquierda 00:22:45
Lo puedo hacer con la derecha 00:22:48
Y todo lo que pueda hacer con la derecha lo puedo hacer con la izquierda 00:22:49
Simplemente que a veces me sale más bonito 00:22:52
Hacerlo con uno que con otro 00:22:55
Ejemplo de un is 00:22:56
¿Vale? 00:23:01
Entonces 00:23:03
Int x es igual a 5 00:23:04
Si 5 es menor que 00:23:07
de X es menor que 5. 00:23:09
System.out.println 00:23:11
menor que 5. 00:23:13
System.out.println de fin. 00:23:15
¿Qué escribe esto? 00:23:17
Pon aquí. ¿Por qué solo fin? 00:23:23
Porque 5 no es 00:23:31
menor que 5. Falso. 00:23:33
Y por lo tanto, 00:23:35
esta instrucción, 00:23:37
la que pone menor que 5, no se ejecuta. 00:23:38
¿Vale? 00:23:42
fijaos que if 00:23:42
escrito así, que yo lo odio escrito así 00:23:44
solo se aplica 00:23:46
a este 00:23:48
sentencia, esta sentencia 00:23:49
estaría afuera, estaría ya 00:23:52
aquí abajo 00:23:54
¿me entiende? 00:23:55
ahora, a mí 00:23:58
me gusta que 00:23:59
a lo que se aplica el if 00:24:01
se ponga entre una 00:24:03
entre llaves, en un bloco 00:24:05
o sea, if, bla bla bla 00:24:08
ya ve aquí antes del primer 00:24:09
system, bla bla bla 00:24:11
y ya ve aquí al final 00:24:13
y luego sigo, entonces veo 00:24:15
bien donde está el bloque 00:24:17
a que se aplica, pero si no lo 00:24:19
pongo, esta como funciona 00:24:21
este programa aquí me escribiría solo fin 00:24:23
vamos aquí a la pantalla 00:24:25
ahí se ve 00:24:46
¡ah no, no miréis! 00:24:48
soy yo chicos 00:24:50
¿sabéis que en el examen hay 00:24:51
tres ejercicios más? 00:24:54
vale 00:24:58
antes eran 100 00:25:00
ahora son 150 00:25:04
vale 00:25:05
int x es igual a 5 00:25:05
si x es menor que 6 00:25:08
llave 00:25:10
si está en punto 00:25:11
en el resultado 00:25:12
si está en punto 00:25:14
en el 00:25:15
menor que 6 00:25:15
que escribe esto 00:25:17
de todo 00:25:19
¿no? 00:25:24
escribe el resultado 00:25:25
se escribe menor que 6 00:25:26
y escribe fin 00:25:28
¿si? 00:25:29
porque el if 00:25:32
Solo se aplica desde aquí hasta aquí 00:25:33
Este es el bloque 00:25:36
Al bloque que viene después 00:25:36
Esto es el bloque que si es verdadero lo ejecute 00:25:39
Si es falso me lo salto 00:25:41
El último, el fin, está fuera de lista 00:25:43
Entonces siempre se aplicará 00:25:46
Hasta que si es verdadero o falso 00:25:48
La condición 00:25:50
¿Se entiende? 00:25:51
Fijaos que esto no lo podía hacer con un condicional 00:25:53
Con un operador externario 00:25:56
Porque aquí dentro del bloque 00:25:59
Si estoy haciendo dos operaciones 00:26:01
como 5 es menor que 6 00:26:02
true, pues entra aquí 00:26:10
y escribe esto, escribe esto 00:26:11
entonces esto no sirve de nada 00:26:12
¿qué pasa si no pongo las paréntesis? 00:26:17
¿qué pasa si no pongo las paréntesis? 00:26:25
¿dónde? 00:26:31
cambia el resultado 00:26:32
si yo no pusiera las paréntesis 00:26:36
escribiría exactamente lo mismo 00:26:46
pero cuidado que si luego cambio esto 00:26:48
y pongo 7 00:26:50
¿qué me pondría? 00:26:51
sin paréntesis y sin esto 00:26:56
si yo quito las paréntesis 00:26:58
está aquí la llave 00:27:03
y pongo 7 aquí 00:27:04
me dice 7 es menor que 6 00:27:06
falso 00:27:08
esta no la ejecuta 00:27:09
resultado, pero si pondría 00:27:11
menor que 6, fin 00:27:13
si no hubiese las paréntesis, las llevo 00:27:14
si no pongo las llaves 00:27:17
solo se aplica al siguiente comando 00:27:19
que es el primer system.out 00:27:21
entonces sería un problema 00:27:23
en vez con las llaves, si pongo 7 00:27:24
me escribiría solo 5 00:27:27
si no está, se aplica 00:27:29
al siguiente comando 00:27:33
¿vale? solo que si 00:27:35
Si el siguiente comando es un bloque, pues entonces se aplicará a todo el bloque. 00:27:37
Si no es un bloque, a la siguiente instrucción. 00:27:42
¿Se entiende? 00:27:47
¿Dudas? 00:27:48
Para quitaros de problemas, esto no lo hagáis nunca. 00:27:51
Hasta si es un comando solo, lo ponéis entre paréntesis. 00:27:57
Entre llaves. 00:28:01
¿De acuerdo? 00:28:04
Ejemplo número dos, no miréis la parte roja. 00:28:07
con cariño señor inspector cariño entonces te paso viajes entender 00:28:09
sí 00:28:33
Entonces, aquí en este caso concreto, ¿cuál imprimiría? ¿El if, o sea, el then o el else? 00:28:33
En este caso diría 00:29:03
¿Esta es verdadera? 00:29:05
Entonces ejecuto el bloque else 00:29:07
Si este es verdadero 00:29:10
O sea que aquí pongo cuatro 00:29:12
Entonces elijo el primer bloque 00:29:14
El bloque then normalmente 00:29:18
Y me salto el bloque else 00:29:20
¿Sí? 00:29:22
Ten en cuenta que en lenguajes más viejos 00:29:24
Como cuando yo era joven 00:29:27
El if else se llamaba if then else 00:29:28
Si, entonces y si no 00:29:32
¿Vale? 00:29:35
Entonces había la rama de 00:29:36
La rama entonces, si esto es verdadero 00:29:37
Entonces hace esto 00:29:41
Y si no, hace este otro 00:29:42
¿Vale? Entonces, este de aquí, la primera rama 00:29:44
La rama verdadera, la otra falsa 00:29:47
Llamando a la computadora 00:29:48
Sí 00:29:49
Claro, pero hay un de, después del de 00:29:50
Sino porque la primera 00:29:52
El primero pone el de 00:29:57
Perro, y pasa el perro también 00:30:02
Independientemente de lo que vaya a ir 00:30:04
esto porque yo he hecho un programa 00:30:06
que tiene sentido 00:30:09
entonces, si es mayor que 5 00:30:10
si es menor que 5, te pone que es menor que 5 00:30:13
y si no es menor que 5, es mayor 00:30:15
igual, un programa que tiene sentido 00:30:17
pero nadie te prohíbe decir aquí 00:30:19
cocodrilo es aquí perro 00:30:21
o aquí hacen una suma 00:30:23
y aquí hacen una resta 00:30:25
el número que te ha dado es menor que 5 00:30:27
lo sumarás y si es mayor que 5 lo restas 00:30:29
¿por qué? no lo sé, eso depende 00:30:31
de tu ejercicio, de por qué estás 00:30:33
haciendo eso. ¿Eh? ¿Dulas? ¿Entiendes? Tened en cuenta que si habéis entendido el 00:30:35
terceternario, que no es lo mismo, pero os facilita mucho entender esto. Es la misma 00:30:46
cosa, ¿vale? Pero, sobre todo la parte de logia booleana, pues entonces esto, esto sería 00:30:52
Que bonito, ocultároslo, ocultároslo. Allí, allí lo veis, ¿eh? Ahora que, ahora que en Egipto, lo tenéis para bajar, que lo veis, pero que, mirad. 00:30:59
Este que hay, ¿eh? ¡Ah! Se sigue viendo, se sigue viendo. 00:31:11
Para que razonéis, es lo de siempre, en el momento que sabéis la solución, os hacen un acertijo. 00:31:27
y mientras nos dice la solución, vosotros estáis pensando en él, en cuanto os dice, ah si era así, es verdad, pues ya está, se ha acabado el juego, entonces ¿qué sale aquí? 00:31:32
¿Qué sale aquí? 00:32:07
Entro aquí, digo, es menor que 5, 5, no, por lo tanto esta rama de aquí no, me voy 00:32:12
al else. 00:32:23
Fijaos que no hay un bloque, a mí me gustaría aquí un bloque que llegue hasta aquí, pero 00:32:24
él no lo ha puesto. 00:32:30
Pero este else, entonces, empieza y se aplica solo al siguiente comando, que es todo este if, ¿vale? 00:32:32
Excepto el último fin, ¿eh? 00:32:40
Entonces, y este de aquí es otro if, donde me dice, vale, seguramente no es menor que 5, porque si no, no estaría aquí, ¿vale? 00:32:42
Pero, ¿cómo? ¿Puede ser igual o mayor? Me pregunto, ¿es exactamente igual a 5? 00:32:50
Y si es verdad, ejecuto eso. Y como es verdad, ejecuto este de aquí. 00:32:56
y me salto el elche morado, que es el if, ¿vale? 00:33:00
El primer if es el azul con el elche azul, 00:33:09
el segundo if es dentro del elche azul y pone if-elche. 00:33:13
¿Sí? 00:33:18
Entonces la solución en este caso es igual a 5. 00:33:21
¿Aquí? 00:33:31
¡Qué bonito así! 00:33:35
Como mismo se entiende mejor. 00:33:38
Y yo lo entiendo mucho mejor así. 00:33:41
Pero es un gasto inútil de paréntesis, pero son gratis. 00:33:43
Eso es a lo que se llamaría indentado. 00:33:49
Indentado es cuando escribes lo que está dentro de un bloque un poquito más a la derecha. 00:33:52
Esto sería, a lo mejor lo que quieras decir tú es anidado. 00:34:02
Eso. 00:34:06
Que es un if dentro de un if. 00:34:07
Esto es un if anitado y luego lo he indentado en el sentido que lo he movido así. 00:34:09
Pero esto lo podría escribir en una línea y funciona. 00:34:13
Entonces, mismo que antes, ¿vale? 00:34:19
Si es este de aquí, entonces hace esto. 00:34:22
Si no, entra aquí dentro y aquí te encontrarás otro if. 00:34:26
Miras el if o lo que sea y lo doblas. 00:34:31
¿Sí? 00:34:34
Debería escribir lo mismo que antes. 00:34:34
¿Sí? 00:34:41
¿Y esto? 00:34:48
el problema de este ejercicio 00:35:35
¿cuál es? 00:35:40
esto ya va a ser en falda 00:35:46
pero el problema serio 00:35:49
aquí es 00:35:55
este else 00:35:56
¿de quién es? 00:35:58
¿de quién todo esto? 00:36:03
¿lo podría ser? 00:36:04
Si esto es así, hace este GIF a secas, y si no, hace esto. 00:36:05
Tendría que tener un ELSE primero para eso, ¿no? 00:36:10
Aquí, el ELSE de primera vez. 00:36:12
Pon un coche de aquí, un coche de aquí. 00:36:15
Un llave. 00:36:18
Llave aquí y llave aquí. 00:36:18
¿Está? 00:36:20
Pero si la llave la pones aquí, aquí, aquí, aquí, y luego de aquí a aquí, 00:36:22
pues entonces es otra cosa. 00:36:27
Es lo de siempre con... 00:36:31
¿Os acordáis la precedencia de operadores? 00:36:32
Es lo del mismo. 00:36:36
Si tú sabes cómo funciona Java por dentro, ¿vale? 00:36:37
Y lo sabes bien y te acuerdas todas estas regletas una tras de otra y te las grabas, 00:36:41
entonces si ves así sabes perfectamente que va a salir ahí. 00:36:47
¿Sí? 00:36:51
Si eres como yo, que no me acuerdo mi nombre por la mañana, ¿vale? 00:36:53
Entonces tienes que encontrar otras estrategias, como por ejemplo, poner las paréntesis bien. 00:36:58
si aquí pones las llaves 00:37:03
no tiene, no hace 00:37:06
falta recordarse si Java 00:37:07
este else se lo da al primer if o al segundo if 00:37:09
porque funciona 00:37:11
ya, si yo la paréntesis 00:37:13
la pongo de aquí a aquí 00:37:16
o sea, después del 00:37:17
i mayor que 1 y al final 00:37:19
pues estoy diciendo que este es un if 00:37:21
a secas sin else y si 00:37:23
se ejecuta, entonces se ejecuta todo lo que sale 00:37:25
si en vez de las paréntesis 00:37:27
las pongo 00:37:30
a ver, de aquí 00:37:31
aquí, o mejor de aquí a aquí. Si cambio los paréntesis de otro lado ahora debería trabajar porque no me da la cabeza. 00:37:33
Entonces puedo hacer que este else sea del otro. Si la pongo aquí, aquí al fondo, antes del 00:37:42
segundo if y después del igual a uno, entonces este else es de este if. 00:37:48
Teniendo las llaves correctamente puedo hacer que este else sea de uno o de otro. Por eso os 00:37:56
invito que siempre dice es y condición bloque el se bloque siempre es una 00:38:02
estructura básica se puede hacer sin sí pero lleva antes o después o no lleva 00:38:10
caos en mi modesta 00:38:16
Por pantalla no saldría nada 00:38:21
Ya que la sentencia IF tiene dos formas 00:38:32
IF e IFELS 00:38:35
Y cuando se metan ambas 00:38:36
No se puede saber a cuál 00:38:38
Probablemente 00:38:39
Ni siquiera se da error 00:38:43
Pero 00:38:45
Evitarlo, ¿vale? 00:38:46
Regla clara 00:38:49
y básica 00:38:50
si una cosa que escribís 00:38:52
es ambigua 00:38:54
desambiguadla 00:38:55
si lo que vais a hacer allí puede tener 00:38:57
dos interpretaciones 00:39:00
7 más 5 por 4 menos 2 00:39:02
por 62 dividido 4 00:39:05
¿en qué orden se ejecuta? 00:39:06
pues ponéis paréntesis 00:39:08
y sabéis en qué orden se ejecuta 00:39:10
y ponéis bloques 00:39:11
y sabéis en qué orden se ejecuta 00:39:15
no hagáis código ambiguo 00:39:16
Esto era el if. ¿Os ha gustado? Si os ha gustado el if, os encantará el switch case. 00:39:18
Pues es otra sentencia condicional que permite comparar una determinada variable con varios 00:39:31
valores posibles. Tened en cuenta que el if yo tengo que hacer, si if vale 1, hace esto. 00:39:37
Y si no, si vale 2, y si no vale 2, hace este otro. 00:39:43
Y si no, si vale 3, hace este otro. 00:39:48
Y si no, si vale 4, hace este otro. 00:39:50
Y cosas por el estilo, ¿vale? 00:39:53
Se queda un poquito engordoso. 00:39:54
Entonces, hay una forma de, si es lo que quiero hacer, o sea, una única variable, tengo x. 00:39:56
Y he hecho un menú. 00:40:01
Al principio del mitograma dice, soy una calculadora. 00:40:02
Si quieres sumar, pulsa 1. 00:40:08
Si quieres restar, pulsa 2. 00:40:10
Si quieres multiplicar, pulsa 3, ¿vale? 00:40:13
Y ahora he leído un número, que puede ser 1, 2 o 3, ¿vale? 00:40:16
Y me pongo en un switch case diciendo, si esta variable es 1, entonces pide dos números y suma. 00:40:21
Si esta variable es 2, pues pide dos números y réstalos. 00:40:28
Si esta variable es 3, pide dos números y multiplica. 00:40:32
¿Se entiende? 00:40:36
Para hacer esto, se usa un switch case. 00:40:38
dependiendo del valor de dicha variable 00:40:40
ejecutamos un bloque de código o no 00:40:42
pero hay varios bloques 00:40:44
se puede hacer lo mismo con varios if and 00:40:45
y dados, pero muchas veces el código 00:40:48
es más limpio si se usa el switch case 00:40:50
en este caso 00:40:52
el switch case se usa solo para 00:40:53
este caso, cuando hay una variable 00:40:56
y con muchos valores posibles 00:40:58
si no se utiliza, y esta maravilla 00:40:59
aquí 00:41:05
entonces tengo switch 00:41:06
la variable que voy a mirar 00:41:09
fijaos que aquí no es booleana 00:41:11
Es la variable. Y me dice, en el caso que valga un valor, ¿vale? Este val1 es un... ¿Mi respuesta favorita? Literal. ¿De qué tipo? 00:41:13
¿De qué tipo? Del tipo de variable. Si yo estoy haciendo una comparación entre enteros, pues variable será un int, y val1 será un int, val2 será un int. 00:41:29
si variable es un char 00:41:50
pues val1 será un char 00:41:53
val2 será un char 00:41:56
¿si? 00:41:57
se puede hacer constring 00:42:00
peligro constring 00:42:01
peligro constring 00:42:07
¿vale? 00:42:11
podéis probarlo, peligro constring 00:42:12
acordaos que string es malvado 00:42:14
hasta como objeto 00:42:17
es un objeto que pero se 00:42:18
porta como un tipo primitivo pero no 00:42:21
Springer más valor 00:42:23
No os quiere Springer 00:42:27
Parece amigo 00:42:28
Entonces 00:42:30
Si es el caso 1 00:42:32
Entonces 2 puntos 00:42:34
Haz esta cosa de aquí 00:42:36
Si vale 2 00:42:37
Haz esta cosa de aquí 00:42:40
Si vale n 00:42:41
Haz esta cosa de aquí 00:42:42
Y puedo poner todos los valores que me da la carne 00:42:43
Sería 00:42:45
Ese sentido de aquí 00:42:47
Si la variable vale valor 1 00:42:48
entonces haz las sentencias esta de aquí, ¿vale? 00:42:53
Y luego ya veremos qué pasa. 00:42:56
Si va a elevar el 2, esta de aquí. 00:42:58
Si va a elevar el 10, esta de aquí. 00:43:00
Cuidado con esta palabrita, break. 00:43:02
Break quiere decir interrumpe, rompe aquí. 00:43:05
Esto quiere decir, si llegas a un break, 00:43:08
saltas al final y sigues adelante. 00:43:11
Se ha acabado el switch case. 00:43:14
Si no pongo el break, 00:43:16
ejecuto la primera válida 00:43:19
y todas las sentencias 00:43:22
que haya después 00:43:24
hasta llegar a un break 00:43:25
¿entendéis? 00:43:27
es un poquito 00:43:33
raro 00:43:34
pero si yo me pongamos 00:43:36
que tengo aquí los valores 00:43:38
1, 2, 3, 4, 5, 6, 7, 8, 9, 10 00:43:39
y no tengo los breaks 00:43:41
si el valor que le he dado a x 00:43:44
a la variable es 2 00:43:46
me ejecutará los bloques del 2 00:43:47
del 3, del 4, del 5, del 6, del 7, del 8, del 9, del 10 00:43:50
desde donde entra hasta el final 00:43:53
si le pongo break 00:43:56
si por ejemplo pongo break al 7 00:43:59
pues lo que hace es ejecutar hasta el 7 00:44:00
y encuentra un break y sale 00:44:03
ahora hacemos un ejemplo 00:44:04
existe también 00:44:07
una opción 00:44:11
que es la opción default 00:44:12
que se mete al final 00:44:14
que quiere decir, si esta variable vale val 1 hace una cosa 00:44:15
si vale val 2 hace otra, si vale val 3 hace otra 00:44:18
y si al final 00:44:21
por defecto 00:44:22
Si no vale ninguno de los valores que te he dado antes, 00:44:24
esto es lo que tienes que hacer. 00:44:28
Como un si no. 00:44:31
Si vale esto, entonces. 00:44:32
Si vale esto, entonces. 00:44:33
Y si no, si no has encontrado lo que querías, esto. 00:44:34
Vale la misma cosa del break. 00:44:38
Si no pongo ningún break, se ejecutará esto también. 00:44:41
Ejemplo práctico. 00:44:49
dame una nota 00:44:50
y te la transformo en aprobado 00:44:53
bien, notable, sobresaliente, matriculador 00:44:55
o suspenso. 00:44:57
¿Sí? Entonces, tú me das una nota. 00:44:59
Si es 00:45:03
5, me dice aprobado. 00:45:03
Y sale. 00:45:07
Si es 6, 00:45:10
me dice bien. 00:45:11
Y sale. 00:45:13
Si es 7 00:45:15
y si es 8, 00:45:16
aquí el break no está. 00:45:18
entonces, si yo le he puesto un set 00:45:19
entraría aquí, no hace nada pero 00:45:21
luego ejecuta las de abajo, por lo tanto ejecutaría 00:45:23
también la del 8, déjame acabar 00:45:26
escribiría 00:45:27
notable 00:45:30
y luego pillaría el break y saldría 00:45:30
en este caso 7 y 8 00:45:33
te dan notable 00:45:35
9, sobresaliente 00:45:36
y sale, 10, matrícula honor 00:45:39
sale y en cualquier 00:45:41
otro caso 00:45:43
me escribiría el suspenso que sería del 00:45:44
1 al 5 00:45:47
porque no es un booleano es un valor es un literal 7 y 8 sería un bull y bull no puede 00:45:48
estar dentro de nosotros entonces no me vale como literal para poner ahí esto es en el caso 00:46:08
que sea 5 hace esto, en el caso que sea 6 hace esto, en el caso que sea TRUE o FALSE. 00:46:14
Además 5 and 6 no es nada valga la pena porque el AND como operador booleano va bool y bool, 00:46:22
no int bool, int int. Puedes hacer 5 and 7, no es nada, puedes poner 5 mayor que 7 and 00:46:29
Siete mayor que nueve. Eso sí, porque son bulle-bulle, que haces un E. 00:46:37
¿Sí? ¿Dudas? ¿Parece correcto? 00:46:42
¿Se entiende? No es complejo, pero es la primera vez que lo veis. 00:46:51
Entonces, en este caso de aquí, lo que hay que hacer es siempre gestionar bien dónde 00:46:59
¿Dónde poner el break, dónde no ponerlo? 00:47:04
¿Sí? 00:47:08
¿Y ahí no? 00:47:08
¿A qué? 00:47:13
Pues te daría suspecho. 00:47:17
El problema es tú. 00:47:20
No hay ninguno de estos valores, 00:47:21
entonces te daría suspecho. 00:47:23
Pero es que tú has permitido que alguien 00:47:24
te pusiera el once. 00:47:27
¿Vale? A lo mejor todo esto 00:47:29
lo puedes poner dentro de un if 00:47:31
que si la nota 00:47:33
es mayor que cero y 00:47:35
menor que diez, 00:47:37
o menor o igual que 10, entonces hazme esto, entonces ya se te da 11, y en el else le pones la nota no es válida. 00:47:38
Póngase que estoy comparando 1, 6, 5, porque yo quiero comparar que nota vale 5, no habría que poner nota igual a 5. 00:47:47
No, porque tú estás haciendo un switch case sobre nota, entonces esta suma que si nota, en el caso en que nota valga 5, 00:47:58
En el caso en que nota valga 6, ¿en qué se está haciendo de manera...? 00:48:06
Un igual igual. 00:48:11
La pregunta seria podría ser, ¿es un igual igual o un punto igual? 00:48:15
Y allí habría que ver, por ahora y por primitivo. 00:48:20
La prueba que todos estáis ansiosos de hacer, 00:48:24
si pongo aquí un string y luego aquí pongo strings, 00:48:30
¿me funciona o no? 00:48:34
yo no os voy a decir 00:48:39
si funciona o no 00:48:41
yo os voy a dejar que sea 00:48:42
vuestra curiosidad y vuestra habilidad de programadores 00:48:44
que hagáis un ejemplo 00:48:46
y que lo probéis 00:48:48
y luego os lo pongo en ex 00:48:49
¡Ejercicios! 00:48:52
¡Otro 60 papás de! 00:48:59
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
12
Fecha:
15 de octubre de 2025 - 10:54
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
49′ 05″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
411.84 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid