Saltar navegación

Estructuras de control 1: condicionales - 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 7 de octubre de 2026 por Stefano C.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, voy a grabar esta clase, por lo tanto, si habláis, me dais vuestra autorización a grabar vuestra voz. 00:00:00
Entonces, nosotros hasta ahora hemos visto principalmente expresiones y tipos de datos. 00:00:08
A este momento, a hoy, a 7 de octubre de 2026, deberíais tener claro la diferencia entre tipos y cómo se declara una variable y qué tipos de operadores hay. 00:00:17
Esta es la base que hemos visto hasta ahora y con eso hemos hecho algunos ejemplos. 00:00:34
Hemos hecho ejercicios que han usado la suma, la resta, el módulo, hemos usado el operador ternario para ver sobre todo la parte booleana. 00:00:40
Entonces hemos visto convicciones con el AND, con el OR, con el NOT, con el mayor, menor, comparación, igual, igual, not igual, etc. 00:00:49
etcétera. En este momento vosotros deberíais saber estas cosas de aquí y cómo se utilizan. 00:01:01
Cómo declarar una variable, qué quiere decir declarar una variable, qué diferencia hay entre 00:01:08
declarar una variable y asignar una variable, qué son los tipos de datos, cuáles son los tipos de 00:01:13
datos compatibles, cómo puede hacer un casting o sea una conversión desde un tipo a otro, 00:01:18
cuáles son las conversiones automáticas, cuáles son las conversiones en vez que tengo que hacer 00:01:23
explícitamente y cuáles son las conversiones que no puedo hacer esto es lo que hemos estado 00:01:28
trabajando la última semana un poco más de las últimas vale cuando nosotros hemos utilizado 00:01:34
un ternario vale que es el operador ternario existe porque valdrá la expresión que hay esto 00:01:45
Es un operador, no un booleano, no necesariamente, pero ¿todo esto de aquí qué es en una palabra? 00:02:04
No. 00:02:14
¿Con disquete? 00:02:15
No. 00:02:16
¿Lo mismo que esto? 00:02:17
¿O esto? 00:02:20
No, no. 00:02:21
Bueno, no. 00:02:22
¿Qué son esto? 00:02:23
¿Qué son esto? 00:02:24
¿Qué son esto? 00:02:26
¿Qué son esto? 00:02:27
¿Qué son esto? 00:02:28
Bueno, no. 00:02:29
¿Qué son esto? 00:02:31
Expresiones. 00:02:41
Este señor de aquí es una expresión. 00:02:43
¿Vale? En concreto es un 00:02:45
operador, es un operador 00:02:47
externario, pero, sustancialmente, 00:02:49
esto es una expresión. 00:02:51
Esto... 00:02:53
¿Qué tipo tiene? 00:02:55
Tres más cinco, ¿qué tipo tiene? 00:03:00
¿Vale? 00:03:02
T más cinco, ¿qué tipo tiene? 00:03:04
¿Qué es? El tipo de C. 00:03:11
Si C es un string, esto sería un string. 00:03:19
Si C es un int, sería un int. 00:03:21
Si C es un double, eso es un double. 00:03:23
Entonces, muy probablemente tiene el tipo de C. 00:03:26
¿Cuál es? No lo sé. 00:03:29
No sé C, no lo he declarado, pues no lo sé. 00:03:30
¿Vale? Pero sé que es el tipo de C. 00:03:33
¿Qué tipo tiene esto? 00:03:35
Entonces, tiene el tipo de la expresión que está aquí. 00:03:45
Tipo T. 00:03:59
si esa es una string 00:03:59
pues todo esto se evaluará 00:04:04
un string, si esto es un int 00:04:06
pues todo esto se evaluará 00:04:08
un int 00:04:10
¿está claro? 00:04:10
¿y esto qué tipo tiene? 00:04:13
tiene que tener el mismo tipo 00:04:20
no puede tener otro tipo 00:04:22
si lo habéis probado 00:04:23
si esto es verdadero devuelve un string 00:04:25
si esto es falso devuelve un int 00:04:28
se enfada, te dice no 00:04:30
estas dos ramas tienen que tener 00:04:31
expresiones distintas 00:04:34
pero con el mismo tipo 00:04:37
que cuando se evalúen estas expresiones 00:04:38
obtengan el mismo tipo 00:04:41
sea igual sea ese tipo 00:04:42
si has metido string a un lado, pues el otro tiene que ser string 00:04:43
si has metido un int a un lado, el otro tiene que ser un int 00:04:46
si has metido double a un lado, el otro a un lado 00:04:49
si has metido scanner a un lado 00:04:50
el otro tiene que ser un scanner también 00:04:53
¿sí? 00:04:54
¿qué tipo tiene esto? 00:04:57
aquí, ¿qué va? 00:05:14
¿Qué tipo tiene? 00:05:15
Es una expresión 00:05:26
de tipo booleano 00:05:27
¿Se entiende esto? 00:05:29
Esta es una expresión 00:05:38
de tipo T 00:05:39
y esta es una expresión 00:05:41
de tipo T 00:05:43
Lo que quiero que quede claro 00:05:44
porque luego es la diferencia con el 00:05:47
hizo que veremos en breve 00:05:49
es que aquí y aquí va una expresión. 00:05:50
¿Entendéis qué es una expresión? 00:05:56
System.org.tln 00:06:01
Me gustan los gatos. 00:06:03
¿Es una expresión? 00:06:06
No. 00:06:09
Es un comando. 00:06:10
Es una instrucción. 00:06:12
No es una expresión. 00:06:15
¿Comillas me gustan los gatos? 00:06:17
¿Comillas es una expresión? 00:06:19
Sí. 00:06:23
es un literal de tipo string 00:06:23
y un literal es 00:06:27
una expresión 00:06:28
las expresiones son 00:06:29
cosas que tú puedes 00:06:32
evaluar y te dan un valor 00:06:34
si te digo system.auto.println 00:06:36
¿qué valor tiene? 00:06:39
no tiene valor 00:06:41
su gente tiene un valor 00:06:42
pero como lo hemos visto nosotros 00:06:45
no da un valor, hace una cosa 00:06:46
ejecuta una instrucción 00:06:48
hace un comando 00:06:51
Pilla la expresión que me has dado 00:06:52
Y la imprime en pantalla 00:06:55
Pero por sí mismo 00:06:57
No le puedo sumar 7 00:06:58
No puedo hacer system.auto.println 00:07:00
Algo más 7 00:07:03
No sé si me explico 00:07:04
Al system.out 00:07:06
No puedo operar con él 00:07:07
No puedo aplicar operadores 00:07:09
Al system.auto.println 00:07:12
Porque no es una expresión 00:07:13
Es un comando 00:07:15
Scan.nexint 00:07:16
Es una expresión. Bueno, dejamos. Porque devuelve un valor. Dejamos por ahí. Eso no funciona. 00:07:22
Estoy buscando, porque hemos hecho muy poco, otras cosas que podrían ser expresión. 00:07:36
Si yo te digo int c es igual a 7, esta es una expresión. Esto. Int x es igual a c más 7. Esta es una expresión. 00:07:43
No, es un coma, un coma de asignación. 00:08:01
Esta es una expresión, ¿sí? 00:08:09
Esta la puede evaluar a un valor. 00:08:12
No sé cuánto vale c, si el p vale 5, pues 5 más 7, 12, 00:08:14
pues esto vale 12 y es un entero. 00:08:18
Sí lo puede hacer. 00:08:20
Pero si te digo, ¿y cuánto vale esto? 00:08:21
No lo sé. 00:08:23
Esto hasta lo podría pensar, decir, mira, x sí, x así, 00:08:26
es una expresión, pero aquí yo estoy haciendo una declaración, en otros son muy tristes, ¿vale? 00:08:31
Es, tenéis que entender la diferencia entre las instrucciones y comandos, que son lo que hacen 00:08:36
hacer algo en mi programa, ¿vale? Que construirán pasito a pasito el algoritmo, y las expresiones, 00:08:43
que son los valores, a lo mejor complejos, porque yo para sacar el valor no es sólo siete, 00:08:51
el tema es, pilla la edad, multiplícala para dos y divídala para el número de árboles de... 00:08:57
¿Para qué sirve? No lo sé. ¿Vale? Pero es una operación grande, pero es una expresión que luego se evaluará a un valor concreto. 00:09:04
¿Entendéis la diferencia? ¿Dudas? 00:09:13
Bueno, la diferencia fundamental entre el operador ternario, que es este de aquí, y el if, es que yo aquí, en el operador ternario, no puedo poner comandos. 00:09:18
En el operador ternario, allí van expresiones. 00:09:32
Sin embargo, en el if, van comandos. 00:09:36
Yo puedo, en el if, en esta rama de aquí, en esta rama de aquí, poner un programa entero. 00:09:41
Es decir, si tú me tecleas 1 00:09:48
Entonces esta cosa aquí 00:09:51
X es 1 00:09:53
Pues entonces calcula la área del triángulo 00:09:54
Y si X es 2 00:09:57
Pues entonces abre un programa 00:09:59
Para escribir el Quijote 00:10:01
Dos cosas completamente distintas 00:10:02
Que no tienen que ver con tipos distintos 00:10:05
Y que hacen cosas distintas 00:10:07
Dos algoritmos, dos programas completamente distintos 00:10:08
Eso con un IFA lo puede hacer 00:10:11
Con un 00:10:13
Operador ternario 00:10:14
en un if aquí 00:10:17
yo puedo tener 25 líneas 00:10:20
de código 00:10:23
aquí siempre tendré 00:10:23
una expresión 00:10:27
no puedo tener 6 expresiones ahí 00:10:28
no puedo poner un system.out 00:10:30
aquí dentro 00:10:33
porque esto es un valor 00:10:35
no una operación 00:10:39
no le puedo decir si 3 es mayor que 4 00:10:41
entonces escribe algo 00:10:43
no lo hemos hecho nunca 00:10:45
nosotros hemos dicho escribe 00:10:46
y luego nos hemos preguntado, hemos dicho, 00:10:48
si es mayor que 4, entonces escribe 7. 00:10:51
Y si no escribe 9, le damos el valor que tiene que escribir. 00:10:53
Pero no le hemos dicho nunca, 00:10:56
si esto es verdadero, entonces escribe, 00:10:58
y si no, no escribe, por ejemplo. 00:11:01
Eso no lo hemos dicho nunca. 00:11:04
Porque no lo podemos hacer. 00:11:05
Porque es una expresión, no es un comando. 00:11:06
¿Dudas hasta aquí? 00:11:11
Vale. 00:11:13
Esto es como previo para... 00:11:14
Nosotros conocemos esto, no conocemos el otro. 00:11:15
pues esta es la diferencia 00:11:17
de por qué necesitamos el otro 00:11:19
y no podemos seguir con este de aquí 00:11:22
porque este es un poquito menos potente 00:11:24
esto es un operador 00:11:26
y el otro es un comando 00:11:27
es una sentencia 00:11:29
¿vale? 00:11:30
entonces 00:11:33
hoy lo que vamos a ver 00:11:33
como nuevo elemento 00:11:35
son las estructuras de control 00:11:37
¿vale? 00:11:40
hasta ahora 00:11:41
nuestros programas 00:11:42
han sido secuencias de instrucciones 00:11:44
Yo empezaba desde el principio y seguía instrucción por instrucción hasta el final. En ningún momento he cambiado el flujo de ejecución de mi programa. 00:11:46
He siempre estado desde la primera línea hasta la última. 00:12:02
La cosa un poquito más compleja que quizá he hecho ha sido el ternario, ¿vale? 00:12:06
Porque o hacía una cosa o hacía otra, pero era siempre ese comando. 00:12:14
Yo ejecutaba esa línea de código, ¿vale? 00:12:19
Y en esa línea de código hacía una cosa u otra dependiendo del valor que salía de ese ternario. 00:12:22
Las estructuras de control son estructuras avanzadas para poder alterar, para poder cambiar el flujo de ejecución de mi programa. 00:12:27
Es decir, que ahora en vez de decir que ejecuto todas las instrucciones desde la primera hasta la última, puede ser que en un determinado momento haga cambios en el orden con el que se ejecutan estas instrucciones. 00:12:42
Cuidado, en cada momento el ordenador tiene que estar seguro al 100% de cuál es el comando que se va a ejecutar en ese momento. 00:12:56
Seguimos en un estado determinista. 00:13:08
No puedo decirle al ordenador, mira, si crees ejecuta esta operación y si no ejecuta otra, siéntetelo tú. 00:13:11
Pues no, eso no existe. 00:13:22
Tú al ordenador le tienes siempre que decir, haz esto, haz esto, haz esto, haz esto. 00:13:24
¿Vale? 00:13:28
Pero no en el orden que hemos visto hasta ahora. 00:13:29
No desde el principio hasta el final, todas una seguida a otra. 00:13:32
¿Vale? 00:13:35
Puedo alterar este flujo de ejecución. 00:13:36
¿Vale? 00:13:41
Estudio de control, son elementos del lenguaje que nos permiten romper con el flujo lógico de ejecución de instrucciones. 00:13:41
¿Vale? 00:13:47
O sea, las entiendes. 00:13:48
se domina flujo de ejecución 00:13:48
el orden en el que se ejecutan 00:13:52
un determinado conjunto de instrucciones 00:13:54
o sentencias, hasta ahora nosotros 00:13:56
hemos usado un orden secuencial 00:13:58
¿vale? la secuencia 00:14:00
de instrucciones es una 00:14:02
estructura de control ¿vale? 00:14:04
pero es la más válida, es 00:14:06
he dado una lista, pues va desde la primera 00:14:07
hasta la última, hace esta operación 00:14:10
este comando, luego este comando, este comando 00:14:11
este comando, este comando, ya está 00:14:14
lo hemos utilizado, pero es 00:14:15
digamos, el más natural. Hago las cosas 00:14:17
en orden. Se acabó. 00:14:20
El flujo lógico, es decir, 00:14:22
que se asume, mientras 00:14:24
no sería lo contrario, es de arriba 00:14:25
abajo, de izquierda a la derecha. 00:14:28
Si yo no digo nada y no 00:14:30
le digo modifica el flujo, es 00:14:32
empiezo desde el primer 00:14:34
comando y voy hacia abajo. 00:14:35
Y en el comando, si hubiese 00:14:38
dos comandos en la misma línea, 00:14:39
separado por punto y coma, haría primero el 00:14:42
que está a la izquierda, luego el que está a la derecha. 00:14:43
¿Sí? Como se lee. 00:14:46
Porque existen distintos tipos de sentencias de control. 00:14:47
Por un lado están los condicionales, por otro lado están los iterativos y por último están las llamadas a métodos. 00:14:55
Estos son tres grupos de estructuras que lo que hacen es modificar el flujo con el que van, el orden de ejecución. 00:15:03
¿Se entiende eso? ¿Repetido ya cinco veces? ¿Os ha ocurrido lo suficiente? 00:15:14
Los condicionales. Los condicionales me permiten elegir si un bloque lo ejecuto o no. 00:15:20
Yo marcaré un bloque y le diré que si una condición es verdadera, entonces ejecútalo y si no, no. 00:15:29
Eso es el ir más básico. Te marco un bloque y te digo, esto se ejecuta solo si la condición es verdadera. 00:15:36
Si lo salto, estoy modificando 00:15:43
El flujo de ejecución 00:15:48
Porque yo he ejecutado los primeros comandos 00:15:51
Llego a este if, este if es falso 00:15:54
Me salto todos estos comandos que están dentro del bloque 00:15:56
Y sigo con los otros 00:15:59
He modificado, ya no estoy haciendo uno tras otro 00:16:00
He hecho un salto, por eso está modificado 00:16:03
Luego el if tiene versión if-else 00:16:06
¿Vale? Ahora veremos qué es. Si esto es verdadero, haz este bloque. Si es falso, sáltate este bloque, pero ejecuta este otro. 00:16:11
O sea, entonces me permite un vídeo, una... no sé, una... una elección, ¿vale? Gráficamente. 00:16:21
si yo llego desde una 00:16:34
estructura 00:16:36
si yo llego aquí 00:16:37
estoy ejecutando, estoy ejecutando 00:16:40
cuando llega un if 00:16:42
vale, si es un if 00:16:43
a secas normal, me dice 00:16:47
que si es verdadero 00:16:49
ejecuta 00:16:53
estas instrucciones de aquí, vale 00:16:54
y luego sigues adelante, si no 00:16:56
lo que hace es 00:16:58
saltarte estas instrucciones 00:17:00
y retomar de aquí 00:17:02
Esto sería el if básico, ¿sí? 00:17:04
En vez, el if else sería que cuando llega la información del if, aquí hay una condición, si es sí, elige esta vía de aquí y hace estas instrucciones, si es no, hace estas instrucciones de aquí y luego sigues adelante, ¿sí? 00:17:08
el if básico normal 00:17:29
estándar, lo que me dice es 00:17:32
ejecuto este bloque 00:17:34
si es verdadero y si no me lo salto 00:17:35
no hago nada más, salto 00:17:38
solo este bloque, lo salto 00:17:40
no lo ejecuto, mientras 00:17:41
el if else me dice si es verdadero 00:17:43
hago así, si no es verdadero hago así 00:17:46
esto es parecido 00:17:48
al ternario 00:17:50
la diferencia es que en el 00:17:51
ternario aquí tenía expresiones 00:17:54
sin embargo 00:17:56
aquí ahora tengo comandos, tengo bloques de comandos. Tengo un bloque que abre aquí y que 00:17:58
cierra aquí y todo lo que se hace aquí se ejecuta sólo si esta condición que he puesto aquí es 00:18:04
verdadera. ¿Entiendes? El switch es una cosa que nos habría servido en algunos ejercicios que hemos 00:18:10
hecho, que es sustancialmente igual al conditional, igual al if, ¿vale? Todo lo que se hace con el 00:18:23
solo que en determinados casos esta es una sintaxis más cómoda cuando cuando yo tengo 00:18:29
un valor una variable y tengo que comprobar si esta variable tiene algunos valores concretos 00:18:41
vale imaginaos un menú típicamente en el que te dice que quieres hacer quieres sumar entonces 00:18:47
pulsa 1, restar, pulsa 2, dividir, pulsa 3 00:18:54
o multiplicar, pulsa 4. ¿Vale? Entonces, si ahora debería 00:18:58
hacer, si lo que has puesto es 1, hace esto. Si lo que has puesto 00:19:01
2, es este. Pues el switch me lo hace más sencillo. Me dice, a ver, mira, 00:19:06
comprueba X. Cuando es 1, hace esto. Cuando es 2, hace esto. Cuando es 3, 00:19:09
hace esto. ¿Vale? Sale más fácil de ver. Pero, 00:19:14
sustancialmente, los dos hacen lo mismo. Cambian el 00:19:17
flujo de ejecución de los comandos 00:19:21
en base a una condición. 00:19:23
Me dicen cuál bloque 00:19:25
ejecutar o si ejecutarlo 00:19:27
o no, en base a 00:19:29
una 00:19:31
condición. 00:19:32
Evalúo la condición. 00:19:36
La condición será una expresión 00:19:38
booleana. Me dará true o false. 00:19:39
En base a true o false, hago o no 00:19:41
hago una determinada. 00:19:43
¿Sí? Esta es la condición. 00:19:46
¿Dudas? 00:19:48
Luego están los iterativos. 00:19:51
Los iterativos me permiten repetir muchas veces un mismo bloque de código. 00:19:52
Entonces, llego al final del bloque de código y cuando llego al final puedo decidir de volver a saltar al principio de este bloque de código. 00:20:00
Entonces estoy alterando otra vez el flujo de ejecución porque normalmente seguiría abajo. 00:20:09
En vez de en determinado momento podría saltar arriba y ejecutarlo otra vez y volver a saltar arriba y ejecutarlo otra vez. 00:20:15
¿Vale? Aquí normalmente hay dos interesantes, también el do while, pero es una versión del while. 00:20:22
El while es que mientras una condición es verdadera, tú sigues ejecutando lo mismo, ¿vale? 00:20:30
Mientras x sea positivo, pues haz x menos menos. 00:20:39
Entonces, en cada ciclo, pues lo que estoy haciendo es reducir x un poquito, un poquito, un poquito, 00:20:43
mientras que x sea positivo. Si x vale mil, lo haré mil veces. 00:20:48
Si x vale 3, pues lo haré 3 veces. 00:20:52
Pero estoy allí, dando vueltas, mientras que x sea positivo. 00:20:55
El for, en vez de me sirve para decir unos límites, ¿vale? 00:21:00
Normalmente digo desde 0 hasta 5. 00:21:05
Pues, entonces, este bloque se repitirá 5 veces. 00:21:08
Tienen algo de diferencia entre los dos, 00:21:14
pero cambiando un poquito como se escribe, 00:21:17
lo que hace un while se puede hacer con un for 00:21:20
y lo que hace un for se puede hacer con un while 00:21:23
¿vale? son 00:21:25
más cómodos en determinados 00:21:26
contextos, entonces veremos 00:21:29
que a veces usamos el while, a veces usamos 00:21:31
el for en base a algunas reglitas 00:21:33
que nos daremos, pero 00:21:35
en teoría el concepto es que hacen 00:21:37
la iteratividad, o sea la posibilidad 00:21:39
de repetir más de una vez 00:21:41
un mismo bloque de código 00:21:43
¿sí? 00:21:44
y finalmente las llamadas a métodos 00:21:47
O sea, yo puedo pillar un trozo de código, darle un nombre y ponerlo en algún lado. 00:21:49
Y ahora en otro trozo de código, en mi main, para ejecutar ese trozo de código que le he dado un nombre, puedo llamar ese nombre. 00:21:58
Entonces, cada vez que yo en mi código, que estoy yendo desde arriba abajo ordenadamente, 00:22:07
encuentro este nombre con el que he llamado el bloque de código que he guardado por otro lado, 00:22:13
salto desde donde estoy 00:22:18
a ese bloque de código 00:22:21
ejecuto ese bloque de código 00:22:23
y vuelvo a donde estaba 00:22:25
y sigo con la siguiente 00:22:27
entonces hago saltos 00:22:28
hacia funciones, hacia trozos de código 00:22:30
que están en otro lado 00:22:33
por ejemplo 00:22:34
el scan 00:22:35
por ejemplo 00:22:48
yo tengo mi programa 00:22:49
se ejecuta aquí 00:22:52
las varias ejecuciones 00:22:54
bla bla bla 00:22:57
De repente me encuentro 00:22:57
un system.auto.println 00:22:59
¿Qué es este println? 00:23:01
Eso es un método, es una función. 00:23:07
Es decir, que es un trozo de código 00:23:09
escrito por otra persona 00:23:11
en algún lado del multiverso 00:23:13
¿Qué es esto? 00:23:15
println 00:23:18
que hace cosas 00:23:18
¿Vale? Aquí estará su if 00:23:20
su while, su retorno 00:23:23
lo que sea. Es un código que no he 00:23:25
escrito yo y que alguien ha llamado 00:23:27
como println. Cuando 00:23:29
Cuando yo aquí me encuentro un system.auto.println, lo que estoy diciendo es, para aquí la ejecución, 00:23:31
vete aquí, ejecuta este código y cuando has acabado, vuelve aquí y sigues con la 00:23:39
siguiente. 00:23:46
Entonces estoy interrumpiendo otra vez el normal flujo de ejecución de este programa. 00:23:51
Este sería uno tras otro, pero cuando llego aquí hago un salto al println que a lo mejor 00:23:57
Ahora aquí dentro tiene if, tiene while, hasta aquí un 15 minutos haciendo cosas. 00:24:02
Cuando ha acabado esta llamada de método, esta llamada de función, esta llamada de procedura, 00:24:07
llamada como os da la gana, vuelve a quien lo ha llamado, a la línea donde se había llamado, 00:24:12
y empieza por la línea siguiente. 00:24:17
Si vuelvo a hacer otro println, desde aquí saltaré otra vez aquí, lo re-ejecuto, 00:24:20
y cuando acabo vuelvo aquí. 00:24:27
Esa es una llamada de método. 00:24:31
Yo puedo crear mis métodos, ¿vale? Puedo darle, por ejemplo, cuando hemos hecho calcular ala del triángulo, calcular ala del cuadrado, pues podría llamar esos trocitos de código con un nombre, con un nombre de función y tenerlos a un lado y reutilizarlo todas las veces que yo quiera. 00:24:32
¿Se entiende más o menos? 00:24:51
Entonces, no los damos por vistos, ¿vale? 00:24:55
Estos de aquí todavía tenemos que trabajar con ellos. 00:24:59
Hoy empezaremos con estos de aquí. 00:25:01
Pero lo que me interesa es que tú, como sentencias de control, 00:25:03
tienes tres formas de alterar la ejecución básica secuencial de mi programa. 00:25:08
O decidiendo si hacer una cosa o no. 00:25:15
segunda opción, repitiendo 00:25:17
un bloco de código una cierta 00:25:19
vez mientras una condición sea 00:25:21
verdadera, o 00:25:23
irte a otro lado, ejecutar 00:25:24
otro trozo de código que 00:25:27
tú has llamado de alguna forma, y luego volver. 00:25:29
¿Vale? 00:25:31
Nosotros hemos dado el punto, ¿no? 00:25:33
Hemos hecho scan.nextInt. 00:25:35
Pues era esta cosa. 00:25:37
O system.out.println. 00:25:41
Más esta cosa. ¿Vale? 00:25:44
Luego veremos qué son los métodos. 00:25:46
En el mundo de la 00:25:48
Programación orientada a objetos se suele llamar de métodos, estos son métodos, Java son métodos. 00:25:49
En el mundo de la programación estructurada normal, pues eso se suele llamar funciones si te devuelven 00:25:56
un valor o proceduras si no devuelven ningún valor. Nosotros los llamaremos métodos. Ahora, 00:26:06
Si tú tienes un lenguaje de programación 00:26:14
¿Qué hace? 00:26:17
Lo que hemos visto hasta ahora 00:26:18
O sea, declaración de variables 00:26:20
Ejecución, una tras otra, cosas por el estilo 00:26:21
Y tiene estas tres opciones 00:26:23
¿Vale? 00:26:28
O sea, tiene comandos para hacer condicionales 00:26:29
Iterativos y llamadas en método 00:26:31
Se llama Turing equivalente 00:26:32
O sea, que puede hacer todo 00:26:34
Lo que haga otro lenguaje de programación 00:26:37
Con las mismas cosas 00:26:40
¿Vale? 00:26:41
y sustancialmente es un 95% de lo que se puede hacer en programación. 00:26:42
Lo que se añade, la programación de unidad de objetos y cosas así, 00:26:48
es para que esto funcione de forma más eficiente 00:26:51
y pueda hacer programas y proyectos más grandes. 00:26:56
¿Vale? 00:27:01
Porque técnicamente todos los proyectos se podrían hacer con estos elementos de aquí, 00:27:01
saldría un infierno, pero se podría hacer. 00:27:05
¿Sí? 00:27:08
las programaciones orientadas a objetos 00:27:09
mejora la forma 00:27:11
con que se usan estas cosas y cómo se 00:27:13
estructura el código para que sea 00:27:15
más fácil utilizarlos en proyectos 00:27:17
complejos y sobre todo 00:27:19
reutilizarlos. No tener 00:27:21
cada vez que tener que 00:27:23
reimplementar las mismas funciones 00:27:25
si estas funciones ya las he implementado 00:27:27
anteriormente. Simplemente importo 00:27:29
las clases que necesito 00:27:31
y las uso. Como nosotros no 00:27:33
hemos tenido que implementar el system.org 00:27:35
lo hemos importado de forma nativa 00:27:37
en nuestros programas 00:27:41
y lo hemos utilizado 00:27:42
nosotros no sabemos como se escribe en pantalla 00:27:44
¿sabéis vosotros como se escribe en pantalla? 00:27:46
ni idea, usamos un printerln 00:27:48
que es un código complejo 00:27:50
que se hablará con el 00:27:51
con el driver 00:27:54
de la pantalla 00:27:57
por algún lado 00:27:58
y allí sacará la información 00:27:59
son cosas de bajo nivel 00:28:01
que nosotros hemos tapado 00:28:03
con un lenguaje de alto nivel 00:28:06
que nos permite hacer las cosas 00:28:08
sin tener que trastear con los 00:28:10
ceros y los unos o los drivers de la 00:28:12
pantalla. 00:28:14
¿Entiendes? 00:28:16
Exactamente, nosotros queremos poder 00:28:18
ser cómodos. 00:28:19
¿Tú das hasta aquí? 00:28:22
Entonces, 00:28:25
empezamos 00:28:28
con los condicionales, ¿vale? 00:28:29
Vamos a ver, lo que he dicho 00:28:31
ahora era todo lo que hay que saber. 00:28:33
¿Vale? Ya sabes, estamos listos, 00:28:35
para el examen, pero vamos a verlo un poquito más en detalle y luego hacemos ejemplo. 00:28:37
Entonces, los condicionales sirven para proporcionar distintos caminos lógicos de ejecución y 00:28:43
después continuar con el programa, ¿vale? Es decir, las estructuras que he dibujado 00:28:47
antes. Yo puedo pasar por este camino o por este otro en base a una condición y entonces 00:28:52
ejerceré o no una parte, una serie de comandos, si esta condición es verdadera o no, ¿vale? 00:28:58
se evaluará una condición 00:29:04
y en base al resultado se ejecutan 00:29:06
instrucciones u otras 00:29:08
este es el dibujito mejor hecho 00:29:10
por expectantes, vale 00:29:14
esto es en ifasecas 00:29:15
si esta condición es verdadera 00:29:18
entonces hay un bloque de código 00:29:20
ejecútalo y luego sigue con el programa 00:29:22
si la condición que he ponido aquí 00:29:24
es falsa, pues salta 00:29:26
de este bloque de código y sigue adelante 00:29:28
¿qué irá en condición? 00:29:30
expresión 00:29:38
incompleta 00:29:39
¿Expresión? Boolean. Aquí tengo que poner una expresión compleja cuantos da la gana, pero el resultado tiene que ser true o false. En base a true o false, si es true, voy para aquí, si es false, voy para acá. 00:29:42
¿Qué tengo que poner aquí? 00:29:57
Lo que me da la gana 00:30:03
Es un bloque de código 00:30:04
Lo que necesito para resolver mi programa 00:30:06
¿Vale? 00:30:08
Pero aquí podría poner 00:30:09
Una secuencia de instrucciones 00:30:11
Podría poner otro is 00:30:12
Podría poner un while 00:30:14
Podría poner una llamada método 00:30:16
Podría llamar todos los anteriores juntos 00:30:18
Aquí haré lo que tengo que hacer 00:30:21
En base a la condición que me ha dicho 00:30:23
¿Ve? 00:30:25
Ahora, si en vez de 00:30:27
Esto es, sustancialmente me está preguntando, ¿este bloque lo ejecuto o no? 00:30:29
Si en vez de no tengo un bloque que tengo que ejecutar o no, 00:30:35
tengo que hacer cosas distintas en base de si es verdadero o falso la condición, 00:30:38
entonces tengo el IFELS. 00:30:44
El IFELS me dice que si es verdadero, esto es el bloque que tienes que ejecutar. 00:30:46
Si es falso, hay un bloque distinto. 00:30:51
Estos dos bloques son exclusivos. 00:30:54
O es que ejecuto uno, o ejecuto el otro. No puede ejecutar los dos, ¿ves? 00:30:57
Ejemplo del instrumento número uno. Int x es igual a 5, si x es menor que 5, 00:31:10
System.app.println es menor que 5. System.app.println es fin. 00:31:16
¿Qué me escribe esto? ¿Por qué por pantalla sale fin? 00:31:21
Porque yo te digo, x es menor que 5. 00:31:30
No. 00:31:37
¿Puede ser menor o igual? Sí. 00:31:39
Pero así es falso. 00:31:40
Esto sería el bloque true. 00:31:43
Me lo salto y voy al bloque este de aquí. 00:31:46
Pero esto no es el bloque else. 00:31:49
Esto se ejecuta siempre. 00:31:50
Si aquí le pongo 7, 00:31:52
si aquí le pongo 3, ¿qué me escribe? 00:31:54
Me pone menor que 5, fin. 00:31:59
Me pone los dos. 00:32:02
ahora normalmente 00:32:02
esto es un poquito 00:32:11
confuso porque me dicen 00:32:13
pero por qué ejecuta esto 00:32:15
esto no estaba 00:32:18
en el bloque 00:32:20
yo quiero que si esto es verdadero 00:32:21
escriba estas dos cosas y si es falso 00:32:24
no escriba nada 00:32:26
¿cómo lo hago? 00:32:27
tengo que marcar los bloques 00:32:29
y esto siempre 00:32:31
si yo no fijo aquí un bloque 00:32:32
el if solo se 00:32:35
se refiere al primer 00:32:36
comando que encuentra. Solo 00:32:39
un comando. Pero 00:32:41
normalmente, los 00:32:42
if pillan un bloque. 00:32:45
¿Os acordáis de los delimitadores que vimos 00:32:47
y decimos, pero no sirven de mucho? 00:32:48
Ahora empiezan a servir. 00:32:50
Entonces, si esto 00:32:53
es verdadero, ejecutas 00:32:55
todo este bloque. Si no, 00:32:57
te saltas este bloque y vas aquí directamente. 00:32:59
Entonces aquí, x es 5, 00:33:03
5 es menos que 6. 00:33:05
Sí. Por lo tanto, entro aquí dentro y escribo resultado dos puntos menor que seis y luego fin. 00:33:06
Y si yo pusiera X7, escribiría. 00:33:15
Solo fin. 00:33:23
Entro aquí, esto es falso, me salto todo este bloque, voy aquí y escribo este de aquí. 00:33:25
Esto está fuera del bloque, esto se ejecuta siempre. 00:33:30
Esto está aquí. 00:33:33
Mi fin está aquí. 00:33:36
Me he saltado el bloque de información y me he ido allí directamente. 00:33:38
¿Qué pasa si no pongo esta de aquí? 00:33:45
El mismo ejercicio, este de aquí, quito las paréntesis. 00:33:48
¿Qué me escribe? 00:33:52
Escribe menor que 6 y 5. 00:33:55
No, escribe exactamente lo mismo. 00:33:59
5 es menor que 6, entonces me escribiría esto, 00:34:03
luego escribiría esto y luego escribiría esto. 00:34:07
Sin problema. Pero si ahora le pongo x igual a 7, ¿qué escribiría? 00:34:10
O sea, quito las paréntesis y pongo estas 7. 00:34:16
Ahora me pondría menor que 6. 00:34:20
Fin. Se saltaría sólo esta línea aquí, porque el if 00:34:24
afectaría esta línea. Como idea, 00:34:28
siempre que usáis un if, un while, un cualquier cosa, 00:34:32
marcad el bloque. Siempre utilizad 00:34:36
estas paréntesis. No se os ocurra nunca no ponerlas. Hasta si es una línea sola, poned una 00:34:40
llave aquí y una llave allá. No cambia nada, son seis segundos de vida, no, tres segundos de vida, 00:34:51
pero os sirve para evitar errores de que luego se aplique solo a esta línea y no a la siguiente. 00:35:00
¿Sí? ¿Dudas hasta aquí? 00:35:07
¿Qué hace esto? 00:35:16
Esto es un if-else. 00:35:30
Entonces me dice, aquí hay dos opciones. 00:35:32
O este bloque de aquí, o este bloque de aquí. 00:35:34
¿Vale? 00:35:38
Y ejecutaré o uno o el otro, nunca los dos a la vez, 00:35:39
dependiendo del valor de esta expresión booleana. 00:35:44
Evalúo la expresión booleana, 5 es menor que 5, falso. 00:35:46
por lo tanto me salto el bloque true y escribo solo el bloque 00:35:50
falso. Si esto fuera verdadero, escribo el bloque 00:35:54
verdadero y salto el bloque falso. En este caso 00:35:58
como 5 no es menor que 5, me iría a leerse, escribiría mayor o igual 00:36:02
que 5 y luego fin, porque fin está fuera del bloque if 00:36:06
y por lo tanto lo escribiría siempre. 00:36:10
Paréntesis pequeña. 00:36:20
Ahora que empezamos a utilizar los bloques, ¿os acordáis que era el ámbito de una variable, los Q? 00:36:21
Y las variables solo existen dentro del bloque en que la creo. 00:36:33
Entonces, si yo digo, si X es menor que 5, pongamos que es verdadero, entro aquí dentro y aquí creo una variable, 00:36:39
esa variable fuera, donde está el fin, ya no existe. 00:36:47
Si creo una variable dentro de un bloque 00:36:51
Cuando salgo de ese bloque ya no existirá 00:36:55
¿Vale? 00:36:57
Entonces ahora el ámbito de la variable 00:36:59
Empieza a tener un poquito más de sentido 00:37:00
Antes era todo el mismo bloque 00:37:02
¿Sí? 00:37:04
¿Es esto? 00:37:10
¿Es esto es como antes hacíamos 00:37:30
Un ternario dentro de un ternario? 00:37:32
Pues esto es un if dentro de un if 00:37:35
El primer if es el azul 00:37:36
¿Vale? 00:37:38
Que pones esta cosa es verdadera 00:37:39
Entonces hace esto de aquí 00:37:41
si no, hace esta otra cosa. 00:37:42
Y en esta otra cosa he metido 00:37:45
un if. ¿Vale? 00:37:46
Esto sería un bloque que empieza aquí 00:37:48
y acaba aquí, y dentro está otro if 00:37:50
que dice, oye, pero si es igual, 00:37:52
entonces, por lo que es igual, y si no, 00:37:54
este else es de este if 00:37:57
de aquí. ¿Veis? 00:37:58
Tened cuidado que a veces 00:38:03
esto lía un poquito 00:38:04
las cosas, porque este else requiere 00:38:06
selección de este if, o de este if, o de este cual. 00:38:08
¿Vale? Entonces, 00:38:11
puede que os liéis un poquito. 00:38:12
Aún así, esto en realidad es el SIF. Existe una forma de escribirlo juntos para que es como si es esto, si no, si es esto, si no, si es esto, si no, si es esto, pero por ahora no nos compliquemos mucho. 00:38:14
¿Qué hace esto? Es lo mismo que antes, ¿vale? Solo que esta vez lo he delimitado con las llaves, ¿vale? Para que se vea que esto es otra cosa, ¿vale? 00:38:30
aquí funciona lo mismo porque esto dice este else se aplicaría solo al siguiente comando y 00:38:52
todo este de aquí es un comando es un comando solo es un comando if por lo tanto funciona 00:38:59
pero quizás así se vea un poco más grande al menos a nuestro nivel esto 00:39:05
después de recreo la solución. Entonces, antes de recreo estamos aquí. ¿Qué hace este programa? 00:39:16
Mi if es menor que uno. Hace lo del is. El problema de esto es cuando no usáis las 00:39:39
las llaves, es este else, es hijo de este if, o es hijo de este if. O sea, este else es si este 00:40:02
if menos de 1 hace esta cosa aquí y si no hace esta otra, o esto es un if plano sin else y dentro 00:40:15
tiene un infeliz. Cuidado con lo que hacéis. Por eso os he dicho, intentad poner siempre las 00:40:25
llaves porque así definís vosotros cómo se tiene que comportar el programa. Si no, tengo que saber 00:40:35
bien cómo funcionaría Java interiormente en estas cosas de aquí y a ver qué pasa. En este caso 00:40:44
concreto y según lo que está escrito aquí debajo, en principio escribiría nada, ¿vale? 00:40:51
Porque esto sería un if y esto sería una sentencia if-else, entonces todo este if-else 00:40:58
sería como si estuviera en un bloque, ¿vale? Y entonces el esto no es verdad saldría y ya está. 00:41:04
Pero claro, cuando esto lo hago muchas veces mezclado así, pues a lo mejor cuando lo leo 00:41:11
rápidamente, medio. Ponéis siempre las llaves, ¿vale? Y dentro tenéis, debajo tenéis la, es útil. 00:41:16
Vale, ¿y esto era LIFS? ¿Te queda claro LIFS? Sencillo, ¿vale? Muy parecido al otro. La diferencia está siempre en esta cosa de aquí. 00:41:26
aquí son solo system.out 00:41:40
no hace grandes 00:41:43
aprietos, vale, la diferencia con lo que 00:41:44
utilizamos antes es que en estas ramas 00:41:46
de aquí, if-else, vale 00:41:49
antes aquí podíamos poner solo expresiones 00:41:50
mientras ahora no estamos 00:41:53
poniendo expresiones, estamos poniendo 00:41:55
programas, estamos poniendo 00:41:56
llamadas a métodos, podemos poner while 00:41:58
podemos poner otros if 00:42:00
podemos poner lo que nos da la gana, vale 00:42:02
estas son comandos, son líneas 00:42:04
de instrucciones, más que una, pueden estar 00:42:07
cinco líneas se me da la gana, ¿vale? 00:42:09
Sin embargo, en el 00:42:11
operador condicional, eso es un operador 00:42:13
que devuelve 00:42:15
un tipo y que se puede evaluar. 00:42:17
Esto no se evalúa, esto se ejecuta. 00:42:19
¿Sí? ¿Me entienden? 00:42:22
Siguiente 00:42:26
condicional que vamos 00:42:26
a ver es el switch case, ¿vale? 00:42:28
El switch case 00:42:31
es siempre un condicional, 00:42:32
siempre es un tercer condicional, y todo 00:42:35
lo que se puede hacer con el switch case 00:42:37
se puede hacer con un if. Eso de if-else, if-else, if-else, if-else, 00:42:39
o el si-else, el si-else, el si-else, pues se puede hacer 00:42:43
la misma cosa. Solo que en determinadas circunstancias, si lo hago con if-else, 00:42:46
me saldría un if dentro de un if, dentro de un if, dentro de un if, 00:42:51
dentro de un if, entonces saldría una cosa bastante compleja de leer. 00:42:55
Mientras este de aquí, en las situaciones en que se usa el switch case, 00:42:59
lo hace más fácil de leer. Está claro que en otras situaciones, 00:43:02
Usar el switch case es relativamente imposible, no se podría, ¿vale? 00:43:06
Esta es la sentencia condicional que permite comparar una determinada variable con varios valores posibles. 00:43:12
Dependiendo del valor de dicha variable, esto tendremos un bloque, o no, ¿vale? 00:43:18
Se puede hacer lo mismo con varios x vanidados, esto hemos ya dicho, ¿vale? 00:43:22
Esto es un switch case, ¿vale? 00:43:28
La idea es esta, ¿sí? 00:43:30
Entonces, si yo tengo una variable, ¿vale? 00:43:33
No sé qué valor tiene esta variable, pero esta variable debería tener un cierto número finido de posibles valores, ¿vale? 00:43:38
Típicamente un menú, ¿vale? 00:43:49
Yo tengo un menú, digo, la opción 1 es esta, la opción 2 es esta, la opción 3 es esta. 00:43:51
Entonces tengo tres posibles valores, 1, 2 y 3. 00:43:55
Tengo cuatro posibles valores, 1, 2 y 3, y cualquier otra cosa, ¿vale? 00:43:58
Cualquier otra cosa me valdría como 00:44:02
Te has equivocado 00:44:04
1, 2 y 3 tengo que hacer cosas concretas 00:44:05
Entonces pillo esta variable 00:44:09
Y voy a comprobar 00:44:11
¿Vale o no? 00:44:12
¿Vale un valor concreto? 00:44:13
Si vale ese valor concreto 00:44:16
Entonces ejecute este código 00:44:18
¿Vale? 00:44:19
Vale 2, ejecute este código 00:44:21
Vale 3, ejecute este código 00:44:23
En base a 00:44:25
¿Cuál pillo de estas? 00:44:27
O sea, ¿Cuál es salida de estas? 00:44:30
de true, ¿vale? 00:44:31
Puede hacer dos cosas. 00:44:34
O ejecutar este bloque 00:44:35
de consentencias y todos 00:44:37
los otros que vienen por debajo. 00:44:39
O salir 00:44:42
con el break. El break 00:44:43
me devolvería al final 00:44:45
del switch. ¿Qué quiere decir? 00:44:47
Mirámoslo aquí. 00:44:50
¿Vale? Entonces yo tengo 00:44:51
switch una variable, x, 00:44:53
¿vale? Case, 00:44:55
en el caso en que valga 1, 00:44:57
pues aquí pongo 1, 00:44:59
ejecutaría esta sentencia 00:45:00
las sentencias 1 00:45:03
si le pongo el break 00:45:04
quiere decir que una vez ejecutada 00:45:07
las sentencias 1 00:45:09
saldría al final del 00:45:11
switch case y seguiría adelante 00:45:13
si no le pongo el break 00:45:15
ejecutaría las sentencias 00:45:17
1 y también las sentencias 00:45:19
2 independientemente de si 00:45:21
el case vale 2 o no 00:45:23
una vez que yo he seleccionado 00:45:24
cuál es el caso 00:45:27
ejecutaré 00:45:28
esas sentencias 00:45:31
y todas las que vienen debajo 00:45:32
hasta llegar a un break 00:45:34
si llega a un break 00:45:36
salgo del switch 00:45:38
si, diría 00:45:40
un ejemplo, así 00:45:50
vale 00:45:52
por ejemplo, me han dado una nota 00:45:53
si, nota 00:45:56
7, pues quiero 00:45:58
transformar este 7 en 00:46:00
suspenso, aprobado 00:46:02
notable, cosas por el estilo 00:46:04
entonces tengo este switch 00:46:06
digo, pillo nota 00:46:07
la variable nota 00:46:10
y miro sus casos 00:46:12
si es 5, en el caso en que sea 5 00:46:13
escribes aprobado 00:46:16
y sales 00:46:18
acabo 00:46:20
en el caso en que 00:46:22
sea 6, pues escribes 00:46:24
bien y sales 00:46:26
en el caso en que sea 00:46:27
7, no hagas nada 00:46:30
pero tampoco el break 00:46:32
¿lo veis? 00:46:35
y en el caso que sea 8 00:46:37
escribe notable 00:46:39
y sale 00:46:41
esto me hace que tanto 7 como 8 00:46:42
me escriberá notable 00:46:45
¿entendéis? 00:46:46
¿entendéis? 00:46:49
yo tengo un 7, saldría aquí 00:46:49
no ejecuto nada, pero ejecuto todo lo que viene 00:46:52
debajo hasta el break 00:46:55
por lo tanto ejecutaría también esto notable 00:46:56
y al break saldría 00:46:59
¿Sí? Entonces, si yo tengo varios casos que harían lo mismo, puedo hacer esto. 00:47:00
Caso 7, 8, 9, 10 y 9, hace esta cosa aquí. 00:47:09
Caso 20, 30, 40, 50, hace esta otra. 00:47:12
¿Entienden? 00:47:16
Fijaos, pero que aquí no estoy preguntándome si es menor, mayor, si es entre unidad. 00:47:17
Pues eso lo hace el IF. Esto es un valor concreto. 00:47:22
Cuando nota, vale ese valor. Ese es el caso. 00:47:25
caso 9 sobresaliente caso 10 matrícula de honor y luego está este de aquí que 00:47:28
viene aquí que me ha saltado vale que es el default el default es un método es un 00:47:35
valor que te dice en todos los otros casos si no has encontrado un caso que 00:47:41
te vale pues aplica el default 00:47:48
si yo no he puesto break antes el default se ejecutará siempre si yo he 00:47:53
puesto break pues entonces sólo en el caso en el que no sea un valor entre entre 5 y 10 en cualquier 00:47:57
otro caso de dar suspecho por aquí se me da 11 pues el suspecho 120 suspecho menos 7 suspecho 00:48:07
¿Entendéis? Y este es el fich. Un ejemplo, es así, hay que probarlo y ver un poquito 00:48:16
cómo funciona. Entonces, lo que vamos a hacer ahora es un poco de código, hago algunos 00:48:31
ejemplos, probamos un poco de IFA, probamos un switch case y cosas por el estilo y luego 00:48:38
como no una banda de 30 artistas la mañana vale entonces sabramos el eclipse 00:48:42
me creo un nuevo 00:48:52
package 00:49:15
con la fecha de hoy 00:49:16
lección 00:49:19
2026 00:49:20
10.07 00:49:23
y aquí dentro creo 00:49:24
un ejemplo 00:49:29
ejemplo if a uno 00:49:30
vale, entonces 00:49:33
la sintaxis del if es sencilla 00:49:41
vale, entonces en base 00:49:44
a un valor que me dan 00:49:46
pues hago algo, vale 00:49:48
casi todos los ejercicios 00:49:50
que os he dado que usan 00:49:53
un ternario 00:49:54
se pueden volver 00:49:57
a rehacer con un if 00:49:58
vale, sería prácticamente lo mismo 00:50:00
Vamos a hacer uno de los ejercicios sencillos de lo que hemos visto. 00:50:02
Dame un número y dime si es par en par. 00:50:06
Entonces, scannerScan es igual a newScannerDeSystem.int 00:50:12
para poder leer. 00:50:18
Si eso lee un número. 00:50:21
intX es igual a scan.nextInt. 00:50:26
He leído un número. 00:50:29
Y ahora me pregunto, si este número es módulo 2 es 0, misma cosa que escribíamos antes, entonces si yo es par, el se, y yo no es par. 00:50:31
En una situación como esta, casi el otro era más compacto, porque al fin y al cabo te daba un string que tú escribías solo una vez un system.out.entendent. 00:50:59
Para estos ejercicios tan sencillos, el otro puede ser una alternativa válida. 00:51:15
Está claro que si yo aquí no te estoy preguntando solo si es par o impar, más te digo, si es par, haz toda una serie de operaciones. 00:51:21
Y si es impar a todo otro ser eliger, pues allí ya es una otra versión. 00:51:28
Allí el otro no lo puedo usar, tengo que utilizar eliger. 00:51:33
Esto es un ejemplo. 00:51:43
Modificámoslo. 00:51:47
Entonces, sí. 00:51:48
Dime si es par o impar, pero también si es positivo o negativo. 00:52:00
Entonces, una forma de hacerlo. 00:52:10
Con esto yo sé si es par o impar. 00:52:13
Cuando digo que es par, y ahora aquí dentro, dentro de este bloque que sé que es par, me pregunto si es positivo o negativo, pero lo podría hacer aquí fuera. 00:52:16
Antes digo si es par o impar, y luego hago otro if para decir si es positivo o negativo. 00:52:26
Pero lo quiero hacer de otra forma. Quiero en una sola cadena decir que es par positivo o par negativo o cosa por el estilo. 00:52:34
de estilo, no sé si me explico, ¿vale? Para forzar 00:52:42
a que el if esté aquí dentro. 00:52:44
¿Sí? Entonces, 00:52:47
yo si estoy en esta rama de aquí, 00:52:48
estoy seguro que es 00:52:51
par, ¿vale? Entonces me vuelvo a preguntar 00:52:52
x es mayor que 0, 00:52:55
entonces 00:53:01
es par positivo. 00:53:02
Si no, 00:53:10
es par negativo. 00:53:18
¿Sí? 00:53:22
Es que en esta zona 00:53:23
aquí estoy seguro que es par y aquí me pregunto si es positivo o negativo y lo mismo tendré que 00:53:25
volver a hacer aquí. Aquí sé que es impar, por lo tanto es impar, pero si es mayor que cero es impar 00:53:34
positivo y si es... esto lo he puesto de error. Entonces ahora yo tengo un programa que le digo 00:53:49
el número. Número 7 es en par positivo. Número menos 8 es par negativo. ¿Vale? Número cero 00:54:00
que me da par positivo. Par negativo. Porque le he puesto un escrito mayor que cero. ¿Vale? 00:54:11
Si quisiera que fuera par positivo, le pongo mayor o igual y ahora es cero, es par positivo. 00:54:29
¿Sí? Este es un ejemplo de un if dentro de un if. 00:54:36
¿Mismo ejercicio de otra forma? 00:54:52
Voy a preguntar. 00:55:07
Si es par y mayor que cero, entonces es par positivo. 00:55:09
¿Justo? 00:55:35
Y ahora me pregunto. 00:55:36
¿El se if es así? 00:55:39
pero es menor, entonces es par negativo. El 6, si es 1 o es distinto de 0, como queráis, y es mayor que 0, entonces es impar positivo. 00:55:47
y si no, si es distinto 00:56:29
y menor que cero, es impar. 00:56:40
Negativo. Todo esto ya no me sirve. Fuera. 00:56:48
Se quedaría una cosa así. ¿Vale? Estoy usando 00:56:56
el sí, el sí, el sí, el sí. Hace lo mismo que antes. ¿Vale? 00:57:04
Simplemente estoy comprobando las cuatro opciones. 00:57:08
Yo debería hacer más o menos lo mismo. 00:57:17
par positivo 00:57:22
menos 8 00:57:24
par positivo 00:57:26
pero par positivo 00:57:27
no sé cuál gusta más 00:57:30
o los parezca más 00:57:39
claro si este de aquí 00:57:40
o este de aquí 00:57:43
pero 00:57:45
en realidad 00:57:46
esto también me da 00:57:49
es como decir 00:57:52
Si esto, esto, si no, si esto, esto, si no, si esto, esto, en cualquier otro caso, el último caso que me queda es el que no vale ninguno de estos tres, entonces allí sé que es impar negativo. 00:57:57
¿Sí? ¿Dudas? Estos son. ¿Queréis hacer un ejercicio? ¿Me diréis vosotros qué hacer y yo lo hago? 00:58:09
Siempre os doy los ejercicios yo, unir. Si no, pues hacemos un switch. 00:58:27
Hacemos un switch y luego los ejercicios los hacemos después. 00:58:36
Ejemplo, switch. 00:58:43
Copio esto para pillar un número, ¿vale? 00:58:48
Esta parte aquí es la misma. Hagamos un pequeño menú. Hagamos una calculadora. 00:58:59
calculadora. Entonces, ¿qué hago? Pillo tres números. Dame num1, num2, n2, n1. ¿Vale? 00:59:07
Y finalmente, un operador. Operador lo leo como número. ¿Vale? Para hacerlo más sencillo. 00:59:29
1 suma, 2 resta y leo int operador es igual a scan.nexit. 00:59:48
Entonces, aquí estoy leyendo un número, un otro número y luego te pregunto, ¿qué quiero hacer? 01:00:04
¿Sumar o restar? 01:00:09
¿O multiplicar? 01:00:10
Venga, 3 multiplicar. 01:00:11
No pongo la división porque se complica un programa. 01:00:14
No mantengo nada. 01:00:21
¿Vale? 01:00:22
Ok, perfecto. Entonces, en base al valor de esto, yo tendré que hacer cosas distintas de estas. 01:00:23
Entonces, lo que hago es un switch. 01:00:30
Switch sobre operador. 01:00:32
Y me digo, en el caso en que sea 1, si eso, num1 más num2. 01:00:35
N1 más N2. 01:00:51
Se me olvida el break. Case dos, dos puntos, siso, n, n1, menos n2. Case tres, dos puntos, siso, n1, multiplicado n2. 01:00:54
Entonces lanzo esto y le digo 01:01:19
¿Cuál es el número uno? Dos 01:01:26
¿Cuál es el número dos? Tres 01:01:28
¿Qué quieres hacer? Multiplicar 01:01:31
Seis, perfecto, funciona fenomenal 01:01:33
Entrego esto y saco un 01:01:36
No, seis 01:01:39
¿Por qué? 01:01:41
Porque si ahora le digo, vale, número cuatro 01:01:44
3, súmalos 01:01:47
el resultado sería 7 01:01:50
y él me escribe 7, 1, 12 01:01:51
¿por qué? 01:01:53
porque él entra 01:01:56
en este 01:01:57
case y como 01:02:00
no hay break, él ejecutará 01:02:02
esto, esto y esto 01:02:04
entonces hace las 3 operaciones 01:02:06
¿entiendes? 01:02:08
entonces aquí le pongo un break 01:02:12
ya está 01:02:14
entonces ahora si le pongo 01:02:21
Muestres suma. Ahora recuerdo la cara malvada de un italiano medianamente alto que me enseñaba 01:02:25
programación y siempre me ha dicho pon las llaves en los bloques. Entonces le pongo llaves en los 01:02:40
bloques para que sepas cada caso donde piensa y donde acaba. Y si quiero lo puedo poner así, 01:02:47
si lo veis mejor vale esto no cambia nada desde la perspectiva de cómo funciona cuando son pocos 01:02:59
como en este caso que sólo escribir y hacer break hasta en una línea sola no no da problema si se 01:03:15
ve bien cuando aquí hay que meter 25 líneas de código pues entonces está bien que sea marcado 01:03:22
con él con este aquí y te diga aquí empezó a casa 3 aquí acaba a mí me gusta más así vale yo lo veo 01:03:28
más claro pero como mi mente que ha aprendido a programar en 2000 pues lo ve vale luego él le 01:03:39
gusta más así. Vale, entrego esto y saco 5,5. Aprobado. Está muy bien. ¿Por qué? Porque quedan 01:03:48
cosillas feas, como por ejemplo si pongo 6 y 5 y 6. No hace nada. Pongámosles algo. Mira que estás 01:04:13
equivocado pues entonces aquí le pongo default en cualquier otro caso siso operación no admitida 01:04:23
Entonces 1, 2 y le pongo... Ya está, ya tengo un 6. ¿Dudas? Sí. Código es esto. 01:04:37
¿Esto se puede hacer con un if? Claramente, sí. op es igual a igual a 1, hace esto. else if op 01:05:15
2, hace esto, o dice, a ver, else, etc. Es un if-else. Solo que cuando la opción es, 01:05:27
pilla un número y compáralo en varios valores, ponga que es en cien valores, pues esta cosa 01:05:38
de aquí suele parecer más estructurada, más fácil de leer con respecto a poner un if-else, 01:05:43
y flex, y flex, y flex, y flex. 01:05:53
¿Esto funciona solo con enteros? 01:05:58
No. Funciona también con char, 01:06:02
con double, con lo que te da la gana. 01:06:03
Funciona también con string. 01:06:05
¿Vale? La string que ponga 01:06:08
aquí se equivalerá aquí con 01:06:09
no igual, igual, 01:06:11
más un punto de igual. 01:06:13
Todo funciona. 01:06:15
¿Vale? 01:06:17
Con otros objetos no lo he probado 01:06:19
en mi vida. 01:06:21
¿Duras? 01:06:22
Vale. 01:06:33
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:
1
Fecha:
7 de octubre de 2026 - 12:21
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 06′ 36″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
160.98 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid