Saltar navegación

20261005 SentenciaIf_3 - 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 5 de octubre de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, aquí tenemos ese diagrama de flujo. 00:00:02
Vale, aquí tenemos, ¿cuál es nuestra condición? 00:00:08
Nuestra condición es, número 1, lo voy a llamar n1 para que sea más, igual a n2. 00:00:11
Esta es la condición. 00:00:18
¿Qué pasa si se cumple? 00:00:22
Pues si se cumple, se está haciendo todo esto. 00:00:24
Todo esto de aquí 00:00:27
Se está haciendo 00:00:30
Si se cumple 00:00:32
Todo eso 00:00:36
Si se cumple 00:00:37
Todo esto de aquí 00:00:40
Lo que está en este bloque 00:00:41
¿Qué pasa si no se cumple? 00:00:43
Si no se cumple 00:00:46
Está haciendo 00:00:48
Todo esto 00:00:48
En este caso es más cortito 00:00:50
Una sola sentencia 00:00:52
Todo esto es lo que está haciendo aquí 00:00:53
Si no se cumple 00:00:54
Todo eso está ahí 00:00:55
Haciendo 00:00:56
¿Vale? 00:00:57
Y tanto si se cumple, que hará todo eso de ahí, como si no se cumple, que hará todo esto de aquí, una vez que se ha hecho o esto o esto, una de las dos cosas, pues ya el programa sigue, ¿dónde sigue? Pues aquí, este punto es este punto, ¿vale? 00:00:59
seguimos por aquí 00:01:25
ejecutando lo que venga después 00:01:28
en este caso son unas sentencias 00:01:30
pero podrían ser muchas las que fueran 00:01:32
vale, pues cada vez que vemos algo así 00:01:34
tenemos que ver el diagrama de flujo 00:01:40
las sentencias de arriba 00:01:42
es lo que hay arriba 00:01:43
lo que sea 00:01:45
la decisión 00:01:46
¿qué se hace en la rama del sí? 00:01:49
lo que hay en el if 00:01:51
en este bloque entre llaves 00:01:53
¿qué se hace en la rama del no? 00:01:54
lo que hay aquí en el else 00:01:57
en este bloque entre llaves 00:01:58
cuando se ha hecho 00:02:00
la que sea, en cada ejecución 00:02:02
puede ser una distinta, cuando se ha hecho 00:02:04
la que sea, el programa 00:02:06
continúa su camino 00:02:08
continúa su camino donde? aquí 00:02:09
este es el punto donde el programa 00:02:12
continúa su camino 00:02:14
ahí, ahí lo continúa 00:02:16
independientemente de si ha hecho esto o esto 00:02:18
continúa con lo que toque 00:02:20
y ahí podría 00:02:22
seguir habiendo sentencias 00:02:24
porque el programa es la combinación 00:02:26
de toda la secuencia 00:02:28
de sentencias que van haciendo 00:02:30
todo lo que me van pidiendo y ya está 00:02:32
vale 00:02:33
entonces vamos a ejecutarlo 00:02:37
antes de 00:02:40
modificar un poco más 00:02:41
entonces efectivamente ejecutamos 00:02:43
esto 00:02:50
primero nos pide los números 00:02:50
esto es antes del if, vale 00:02:56
primero va a hacer esto 00:02:59
porque esto es lo que va antes de la sentencia 00:03:01
de decisión, vale, primero nos pide 00:03:03
los números 00:03:05
pues venga, el número 1 00:03:06
pues el 45 00:03:08
nos sigue pidiendo 00:03:10
el número, vale 00:03:12
ahora estamos pues haciendo esto 00:03:14
número 2, le vamos a poner el 45 00:03:16
otra vez, cuando le demos 00:03:18
al enter ya estamos aquí, ahora 00:03:20
se hará la pregunta, como son iguales 00:03:22
entrará aquí 00:03:24
y empezará a hacer todo esto 00:03:26
efectivamente 00:03:28
como son iguales y esta condición es 00:03:31
true, entra en este bloque 00:03:32
y me muestra el mensaje 00:03:34
venga, segunda oportunidad 00:03:36
me pide el número uno otra vez 00:03:39
yo meto el número uno 00:03:41
pues lo que sea 00:03:44
me pide el número dos 00:03:44
otra vez 00:03:48
meto el número dos, el que me dé la gana 00:03:49
y luego independientemente 00:03:51
ya de cómo sean 00:03:54
independientemente de cómo sean 00:03:55
te mostraba la suma 00:03:57
pues efectivamente 00:03:59
me muestra la suma 00:04:01
Y ya está, como ya ha terminado esto, el programa ahora ya ha continuado por aquí. 00:04:03
Esto lógicamente no lo hace, porque esto es lo que se hubiera hecho, se hubiera hecho, si la condición hubiera sido falsa. 00:04:09
Esto es lo que se hubiera hecho. 00:04:19
Pero como la condición ha sido true, lo que se ha hecho es esto. 00:04:20
O se hace esto de aquí, o se hace esto de aquí. 00:04:23
O una, o la otra. 00:04:27
Y cuando ya se ha hecho la opción correspondiente 00:04:29
El programa sigue con lo que toque 00:04:32
Que eso es lo que ha hecho 00:04:33
Seguir con lo que toca 00:04:35
¿Vale? 00:04:36
Bueno, ¿entendido? 00:04:47
Vale, a ver, pequeñas modificaciones sintácticas 00:04:51
Para irnos familiarizando 00:04:55
Vale, por lo general yo he dicho 00:04:57
Que las sentencias que se hacen 00:05:02
Tanto en la rama del sí como en la rama del no 00:05:03
irán entre esos símbolos de llave 00:05:06
y eso es lo que se llama un bloque, ¿verdad? 00:05:10
Esto es un bloque con un montón de sentencias 00:05:13
y esto es otro bloque con otro montón de sentencias. 00:05:16
Vale, bueno, en este caso con una sola. 00:05:21
Bueno, pues, 00:05:25
en el caso de que el bloque tenga una sola sentencia, 00:05:27
en el caso de que tenga una sola, 00:05:33
las llaves se pueden quitar 00:05:35
solo en ese caso 00:05:37
por ejemplo, en este ejemplo 00:05:39
aquí no podríamos quitar las llaves 00:05:42
porque la rama del sí 00:05:44
y la rama del true 00:05:46
tiene un montón de sentencias 00:05:47
las tengo que poner obligatorias 00:05:48
pero la rama del else 00:05:51
solo tiene una 00:05:55
entonces cuando solo hay 00:05:55
una sentencia en la rama que sea 00:05:59
la de if, else, true, false 00:06:02
la llave es opcional 00:06:04
y el programa sigue significando 00:06:06
exactamente lo mismo 00:06:09
¿vale? entonces lo que yo he escrito antes 00:06:10
y esto es idéntico 00:06:15
¿vale? 00:06:16
entonces para Java 00:06:23
¿qué significa 00:06:25
cuando él no ve una llave 00:06:26
aquí? cuando él 00:06:29
ve un else o ve un if 00:06:31
y no ve que automáticamente después 00:06:32
haya una llave, no ve, dice 00:06:35
ah vale, entonces interpreto 00:06:36
que la única 00:06:39
sentencia que hay que hacer 00:06:41
es la que viene después 00:06:42
interpreto que la única que hay 00:06:44
dentro de mi rama 00:06:49
interpreto que es la única que hay 00:06:50
es la que viene después 00:06:53
y las que haya continuación 00:06:54
son ya 00:06:56
de fuera de la sentencia 00:06:58
es decir, imaginaos que uno está 00:07:00
haciendo un estilo 00:07:05
de código fatal 00:07:07
y esta sentencia la ha puesto así 00:07:08
¿vale? 00:07:11
entonces uno podría pensar 00:07:17
viendo este código, podría pensar 00:07:19
que la rama del sí 00:07:21
tiene todo esto 00:07:23
esto es lo que se hace 00:07:26
si me da true la condición 00:07:28
y uno viendo esto así a lo tonto 00:07:31
podría pensar entonces 00:07:33
que la rama del no 00:07:35
tiene todo esto 00:07:36
Ya, pero está deduciendo eso por las tabulaciones y espacios 00:07:40
Cuando eso no pinta nada 00:07:46
No, es mentira 00:07:47
En este programa, la rama del no o la del else 00:07:49
Solo, solo tiene esto 00:07:53
Y esta ya se hace después 00:07:56
¿Por qué? 00:08:00
Porque no hay una llave aquí 00:08:01
Entonces, desde el momento en que la máquina virtual 00:08:02
el compilador ve que aquí 00:08:06
no se abre una llave 00:08:08
él deduce que entonces 00:08:10
la única sentencia que tenemos dentro 00:08:12
es esta 00:08:14
y esta ya 00:08:15
se sobreentiende que es una sentencia que ya está fuera 00:08:18
del ifelse, esta ya está fuera 00:08:20
con lo cual este programa 00:08:22
me da igual que esto esté tabulado aquí 00:08:24
que esté aquí, me da lo mismo 00:08:26
es que significa lo mismo, significa igual 00:08:28
las tabulaciones de los espacios no pintan nada 00:08:30
son las llaves las que marcan 00:08:33
entonces, aquí no hay llave 00:08:34
entonces, sobreentiendo 00:08:36
que solamente esta ascendencia 00:08:38
es la que hay 00:08:40
dentro del else, y lo que venga después 00:08:42
lo que venga después 00:08:45
ya está fuera, ya está fuera 00:08:46
del if, vale, si este es 00:08:48
si, no 00:08:53
sigo por aquí 00:09:07
sigo por aquí 00:09:10
vale, como aquí no hay llave 00:09:11
esto es lo único que va aquí 00:09:14
lo único 00:09:16
porque aquí no hay llave 00:09:17
luego solo la siguiente sentencia 00:09:19
y la que haya después 00:09:20
todo lo que haya después 00:09:22
ya es de fuera 00:09:23
ya es de fuera y ya va aquí 00:09:25
de fuera 00:09:27
entonces este programa 00:09:28
funcionaría perfectamente 00:09:36
hace lo que tiene que hacer 00:09:38
pero está escrito muy feo 00:09:39
está escrito como para confundir 00:09:41
porque uno lo ve así 00:09:42
y parece que 00:09:44
es que esto es dentro del ELSE 00:09:46
no es dentro del ELSE 00:09:48
es que no lo va a hacer dentro del ELSE 00:09:49
en ningún caso 00:09:50
vale 00:09:51
entonces 00:09:53
esta es una mejor manera 00:09:54
de escribir este código 00:09:57
aunque haga lo mismo, hace lo mismo 00:09:59
es una mejor manera, porque aquí se ve más claro 00:10:01
a la vista 00:10:04
vale, aquí si yo quito las llaves 00:10:04
la lío 00:10:10
vale, yo voy a quitarlas 00:10:11
aquí la lío porque son 00:10:14
más de una sentencia 00:10:15
yo las quito 00:10:16
y efectivamente aquí me sale una cosa roja 00:10:18
Porque aquí hay muchas antes del else 00:10:21
Hay un montón 00:10:25
Hay un montón 00:10:26
Entonces, no 00:10:29
Esto tiene que estar entre llaves 00:10:31
¿Vale? Luego entonces 00:10:34
Primera cosa 00:10:41
Si solamente hay una sentencia 00:10:42
Tanto en la rama del sí 00:10:46
Como en la rama del no 00:10:47
Podemos quitar las llaves 00:10:49
Porque el sentido del programa es idéntico 00:10:52
Es lo mismo 00:10:56
Se sobreentiende que solo la única sentencia que sigue al if o al else es la que cuenta 00:10:56
Vale, primera cosa 00:11:05
Segunda cuestión de sintaxis, de código 00:11:08
La rama del no es opcional 00:11:16
¿La puedo poner o puedo no ponerla? 00:11:22
es decir, existe una variante en la cual yo solo hago algo 00:11:26
si se cumple la condición y si no se cumple no hago nada 00:11:31
por ejemplo, vamos a poner otro ejemplo chorra 00:11:34
por ejemplo, vamos a hacer un programa y así ya aprovechamos 00:11:38
para esto que os digo, de incorporar alguna de las pequeñas 00:12:09
funcionalidades que tienen los datos string, vamos a hacer un programa 00:12:11
que solicite tu nombre 00:12:17
Y te salude por tu nombre 00:12:20
¿Vale? 00:12:24
Pero si 00:12:34
Te salude por tu nombre 00:12:35
Solo 00:12:40
Si tu nombre 00:12:41
Tiene menos de 00:12:43
Diez caracteres 00:12:47
Si tu nombre es demasiado largo 00:12:49
No te saluda 00:12:52
¿Vale? 00:12:53
Este programa, esta aplicación 00:12:54
Solo concibe saludar 00:12:56
si tu nombre tiene menos de 10 caracteres 00:12:58
si no, te ignora 00:13:01
no es válido por lo que sea tu nombre 00:13:02
o ya está, te ignora 00:13:04
vale 00:13:05
bueno, pues vamos a aprovechar esto 00:13:07
para incorporar alguna de las 00:13:10
poquitas cosas que puede hacer string 00:13:13
que podemos nosotros ahora entender 00:13:15
vale 00:13:16
pero bueno, están recogidas en el otro fichero 00:13:19
que en el aula virtual 00:13:20
pues venga, datos del programa 00:13:21
nuestro nombre 00:13:24
un nombre es una cadena de caracteres 00:13:25
Lo tenemos que guardar en un dato stream 00:13:28
Pues venga, mi nombre 00:13:30
Como vamos a leer del teclado 00:13:32
El escáner lo necesitamos 00:13:35
Vale, pues entonces 00:13:38
Leer el nombre 00:13:55
Tenemos que leerlo sí o sí 00:13:56
Ahora otra cosa es 00:13:58
Que puede que saludemos 00:13:59
O que no hagamos nada 00:14:01
Depende de una condición 00:14:03
El nombre hay que leerlo sí o sí 00:14:04
Pues venga, vamos a aprovechar 00:14:06
Y lo leemos aquí a la vez que lo declaramos 00:14:08
Vale 00:14:11
Pues vamos a incorporar. 00:14:15
Nosotros ya sabemos leer números, tanto enteros como decimales, 00:14:18
y guardarlos en las variables correspondientes, 00:14:24
con nextIn, nextDouble, nextFloat, si era Float. 00:14:26
También sabemos leer un boolean, si escribimos true o false, 00:14:30
con nextBoolean se guarda en el boolean correspondiente, 00:14:33
eso lo hemos hecho. 00:14:35
Lo que no hemos hecho es leer una cadena entera de texto 00:14:36
y guardarla en una variable string. 00:14:40
Bueno, pues también hay un método para eso 00:14:41
¿Qué es esto? 00:14:45
En lugar de escribir next int, next double, next boolean 00:14:46
Pues next line 00:14:51
Vamos a poner primero el aviso de introduzca nombre 00:14:52
Claro, para que 00:15:00
Introduzca su nombre 00:15:01
Vale, pues ya está 00:15:06
Esto no tiene ninguna dificultad 00:15:13
Next line 00:15:15
Se queda ahí esperando que tú metas pipipipipipipi texto 00:15:16
Cuando ya la has dado al enter 00:15:19
Coge ese texto 00:15:22
Esa sucesión de caracteres 00:15:23
Tenga lo que tenga 00:15:24
Y lo guarda en stream 00:15:25
Vale, muy bien 00:15:26
Ahora 00:15:27
Vale, ahora ya 00:15:30
Si que el programa 00:15:36
Nos exige 00:15:38
Incorporar una sentencia de decisión 00:15:39
Porque el programa que hace 00:15:41
El programa me va a saludar 00:15:42
Pero 00:15:44
Hola 00:15:46
Nombre 00:15:47
En principio esto es saludarme 00:15:50
mostraros la nombre, pero ¿me va a saludar en cualquier caso? 00:15:52
no, solo me va a saludar 00:15:56
si se da una condición, solo 00:15:58
si no se da no me saluda, entonces necesitamos 00:16:00
una sentencia de decisión que me permita hacer 00:16:04
cosas diferentes en función de si pasa una cosa 00:16:07
o no pasa, la necesito, no hay otra 00:16:10
¿vale? entonces si se da una cosa me saludará 00:16:12
y si no se da pues no hace nada 00:16:16
vamos a ver qué es eso de no hacer nada 00:16:19
vale, pues tendremos que poner una sentencia de decisión 00:16:21
entonces ahora aquí 00:16:23
si se da la condición 00:16:25
que tendré que ver cuál es 00:16:28
me saludas 00:16:29
y aquí puedo poner la llave, puedo no ponerla 00:16:31
da exactamente igual 00:16:33
porque es sólo una sentencia 00:16:35
saludarme 00:16:37
y si no se da esa condición 00:16:38
no haces nada 00:16:42
con lo cual, ¿qué hago? 00:16:43
¿dejo yo aquí un bloque vacío sin nada? 00:16:46
pues esto es 00:16:49
Feo, lo puedo dejar, no pasa nada, pero es un poco feo. Entonces, se contempla que una sentencia de decisión de tipo if else, el else no esté y no pasa nada. ¿Qué significa si no está? Que en el caso de que la condición no se cumpla, no se hace nada. Ya está. Eso es lo que significa. 00:16:50
es decir, dejarlo así 00:17:10
y dejarlo 00:17:13
así 00:17:15
es lo mismo 00:17:19
pero así es más feo 00:17:21
así es más feo 00:17:24
¿vale? 00:17:26
entonces si yo veo que en la rama del no no hago nada 00:17:27
lo natural es que la quite 00:17:30
¿vale? 00:17:31
entonces, ahora aquí 00:17:42
¿qué me faltaría? 00:17:43
poner la condición de 00:17:45
que el nombre 00:17:47
tenga más de 10 caracteres 00:17:49
pues ahí 00:17:51
ya la he liado, ¿cómo saco yo 00:17:53
el número de caracteres del nombre? yo que sé 00:17:55
el nombre es una cadena de texto que me han 00:17:57
metido, ¿cómo lo hago? 00:17:59
bueno, pues ahí 00:18:02
es donde viene que las variables 00:18:03
string, por ser variables 00:18:05
especiales, variables objeto 00:18:07
pueden hacer cosas 00:18:09
que las variables primitivas 00:18:11
como los números 00:18:13
los boolean, los char 00:18:14
no pueden 00:18:17
aquí es donde viene eso 00:18:17
¿vale? entonces vamos a ir incorporando 00:18:20
algunas de esas pequeñas cositas 00:18:31
para usarlas sin entender todavía 00:18:33
que es una variable objeto 00:18:34
vale, pues a ver 00:18:36
nombre 00:18:38
es una variable 00:18:43
pero resulta que es una variable 00:18:45
de las que yo estoy llamando 00:18:49
objeto 00:18:50
a las otras las llamo primitivas 00:18:51
variable objeto 00:18:57
¿Por qué los objetos son diferentes a las primitivas? 00:18:58
Ahora mismo nos es difícil de entender, no podemos, no sabemos lo que es un objeto. 00:19:01
Pero bueno, sirva como indicación que la diferencia está en la forma en la que se almacena. 00:19:06
¿Vale? Una variable primitiva, como un número n, directamente se crea un espacio en memoria para ella. 00:19:11
72, 14, 15. 00:19:18
Sin embargo, una variable objeto como esta de aquí, string s, no se almacena directamente como un espacio en memoria con el dato, no se almacena así, se almacena de otra manera, ¿vale? 00:19:21
Se almacena como una variable que tiene una dirección de memoria y esa dirección ya me dice, me está diciendo esa dirección donde está el dato. 00:19:37
pero bueno, eso lo digo 00:19:48
pues porque es la diferencia entre objeto 00:19:50
y variable primitiva 00:19:53
para 00:19:54
ponerlo en contexto 00:19:55
pero esto ahora mismo nos importa poco 00:19:58
¿vale? nos importa poco 00:20:00
lo que nos importa es, ahora mismo 00:20:01
que las variables objeto 00:20:08
por el hecho de ser objetos 00:20:09
aunque no entendamos muy bien lo que significa ser objetos 00:20:12
tienen una posibilidad 00:20:14
que no tienen las variables primitivas 00:20:16
que es dar órdenes 00:20:19
para que pasen cosas 00:20:21
la variable S 00:20:22
esta de aquí, aparte de tener el dato 00:20:24
que es el nombre que sea 00:20:27
aparte de tener el dato 00:20:28
tiene la posibilidad 00:20:31
de dar órdenes para que pasen cosas 00:20:33
los objetos pueden hacerlo 00:20:35
las variables primitivas 00:20:39
como los números y decimales no pueden 00:20:41
los objetos pueden 00:20:42
y la variable S, aparte de guardar el dato 00:20:44
puede dar órdenes 00:20:47
para que pasen cosas 00:20:48
¿Y cómo se dan órdenes para que pasen cosas? 00:20:49
Pues uno escribe la variable, un puntito 00:20:53
Y la orden que sea dentro de las posibilidades 00:20:56
Claro, dentro de las posibilidades 00:21:00
Pues vamos a escribirlo, a ver 00:21:02
Fijaos, si yo escribo aquí, lo voy a poner aquí abajo 00:21:05
Si yo escribo aquí nombre y pongo punto 00:21:12
Fijaos todo lo que se me despliega 00:21:16
un montón de órdenes 00:21:19
que puede dar ese objeto 00:21:21
esto es lo que se llama 00:21:24
métodos, ¿vale? que ya entenderemos 00:21:26
también lo que es un método más adelante 00:21:27
y dos o tres de ellos 00:21:29
dos o tres, los tenemos que usar 00:21:31
desde ya porque son básicos 00:21:34
para hacer cosas con cadenas de texto 00:21:35
son básicos 00:21:38
¿vale? 00:21:40
entonces 00:21:42
hay uno en particular 00:21:42
que es 00:21:46
este que pone aquí length de aquí 00:21:47
este length 00:21:50
que qué es lo que hace esta orden 00:21:52
o este método, qué es lo que hace 00:21:54
cuando está escrito después del punto 00:21:56
lo que hace es ponerse 00:21:58
a contar los caracteres 00:22:00
de la cadena, ponerse a contarlos 00:22:02
y decirte cuánto les han salido 00:22:04
eso es lo que hace esta orden 00:22:06
si tú invocas esta orden 00:22:08
length 00:22:10
se pone a contar los caracteres del 00:22:11
dato, 1, 2, 3, 4 00:22:14
y te dice 7, me han salido 7, eso hace. 00:22:16
¿Vale? Es un ejemplo de orden que puede invocar este objeto. 00:22:21
Fijaos que si yo en lugar de una variable string hago esto mismo con una variable n, 00:22:26
la variable primitiva n no tiene órdenes que invocar, no puede, porque no es un objeto. 00:22:32
Solo los objetos pueden invocarlas. 00:22:41
De hecho, scan también es un objeto 00:22:43
Por eso a través del puntito ha podido invocar esta orden 00:22:47
Que es, oye tú, teclado, quédate ahí a la espera de que te introduzcan un dato 00:22:51
Y cuando te lo den, dámelo 00:22:58
Es la misma idea 00:22:59
Bueno, pues entonces, esto que he dicho yo del length es justo lo que queremos 00:23:02
Me dicen, oye, vamos a contar cuántos caracteres tiene el nombre que me has dado 00:23:09
Vamos a contarlos, porque si fueran menos de 10, entonces te saludo, si no, no. 00:23:13
Entonces vamos a contarlos, pues anda, qué bien, porque nombre, por ser un objeto, puede dar esa orden, length, 00:23:20
y esto que te saca, esto después de contarlo, te saca, te devuelve, te entrega el número de caracteres que tiene ese nombre. 00:23:31
Te los entrega, te los devuelve, te los da, te dice, me han salido 25. 00:23:41
vale, pues, los que me han salido son menores de 10, 00:23:46
y ya tengo mi condición ahí estupendamente hecha, 00:23:53
vale, si la cuenta de los caracteres que tiene este objeto cadena nombre, 00:23:57
esta cuenta que me ha salido, porque esta orden led los ha contado y me los ha devuelto, 00:24:06
es menor que 10, pues me saludas, y si no, no, 00:24:12
Bueno, pues esta orden, la orden LENZ, que en lenguaje Java se llama método, este método, el método LENZ, ya es otra de esas cosas que ya nos aprendemos, la tenemos en la cabeza de memoria. 00:24:18
Cuando yo necesite saber la cantidad de caracteres de una cadena, lo puedo obtener con LENZ, ya nos lo aprendemos de memoria y ya está. 00:24:33
vale, pues este programa habría terminado 00:24:42
me va a saludar 00:24:58
solo si se cumple la condición 00:25:00
si no, no 00:25:02
y la rama del else como es opcional 00:25:02
la he quitado porque en el caso 00:25:06
de que no, no quiero que haga nada 00:25:08
entonces si ejecutamos 00:25:09
esto 00:25:12
introduzca su nombre 00:25:13
me saluda 00:25:15
pero si lo vuelvo a ejecutar 00:25:17
introduzco un nombre muy largo 00:25:20
porque tengo un nombre muy largo 00:25:22
el programa termina sin haber hecho nada 00:25:23
¿vale? 00:25:26
no me saluda 00:25:30
luego siguiente cosa que ya incorporamos 00:25:31
la rama del else 00:25:38
se puede quitar si está vacía 00:25:40
¿se puede quitar 00:25:42
la rama del if si está vacía? 00:25:49
no, imaginaos por ejemplo 00:25:50
que queremos cambiar el código 00:25:54
y decir 00:25:56
imaginaos que hemos puesto 00:25:58
aquí la condición 00:26:00
en lugar de menor que 10 00:26:01
mayor o igual que 10 00:26:03
en este caso no queremos 00:26:05
que nos salude 00:26:07
y en el caso de que no 00:26:08
sea mayor o igual que 10 00:26:11
en este caso sí 00:26:13
¿vale? 00:26:14
es decir, repito 00:26:22
imaginaos que yo he puesto la condición 00:26:23
así, porque me ha dado la gana ponerla así 00:26:27
me ha dado la gana ponerla así 00:26:28
pues para que el programa 00:26:30
siga haciendo lo que tiene que hacer 00:26:32
ahora es en la rama del sí 00:26:34
en la que no puede hacer nada 00:26:37
porque si es mayor o igual que 10 no hagas nada 00:26:38
y es en la rama del no 00:26:39
en la de menor que 10 en la que me saludaría 00:26:42
¿verdad? 00:26:44
entonces si yo he puesto la condición al revés 00:26:46
esta es la que se queda vacía 00:26:48
y esta es la que tiene el contenido 00:26:51
¿verdad? si es que la he puesto al revés 00:26:53
vale, entonces yo digo 00:26:55
uy, esta se ha quedado vacía 00:26:59
¿la puedo quitar igual que antes 00:27:02
quité el else cuando se quitó vacío? 00:27:04
la del if no se puede quitar 00:27:06
si está vacía, pues la dejas vacía 00:27:09
¿por qué no se puede quitar? 00:27:10
hombre, pues porque es la que tiene la condición 00:27:13
si yo la quito 00:27:15
¿dónde pongo la condición? en el se, no 00:27:17
esa es la sintaxis, no me lo permite 00:27:18
entonces la rama del if, aunque en el caso 00:27:20
del si 00:27:23
aunque yo tenga una 00:27:24
que en la del si 00:27:27
sea en la que no haga nada 00:27:29
y en la del no sea en la que 00:27:31
haga cosas, como es este 00:27:33
caso, en la del si no hace nada 00:27:35
y en la del no, no hace cosas 00:27:37
o sea, este diagrama es esto 00:27:39
aunque lo tenga 00:27:40
el if no lo puedo quitar 00:27:42
se queda ahí vacío, no hace nada 00:27:44
pero claro, efectivamente 00:27:46
este programa 00:27:53
con un if vacío 00:27:55
aunque funciona y hace 00:27:56
lo mismo que hacía el otro 00:27:58
hace lo mismo, lo que pasa es que al haber cambiado la condición 00:28:00
he cambiado una rama por la otra 00:28:03
aunque funciona y hace lo mismo 00:28:04
introduzca su nombre 00:28:07
aquí me va a saludar, muy bien 00:28:08
Pero si pongo uno muy largo 00:28:10
Pues aquí no me va a saludar 00:28:12
No me saluda y terminó 00:28:14
Aunque hace lo mismo 00:28:16
Este código sería muy feo a la vista 00:28:17
Tú ves esto y dices 00:28:20
Jolín, un if sin nada adentro, que horrible 00:28:22
Porque un if 00:28:24
Sin el else colgando 00:28:26
Es bonito, está bien, lo ves y dices 00:28:28
Pero un if sin nada adentro 00:28:30
Y el else con cosas 00:28:32
Esto a la vista es bastante feo 00:28:34
Pero claro, hay una forma muy fácil de arreglarlo 00:28:36
¿Cómo lo arreglamos para que sea el if el que tenga las cosas y el else el vacío? 00:28:39
Poniendo la condición contraria, ya está. 00:28:45
Si yo identifico que me ha quedado un if vacío y un else con cosas, ¡qué feo! 00:28:50
Pues hago el negado de la condición. 00:28:55
El negado, la condición justo opuesta, la negada. 00:28:58
Y si yo niego esta condición, entonces esto pasa aquí. 00:29:02
y el que se queda vacío es el otro 00:29:06
¿verdad? si pongo la condición 00:29:09
justo opuesta 00:29:11
¿cómo puedo negar 00:29:12
fácilmente una condición? 00:29:15
con el operador no delante 00:29:17
es decir 00:29:19
si yo pongo esto 00:29:20
¡ala! ya negué 00:29:22
mi condición 00:29:25
la negué, voy a poner entre paréntesis 00:29:26
claro, para que se vea que estoy negando 00:29:30
todo eso, ¿veis? 00:29:31
ese es el operador que niega una condición 00:29:33
negada 00:29:35
si no se cumple toda esta 00:29:37
negada, pues entonces si yo la niego 00:29:40
automáticamente 00:29:41
esto pasa arriba 00:29:43
y el else es el que se queda vacío 00:29:44
si yo pongo la condición 00:29:48
negada, justo la opuesta 00:29:50
y yo siempre puedo negar una condición 00:29:51
poniendo el no delante 00:29:54
poniendo el no, si yo la niego 00:29:55
lo del else pasa al if 00:29:58
y lo del if pasa al else 00:29:59
entonces ahora ya esto me queda más bonito 00:30:01
y el else ya lo podría quitar 00:30:03
este else ya 00:30:05
se podría eliminar 00:30:07
¿vale? y ya esto me queda un código 00:30:09
más bonito 00:30:11
ahora ya sí 00:30:12
a ver, otra cosa es que 00:30:17
luego vea yo la condición como me queda 00:30:22
y mire a ver, oye voy a reescribir la manchula 00:30:24
porque me ha quedado muy fea, hombre pues decir 00:30:26
no es el nombre 00:30:28
mayor o igual que 10 00:30:30
es igual que decir y me va a quedar 00:30:32
más bonito, ¿verdad? 00:30:34
esto es lo mismo 00:30:36
que decir lo que hemos escrito antes 00:30:37
nombre.le 00:30:40
menor que 10 00:30:43
es decir, no 00:30:46
mayor o igual que 10 00:30:48
es lo mismo que decir menor que 10 00:30:50
pues hombre 00:30:52
esta condición, aun siendo 00:30:54
idéntica a esta 00:30:56
aun siendo idéntica 00:30:57
es más fea que esta 00:30:59
es más fea, aun siendo idéntica 00:31:01
siendo lo mismo 00:31:03
no eres mayor de 23 años 00:31:03
eres menor de 23 00:31:07
es lo mismo 00:31:10
significa lo mismo 00:31:11
pondríamos esta 00:31:13
pero a ver, lo que yo quería decir ahora es 00:31:16
que si tú tienes una condición, la que sea 00:31:18
y la niegas 00:31:20
y la niegas, pues lógicamente 00:31:22
lo del ELSE 00:31:25
se convierte en el IF y lo del IF pasa al ELSE 00:31:26
entonces siempre puedes 00:31:29
intercambiar la rama del sí 00:31:31
con la del no, negando la condición 00:31:33
y así la dejas 00:31:35
lo dejas más bonito, si es que lo quieres 00:31:37
dejar más bonito, porque el leaf se había quedado vacío 00:31:39
como fuera 00:31:41
vale 00:31:42
pues vamos a ver que enunciados 00:31:47
tenemos por aquí 00:31:53
para 00:31:54
que podáis arrancar a hacer antes 00:31:58
porque hay muchas modificaciones 00:32:01
y un montón de casuísticas y un montón de cosas 00:32:03
con la incidencia de decisión que hay que seguir viendo 00:32:05
Pero bueno, entonces seguir con el rollo y vamos a ver qué cosa hay por aquí para que 00:32:06
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado básico
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
5 de octubre de 2026 - 12:39
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
32′ 11″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
599.58 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid