Saltar navegación

20261005 SentenciaIf_1 - 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

Bueno, pues estamos aquí, ¿verdad? Estos son los ejercicios que dejamos la última media horita del viernes pasado para que practicarais, ¿vale? 00:00:04
Espero que lo hayáis hecho y si tenéis algún problema o cosa, pues me lo decís. 00:00:19
Y qué más cosas hay aquí puestas. 00:00:25
esto 00:00:27
lo vamos a dejar un poquito 00:00:29
por ahora 00:00:33
son simplemente como 00:00:34
nosotros tenemos que usar el tipo string 00:00:36
desde ya, porque nuestras aplicaciones 00:00:39
necesitan usar cadenas de texto 00:00:41
una aplicación 00:00:43
que no use cadenas de texto 00:00:45
es muy raro 00:00:47
pues aparte de 00:00:48
saber declarar 00:00:51
la variable 00:00:52
que va a contener esa cadena de texto 00:00:55
que ya sabemos como declararla 00:00:57
pues con este tipo de dato que es especial 00:00:58
porque es objeto 00:01:02
aunque todavía no lo entendamos 00:01:03
ni sabemos por qué es especial 00:01:05
aparte de saber declararla 00:01:06
y de saber asignarle cosas 00:01:08
que ya sabemos cómo se le asigna algo 00:01:10
a una variable string, pues como a cualquier otra variable 00:01:13
asignándole algo compatible 00:01:15
que sea una cadena de texto 00:01:17
literal entre comillas dobles 00:01:19
o otra variable string 00:01:21
o la concatenación de dos cosas 00:01:23
¿verdad? 00:01:26
la concatenación de dos cosas, también es un string, esto concatenado con lo que hay en esta variable, 00:01:28
pues eso es lo único que sabemos hacer ahora mismo con string. 00:01:39
Entonces, el hecho de que las variables string sean de ese tipo especial, que lo decimos ahora sin entender lo que es, 00:01:43
que es de tipo objeto, les da unas posibilidades que no tienen las variables normales, 00:01:52
las variables primitivas, como los números entre los i decimales, los char y los boole. 00:02:02
¿Vale? Esas son las variables de tipo primitivo. 00:02:10
Bueno, pues esta, al ser variable objeto, ese nombre que no sabemos qué significa, 00:02:13
tiene unas posibilidades 00:02:18
que no tienen estas variables primitivas 00:02:21
entonces las recojo aquí un poquito 00:02:24
pero para no aburrirnos ahora mirando esto 00:02:26
como no vamos a poder entenderlo en realidad 00:02:30
es solo recoger lo básico para poder usarlo 00:02:33
vamos a empezar con la sentencia de decisión 00:02:35
y según vayamos viendo ejercicios 00:02:40
en los cuales usemos cadenas de texto 00:02:44
es decir, usemos string 00:02:47
según vayamos viendo esos ejercicios 00:02:50
pues iremos viendo 00:02:52
estas 00:02:53
posibilidades, funcionalidades 00:02:54
que tienen las cadenas de texto 00:02:57
¿vale? 00:03:00
que nos van a, para poder hacer unas cosas 00:03:01
mínimas con ellas, para poder hacer unas cosas 00:03:03
mínimas, aparte de lo que ya sabemos 00:03:05
que es concatenar 00:03:07
¿vale? 00:03:08
bueno, pues entonces vamos ahora con esto de aquí 00:03:11
la sentencia de decisión 00:03:13
¿vale? 00:03:15
Ahí lo tenéis todo recogido en ese fichero. 00:03:17
Bueno, pues vamos allá. 00:03:29
Vale, entonces hasta ahora nuestros programas eran exclusivamente una sucesión de sentencias, por supuesto, una tras otra, porque eso es un programa, una sucesión de sentencias. 00:03:33
Pero esas sentencias hacían un conjunto muy reducido de cosas, porque era lo único que sabíamos hacer, ¿verdad? 00:03:52
Esas sentencias podían declarar variables, eso sabemos hacerlo, declarar una variable para que esa variable ya me contenga un dato y yo pueda ya operar con él, hacer asignaciones y ya sabemos lo que es hacer una asignación. 00:03:59
A una variable le asigno un valor. Y bueno, la complejidad de esta primera parte era, ¿qué puedo poner yo aquí? Pues desde el valor directamente hasta una expresión que combine operadores, cuyo resultado sea un valor compatible, pero al fin y al cabo no dejará de ser una asignación, que es lo que hemos estado practicando todo este tiempo. 00:04:28
construir expresiones 00:04:53
válidas, cuyo único 00:04:56
resultado, cuya única finalidad 00:04:58
es asignarse 00:05:00
a una variable de un tipo compatible 00:05:02
ya está, entonces con esas 00:05:04
operaciones, construíamos 00:05:06
expresiones que se asignaban a la variable 00:05:08
y luego también 00:05:10
hemos sabido mostrar por pantalla 00:05:12
esos valores 00:05:14
mostrarlos por pantalla 00:05:17
con un system out 00:05:19
println los hemos mostrado por pantalla 00:05:20
vale 00:05:23
y dentro de las asignaciones 00:05:24
también hemos sabido 00:05:27
hacer una asignación 00:05:29
de un valor que venía 00:05:31
del teclado, eso también lo hemos sabido 00:05:33
hacer 00:05:35
las asignaciones que es lo que nos ha 00:05:35
llevado pues más tiempo 00:05:41
las hemos hecho 00:05:43
valor tal cual 00:05:45
construyendo una expresión 00:05:46
la variante condicionada 00:05:48
que es o asigno esto 00:05:50
o asigno esta otra cosa 00:05:52
en función de la expresión 00:05:54
o asigno un valor 00:05:56
leído del teclado 00:05:58
¿vale? pues una secuencia 00:05:59
de sentencias 00:06:02
de estos tipos 00:06:04
de aquí han construido nuestros programas 00:06:06
hasta ahora ¿vale? hemos 00:06:08
visto algo más, hemos hecho algo más que eso 00:06:10
bueno 00:06:12
lógicamente 00:06:16
solamente con estas sentencias 00:06:18
no podemos realizar 00:06:20
todo, cualquier función 00:06:23
que queramos hacer, no podemos 00:06:25
nos quedamos muy cortos 00:06:26
no podemos solamente construyendo expresiones 00:06:28
elaborar 00:06:31
la solución para cualquier problema 00:06:33
que nos planteen, es imposible 00:06:35
se queda muy corto 00:06:37
todo esto, tenemos que tener más posibilidades 00:06:38
para hacer cosas 00:06:41
¿no? por ejemplo 00:06:42
si a mí me dicen 00:06:45
programa que 00:06:47
solicite 00:06:48
nombres 00:06:51
de usuario 00:06:54
y te diga 00:06:55
cuáles de ellos están en castellano 00:06:58
por ejemplo, y cuáles están 00:07:00
en otro idioma, bueno, más que nombres, palabras 00:07:02
los nombres son más 00:07:04
asépticos en el idioma 00:07:06
entonces 00:07:07
y además nos dicen, ese programa 00:07:09
finalizará 00:07:12
cuando el usuario introduzca como 00:07:13
nombre, fin 00:07:16
¿vale? eso podría ser un programa 00:07:17
perfectamente que nosotros podríamos querer 00:07:20
programar, ¿programa qué? 00:07:22
dame una 00:07:25
dame una palabra 00:07:26
castellano 00:07:28
dame una palabra 00:07:29
inglés, luego habría que ver cómo 00:07:31
averiguamos si es castellano o inglés, pero esa parte 00:07:34
ya me importa menos, dame una palabra 00:07:36
francés, ¿vale? te va dando 00:07:38
respuestas a palabras que tú 00:07:42
vas introduciendo, dame una palabra 00:07:44
Eh, fin 00:07:45
Ah, pues aquí termino 00:07:48
¿Vale? Podría ser una propuesta de programa 00:07:49
Que nos hace 00:07:52
Entonces 00:07:53
¿Con qué problema nos encontramos aquí a la hora 00:07:55
De elaborar esto? 00:07:58
Pues que como lo hacemos, podríamos decir 00:08:02
Vale, pues yo le hago un siso 00:08:04
Dame palabra 00:08:05
Leo la palabra 00:08:10
con el 00:08:15
next como sea 00:08:21
ahora incorporaremos como leer un 00:08:23
porque solamente sabemos leer números hasta ahora 00:08:25
números y boolean, leo la palabra 00:08:27
aquí hago lo que tenga que hacer 00:08:28
para 00:08:31
que esa parte, estas sentencias 00:08:33
son las que me importan ahora 00:08:35
y aquí ya pongo el resultado 00:08:37
vale, lo que sea 00:08:39
pero esto yo lo 00:08:41
tengo que hacer de forma indefinida 00:08:44
pues con lo que sabemos hacer ahora 00:08:46
todo esto 00:08:48
lo pondría aquí otra vez 00:08:49
muy bien 00:08:52
todo esto lo pondría aquí otra vez 00:08:53
entonces si el programa me estaría 00:08:56
dame palabra, la lee, me da el resultado 00:08:57
dame palabra, la lee, me da el resultado 00:09:00
pero claro, me veo yo de repente 00:09:03
diciendo, pero vamos a ver 00:09:04
¿cuántas veces escribo esto? 00:09:06
¿cuántas veces lo escribo? no sé 00:09:08
porque yo no sé cuántas 00:09:10
veces voy a tener que hacer 00:09:12
esto, porque el usuario 00:09:14
me ha dicho, el que me ha pedido el programa 00:09:16
me ha dicho, oye, el programa 00:09:19
tiene que dejar de hacerte 00:09:21
esto, de pedirte esto, cuando 00:09:23
tú tecles la palabra 00:09:24
fin, entonces ahí termina 00:09:27
vale, muy bien 00:09:29
pero tú cuando estás programando esto 00:09:30
tú no sabes cuándo va a llegar 00:09:32
esa palabra fin, entonces tú 00:09:35
como programador que estás haciendo el código 00:09:36
¿cuántas veces escribes esto? 00:09:38
no sabes, no tienes 00:09:41
ni idea, lo escribes siete veces 00:09:43
Pues entonces tu programa va a pedir siete palabras, independientemente de cuándo haya escrito el usuario fin. 00:09:45
¿Lo escribes cien veces? 00:09:50
Pues entonces el programa te va a pedir cien palabras, independientemente de cuándo hayas escrito tu fin. 00:09:53
Luego, con las herramientas que tenemos ahora, este programa sencillo que nos han planteado, no podemos resolverlo. 00:10:00
Porque nos vemos en la duda de, ¿y cuántas veces repito yo esto? 00:10:08
Claro, porque necesitamos un tipo de sentencia adicional 00:10:12
Que no hemos visto 00:10:16
Claro, necesitaríamos 00:10:19
Ah, vale, es que yo necesito una sentencia que me permita repetir algo 00:10:21
Mientras no se cumpla una condición de finalización 00:10:26
Es lo que necesito 00:10:32
Una sentencia de Java que me diga 00:10:33
Repite esto mientras no ocurra lo siguiente 00:10:36
Nosotros no sabemos programar eso 00:10:40
Nos conocemos esa sentencia 00:10:43
La sentencia nos falta 00:10:45
La sentencia que le dice a Java 00:10:46
Repite esto 00:10:48
En nuestro caso sería esto de aquí 00:10:49
Repite esto 00:10:51
Una vez y otra vez y otra vez 00:10:54
Mientras se dé una condición 00:10:55
La que sea en este caso sería 00:11:00
Mientras la palabra introducida 00:11:03
Sea diferente de fin 00:11:05
Mientras la palabra 00:11:06
Sea diferente de fin 00:11:09
Vale, pues deberíamos ser capaces de programar esto 00:11:10
Un código que se repite un montón de veces 00:11:16
No tengo yo que escribir una tras otra 00:11:20
Porque es que yo no sé cuántas veces se va a repetir 00:11:22
Depende de cuándo introduzca el usuario 100 00:11:24
Pues tendría que ser yo capaz de escribir una sentencia 00:11:27
Que le explique a Java 00:11:30
Repite esto mientras esta condición sea cierta 00:11:32
Repítelo 00:11:37
Vale, eso sería pues un bucle, ¿verdad? Eso es lo que se llamaría un bucle. Bueno, pues esa es una sentencia que nos falta para poder hacer cosas. Y también nos falta otra sentencia más. 00:11:38
Por ejemplo, una situación en la que nos dicen, a ver, hazme un programa, por favor, que te solicite un número y si el número es primo te haga no sé qué cosa y si no es primo te haga otra cosa diferente. 00:11:56
entonces, con lo que hemos visto hasta ahora 00:12:24
no sabemos programar eso 00:12:28
nosotros sabemos en función de una condición 00:12:30
asignar un valor 00:12:33
a una variable 00:12:35
asignar un valor o asignar otro 00:12:36
en función de una condición, eso si sabemos, ¿verdad? 00:12:38
nosotros sabemos 00:12:41
a una variable en función 00:12:42
de una condición 00:12:45
asignarle o el valor 00:12:46
este o el valor este 00:12:49
pero no sabemos 00:12:50
en función de una condición 00:12:52
hacer toda una ristra de cosas 00:12:54
o hacer otra, eso no lo sabemos 00:12:56
¿vale? y necesitaríamos 00:12:59
saberlo hacer para hacer un programa 00:13:01
como el que me han dicho 00:13:03
oye, introduce un número 00:13:04
si es primo, por favor, opera 00:13:06
con él para hacer no sé qué 00:13:09
si no es primo, hace estas otras cosas 00:13:10
con lo que conocemos 00:13:13
no sabemos hacer ese programa 00:13:15
claro, porque necesitamos 00:13:16
una sentencia en Java que nos permita expresar 00:13:18
esa idea, la idea de que 00:13:21
en función de una condición, mi programa hace toda una serie de cosas 00:13:23
o si no hace una serie de cosas diferentes. 00:13:26
Esa sería la sentencia de decisión o selectiva. 00:13:31
Luego, nos faltan sintaxis de sentencias de Java 00:13:37
para poder hacer cualquier cosa que se nos pida en un enunciado, en una aplicación. 00:13:41
Pero la buena noticia es que existe una cosa que es de la estructura o del programa estructurado 00:13:49
¿Y qué dice esto? 00:14:11
Pues esto, los teóricos de la programación allá en su momento averiguaron que cualquier problema, cualquiera, cualquiera, cualquiera 00:14:18
que una CPU 00:14:27
pueda resolver, una CPU tradicional 00:14:29
como las que están en todos los ordenadores 00:14:32
que tenéis, tablets, móviles, etc. 00:14:33
Cualquier problema que una CPU 00:14:36
pueda resolver mediante 00:14:37
sentencias de código que llegan 00:14:39
hace sus operaciones y las envía a los buses 00:14:43
cualquiera, se puede 00:14:45
elaborar simplemente 00:14:48
combinando en secuencia 00:14:49
estas estructuras que hemos 00:14:52
visto, la asignación por supuesto, esa se asume, la entrada de datos lógicamente, pues 00:14:56
combinando exclusivamente bucles como los que he planteado antes por encima sin explicar 00:15:01
y decisiones, pues combinando exclusivamente sentencias de bucle y sentencias de decisión 00:15:08
en secuencia, se puede hacer cualquier, se puede elaborar cualquier programa, no hace 00:15:16
falta nada más, no hace falta ninguna otra 00:15:25
estructura de programación 00:15:27
nada más 00:15:28
bueno, pues los 00:15:30
programas que usan exclusivamente 00:15:33
esas cosas 00:15:34
que son, por supuesto, lectura de datos 00:15:35
y asignaciones, es inevitable, si no tengo datos 00:15:38
de partida, pues no puedo hacer nada, eso lo damos por sentado 00:15:40
que cualquier lenguaje de programación 00:15:43
permite incorporar 00:15:45
datos a sus variables 00:15:47
mediante asignaciones 00:15:48
pues los programas que usan 00:15:50
exclusivamente en secuencias 00:15:53
sentencias de ese tipo bucles y decisiones bucles y decisiones bucles y 00:15:54
decisiones más repito la asignación de datos son programas estructurados 00:15:59
y los lenguajes de formación estructurados son los que usan estas 00:16:06
sentencias y punto pelota y ninguna otra y para contar y cuáles son 00:16:17
absolutamente todos los que conocemos todos los que conocemos 00:16:22
¿Vale? Java incluido, son lenguajes de programación estructurados, porque solamente necesitan usar estas sentencias, bucles y decisiones, nada más. 00:16:27
Claro, la complicación viene de que hay que decidir correctamente cuáles, en qué orden hay que usarlas para que el programa haga lo que tiene que hacer, lógicamente, para que el programa haga lo que tiene que hacer. 00:16:37
Esa es la parte complicada. 00:16:51
bueno, pues 00:16:53
todo lo que hay más allá de esto 00:16:56
ahora ya es 00:16:59
cómo organizo mi código 00:17:02
entonces, la programación entrada a objetos 00:17:04
es única y exclusivamente 00:17:06
programación estructurada 00:17:09
a la que se le da 00:17:11
una manera de organizar 00:17:13
el código que permite 00:17:15
la reutilización, sobre todo 00:17:16
la mejora en mantenimiento 00:17:19
el poder trabajar 00:17:23
diferentes personas en diferentes 00:17:24
partes del programa, o sea la operación 00:17:27
orientada a objetos, lo que incorpora 00:17:28
es una manera de 00:17:31
organizar los problemas estructurados 00:17:33
ya está, no incorpora nada más 00:17:35
una manera de organizarlos 00:17:36
entonces, ¿Java es un lenguaje orientado a objetos? 00:17:38
por supuesto, pues como Python 00:17:41
como prácticamente todos 00:17:43
¿significa eso que no sean estructurados? 00:17:44
no tiene nada que ver, todos son 00:17:46
estructurados porque todos usan 00:17:48
esto en secuencia. 00:17:50
Si además son orientados a objetos, 00:17:53
la orientación a objetos lo que 00:17:55
hace es 00:17:57
ofrecer una forma de organizarlo. 00:17:57
Ya está. Nada más. 00:18:01
¿Vale? No son conceptos 00:18:03
separados. Lenguajes 00:18:04
estructurados, lenguajes orientados a objetos. 00:18:06
No. Se refieren 00:18:09
a cosas independientes. Por debajo 00:18:10
está el lenguaje estructurado 00:18:13
y luego cómo organizas tú ese código. 00:18:14
pues la programación orientada a objetos 00:18:16
te da una forma eficiente 00:18:20
de organizarlo 00:18:21
¿por qué es necesaria? 00:18:22
porque si usáramos solamente 00:18:25
los lenguajes 00:18:27
en su forma estructurada 00:18:29
o sea la secuencia de bucles, decisiones 00:18:31
todo estaría muy bien, podríamos hacer lo que quisiéramos 00:18:34
pero un programa 00:18:36
para hacer pues 00:18:37
una aplicación cualquiera 00:18:39
pues podría tener a lo mejor 00:18:40
5.300, 400 líneas 00:18:42
¿vale? está muy bien 00:18:45
funciona perfectamente, pero hombre 00:18:46
5.430 líneas se hace pesado 00:18:48
si de repente quiero 00:18:50
cambiar algo en su funcionalidad 00:18:52
buscar en un chorizo 00:18:55
de 5.430 líneas 00:18:57
se hace pesado 00:18:59
¿vale? 00:19:00
si yo ese código 00:19:04
se lo tengo que dar a alguien 00:19:05
para que lo entienda, lo mantenga 00:19:07
en el futuro, lo que sea 00:19:09
si le doy un chorizo de 5.430 líneas 00:19:10
pues se le va a hacer pesado 00:19:13
entonces la programación 00:19:14
y entrada a objetos 00:19:16
permite que los programas 00:19:16
no sean chorizos 00:19:18
de 5.430 líneas 00:19:19
ya está 00:19:21
única y exclusivamente 00:19:21
y al no ser chorizos 00:19:22
de 5.430 líneas 00:19:24
porque los separa en partes 00:19:26
pues esas partes 00:19:27
se pueden atacar 00:19:29
de forma separada 00:19:31
si yo tengo que tocar algo 00:19:32
voy a la parte 00:19:33
que tengo que modificar 00:19:34
y el resto de partes 00:19:35
ni se entera 00:19:36
esa es la filosofía 00:19:37
de la programación 00:19:39
y entrada a objetos 00:19:39
¿vale? 00:19:40
que ya iremos viendo 00:19:41
Bueno, pues entonces 00:19:42
¿Qué es lo que vamos a ver nosotros ahora? 00:19:45
Pues vamos a seguir incorporando 00:19:47
Sentencias de programación estructurada 00:19:49
Y la primera de ellas 00:19:52
La de decisión 00:19:53
La siguiente, los bucles 00:19:54
Bueno, pues la sentencia de decisión 00:19:57
Es muy fácil de entender 00:20:20
Conceptualmente 00:20:24
Tiene todo el sentido del mundo 00:20:25
Pensar 00:20:28
Que un programa 00:20:28
en función de una condición 00:20:30
necesite hacer una cosa 00:20:32
o necesite hacer otra 00:20:35
es una idea muy normal 00:20:37
ahí me dan los datos 00:20:39
de un usuario 00:20:43
entonces 00:20:45
si el usuario tiene rol administrador 00:20:46
yo voy a hacer una cosa 00:20:49
que es mostrarle la pantalla de administrador 00:20:52
si tiene rol 00:20:53
usuario normal 00:20:55
cliente, pues voy a hacer otra 00:20:57
que es mostrarle la pantalla de cliente 00:20:59
o sea continuamente los programas 00:21:01
en función de una condición 00:21:03
o tiran por un camino 00:21:05
o tiran por otro 00:21:07
continuamente 00:21:08
yo entro en una aplicación 00:21:09
¿qué día es una aplicación? 00:21:12
agenda, soy tu agenda 00:21:17
¿qué día soy? yo le pongo lunes 00:21:18
pues ese programa 00:21:20
si es lunes 00:21:22
me mostrará una cosa 00:21:25
pero si le pongo martes me mostrará otra 00:21:27
pero si le pongo miércoles me mostrará otra 00:21:29
entonces es una situación lo más natural del mundo 00:21:32
que un programa en función de una condición 00:21:34
sea la que sea 00:21:36
o necesite hacer una cosa 00:21:37
o necesite hacer otra 00:21:40
eso se ve muy bien 00:21:41
diagramas de flujo 00:21:45
que los diagramas de flujo 00:21:48
son una de tantas estructuras 00:21:50
como los pseudocódigos, como todo eso 00:21:51
que nos permiten en plan borrador 00:21:54
hacer nuestros primeros bocetos 00:21:56
de diseños de programas 00:21:58
antes de pasar a escribir código 00:21:59
antes de pasar a escribir código 00:22:01
pues uno se puede hacer 00:22:04
lógicamente se debería hacer 00:22:06
una primera idea de este programa 00:22:08
como voy a combinar aquí una decisión 00:22:10
y aquí me va a tocar un bucle porque tengo que repetir 00:22:12
muchas cosas 00:22:14
se lo puede hacer uno en papel o a ripet 00:22:15
o hay 00:22:18
pequeñas 00:22:19
herramientas, estándares 00:22:23
más o menos que usamos todos 00:22:26
pues para hacer esos bocetos 00:22:28
de cómo va a ser el diseño 00:22:30
de mi programa 00:22:32
una es el diagrama de flujo 00:22:33
pues por ejemplo, en diagrama de flujo 00:22:36
¿cuál sería el diagrama de flujo 00:22:38
de una sentencia de decisión? 00:22:40
pues bueno, el programa 00:22:46
me viene por aquí 00:22:46
este es el hilo del programa 00:22:47
el programa 00:22:49
está aquí y de repente 00:22:52
me pregunto yo si se cumple una condición 00:22:54
si la condición se cumple 00:22:59
yo ahora ya haré lo que toque hacer 00:23:05
si la condición no se cumple 00:23:10
ahora haré lo que toque hacer si no se cumple 00:23:13
cuando ya he terminado de hacer 00:23:16
lo que tengo que hacer cuando la condición se cumpla 00:23:19
el programita continúa su camino tranquilamente 00:23:22
Cuando ya he terminado de hacer 00:23:25
Lo que tengo que hacer 00:23:29
Si la condición no se cumple 00:23:30
El programita continúa su camino 00:23:31
Tranquilamente hasta su final 00:23:33
Con las sentencias que haya por aquí 00:23:35
¿Vale? 00:23:37
Es decir, aquí podría haber más sentencias 00:23:38
Y aquí también podría haber más sentencias 00:23:40
¿Vale? 00:23:48
Cada cuadradito 00:23:57
En el diagrama de flujo 00:23:59
Cada cuadrado significa 00:24:01
Pues un bloquecito de sentencias 00:24:02
Este sería el inicio del programa 00:24:04
Y este sería el final 00:24:09
Este sería el diagrama de flujo 00:24:10
De un programita 00:24:14
Que usa una sentencia de decisión 00:24:15
El programa arranca 00:24:17
Aquí hará cosas 00:24:20
Cuadradito significa 00:24:22
Unas cuantas sentencias 00:24:24
Como las que hemos hecho hasta ahora 00:24:25
Ahora de repente 00:24:27
Nos damos cuenta de que 00:24:29
En función de una condición 00:24:31
O hay que hacer una cosa o hay que hacer otra 00:24:33
Es decir, no hay que hacer esto siempre 00:24:35
O esto siempre, no lo sé 00:24:37
Depende de una condición 00:24:39
Si la condición se da, hago esto 00:24:40
Y si no se da, hago esto 00:24:42
Por ejemplo 00:24:44
Una agenda que te dice lo que tienes que hacer 00:24:48
En función de si es laborable o es festivo 00:24:52
Pues la agenda arranca 00:24:55
Aquí te muestra, hola, ¿qué tal? 00:24:57
Soy la agenda, patatín, patatán 00:24:58
Te muestra no sé cuántos 00:25:00
Y ahora lo que tiene que hacer la agenda es diferente en función de si es laborable o si es testigo 00:25:01
Por lo cual le toca hacerse la pregunta, sí o sí, no hay tutía, le toca hacerse la pregunta 00:25:07
Por lo cual aquí se abre la sentencia de decisión 00:25:13
La pregunta en diagrama de flujo se pone en rombito siempre 00:25:17
Me toca hacerse la pregunta, se hace la pregunta 00:25:22
Si esto es cierto, hace lo que tenga que hacer 00:25:25
y si es falso hace lo que tenga que hacer 00:25:29
y luego continúa 00:25:33
me da igual que haya ido por aquí 00:25:35
que haya ido por aquí 00:25:37
entonces mi agenda 00:25:38
programa arranca 00:25:40
hola que tal soy la agenda patatín patatán 00:25:41
te muestra lo que sea 00:25:43
ahora se hace la pregunta 00:25:44
el programa 00:25:46
es laborable 00:25:47
se va por aquí 00:25:48
pues tienes que ir a recoger a no se quien patatín patatán 00:25:50
comprar el pan no se cuantos 00:25:52
no es laborable 00:25:54
Pues tienes que dormir hasta las 10 y regar las plantas 00:25:56
Vale 00:26:00
En ambos casos, una vez que ha hecho lo que toca 00:26:00
Tanto si se cumple como si no se cumple 00:26:05
El programa terminará 00:26:07
Como por ejemplo, adiós, me voy y voy a cerrar el programa 00:26:08
No te olvides de hacer lo que te he dicho, etc. 00:26:11
Bueno, pues este diagrama de flujo 00:26:18
Es el diseño de un programa que usa una sentencia de decisión 00:26:20
Nuestro problema ahora 00:26:25
Si hemos entendido realmente 00:26:29
Su utilidad 00:26:31
Y por qué son imprescindibles 00:26:32
Si lo hemos entendido 00:26:35
Nuestro único problema ahora es 00:26:37
Cómo lo programamos 00:26:38
Entonces, recopilando 00:26:39
Primero, tenemos que saber 00:26:47
Que esta posibilidad existe 00:26:49
Lógicamente, que un programa 00:26:51
Haga una serie de cosas 00:26:53
O haga otras en función de una condición 00:26:55
Esa posibilidad existe 00:26:57
segundo 00:26:59
tengo yo que ir cogiendo soltura 00:27:01
lógicamente en identificar 00:27:04
cuando tengo un enunciado 00:27:05
anda, aquí voy a necesitar una sentencia 00:27:07
de decisión, porque lo que me están 00:27:10
pidiendo hacer, o bien 00:27:12
se hace de esta manera, o bien se 00:27:14
hace de esta otra en función de una condición 00:27:16
luego yo tengo que identificar 00:27:18
pues voy a necesitar una sentencia 00:27:20
de decisión, porque mi programa 00:27:22
viene a hacer esto, viene a hacer lo otro en función de la condición 00:27:24
entonces yo lo identifico, porque soy el que 00:27:26
programo, lo identifico 00:27:28
Y luego ya compongo mi programa. Ah, vale, pues la voy a tener que poner aquí, primero pongo lo siguiente, luego lo compongo, hago mi primer diseño y mi boceto. Y luego ya, pues programar esto, una vez que ya sé la sintaxis de esto, pues es inmediato. 00:27:29
entonces, ¿alguien tiene alguna duda 00:27:47
sobre el sentido 00:27:51
la razón 00:27:52
de por qué hay que incorporar 00:27:53
sentencias de decisión en un lenguaje 00:27:56
estructurado 00:27:58
y a qué situaciones 00:27:59
aplica 00:28:02
nadie, ¿no? 00:28:03
¿tienen ninguna duda de por qué existen? 00:28:06
bueno, pues entonces, ¿qué es lo que nos queda? 00:28:09
ver cómo es 00:28:12
la sintaxis que nos permite 00:28:12
programar esto 00:28:15
que hay unas cuantas posibilidades 00:28:17
con matices cada una de ellas 00:28:22
y yo decido pues en cada momento 00:28:24
pues a lo mejor cuál pega más, etc. 00:28:26
Vale, pues a ver 00:28:30
vamos a ver la sintaxis 00:28:31
de la sentencia de decisión básica 00:28:33
que es esto de aquí 00:28:36
si la condición se cumple hago una cosa 00:28:37
y si no se cumple hago otra 00:28:40
Vale, pues la sintaxis sería 00:28:43
mi programita viene por aquí 00:28:52
hace lo que tenga que hacer, que sería esto 00:28:54
por ahí viene mi programita, hace lo que tiene que hacer 00:28:56
ahora llega el momento 00:28:58
de hacerse la pregunta 00:29:00
porque en función del resultado 00:29:01
de la pregunta, o hago una cosa 00:29:04
o hago otra, pues cuando llega 00:29:06
el momento de hacerse la pregunta 00:29:08
como no podía ser de otra manera 00:29:10
pues yo escribo if 00:29:12
si pasa esto, hace una cosa y si no otra 00:29:13
y aquí pongo 00:29:16
esa pregunta, que esa pregunta 00:29:18
¿Qué es? Un booleano, una condición. Aquí pongo mi condición, algo que puede ser true o false. Ahí pongo mi condición. Y ahora, lo que viene justo después, yo ahora entre llaves, aquí pongo lo que haría en el caso de que se cumpla. 00:29:20
¿vale? esto sería la rama del true 00:29:55
si se cumple la condición 00:29:58
esto es lo que se hace 00:30:02
luego después pongo el se 00:30:03
abro otro bloquecito de llaves 00:30:08
y si no se cumple 00:30:10
lo que hay que hacer en ese caso se pone aquí 00:30:14
y ya está 00:30:18
ya terminó 00:30:20
una de las posibilidades de sintaxis 00:30:22
la más estándar 00:30:24
¿vale? 00:30:26
esto es exactamente esto 00:30:27
que la condición se cumple hago esto 00:30:30
si no se cumple hago esto otro 00:30:33
y luego ya el programa sigue por debajo tranquilamente 00:30:37
ahí sigue, igual que seguía por aquí 00:30:40
me da igual haber hecho esto o haber hecho esto otro 00:30:42
una de las dos cosas habré hecho lógicamente 00:30:45
porque la condición o es true o es false 00:30:48
no hay un término medio 00:30:50
o es true o es false 00:30:52
una de las dos habré hecho 00:30:53
o he ido por aquí 00:30:54
o he ido por aquí 00:30:56
no hay otra 00:30:59
pero me da igual haber ido por aquí 00:31:02
que haber ido por aquí, llega un momento en que ya he terminado 00:31:04
lo que tengo que hacer 00:31:06
esto va aquí y esto va aquí 00:31:07
llega un momento en que ya he terminado 00:31:10
lo que tengo que hacer y sigo 00:31:12
y mi programa sigue 00:31:14
con lo que tenga que hacer después 00:31:15
que en este caso iría después de las llaves estas 00:31:17
vale, pues esta es la sentencia básica 00:31:19
Entonces, si la practicamos aquí para ir incorporando matices, vale, pues por ejemplo, venga, voy a hacer un proyecto cualquiera de pruebas, pruebas de sentencia y decisión, paquete ejemplos. 00:31:31
Vale, pues venga 00:32:57
Vamos a 00:33:33
Dos números 00:33:38
Por ejemplo 00:33:52
Si son distintos 00:33:58
Te muestra la suma 00:34:00
Y si son iguales 00:34:07
Vamos a hacer algo 00:34:13
Que implique varias sentencias 00:34:17
Para que no sea algo que no haríamos 00:34:18
Con el operador ternario básico 00:34:20
Y si son iguales 00:34:22
Te avisa 00:34:24
Te solicita 00:34:36
Te solicita 00:34:39
Otra vez 00:34:41
Los números 00:34:45
Y ahora ya sí que sí los suma 00:34:49
Aunque sean iguales 00:34:53
Porque si no tendríamos que meternos en un bucle 00:34:56
Que no sabemos hacer 00:34:57
Vale, pues venga 00:34:58
Programa te pide dos números 00:35:01
Si son diferentes te muestra la suma 00:35:03
Y si son iguales te da una segunda oportunidad, pidiéndotelos otra vez, y en ese caso ya te hace la suma, o sea, te da una segunda oportunidad, ya no más, ¿vale? Por ejemplo, entonces esto no nos lo plantearíamos hacer con un operador ternario, porque el operador ternario podríamos hacer la condición de ser iguales, pero en el caso de que sean iguales todavía no tenemos la asignación lista, tendríamos que seguir pidiendo cosas, 00:35:06
Entonces esto, como hacíamos en los videos anteriores, no podíamos 00:35:32
Vale, pues entonces 00:35:36
Vamos a declarar primero las variables que necesitamos 00:35:40
Número 1 y número 2 00:35:45
Como vamos a leer del teclado 00:35:50
Pues venga, el objeto este famoso 00:35:53
Ahora leemos los datos 00:35:57
Vale, pues venga, vamos a leer los datos 00:36:13
Número 1 00:36:16
Igual a 00:36:20
Scan.nextin 00:36:22
Bueno, vamos a poner el mensajito 00:36:27
Número 1 00:36:31
Y número 2 00:36:37
Vale, hasta aquí no hay duda 00:36:46
El programa 00:36:54
Ha solicitado dos números enteros por teclado 00:36:56
Y ahí los tiene 00:36:59
y ahora es cuando empezamos a pensar en el algoritmo 00:37:00
que es, vamos a ver 00:37:02
¿qué hago? pues es que depende 00:37:03
porque hago cosas completamente 00:37:06
diferentes en ambos casos 00:37:08
si son diferentes 00:37:10
directamente los sumo 00:37:12
y muestro la suma 00:37:14
y si son iguales me viene 00:37:15
pedirlos otra vez 00:37:17
leerlos otra vez 00:37:21
ahora y así hacer la suma 00:37:22
hago dos cosas completamente distintas 00:37:24
entonces aquí es cuando yo identifico 00:37:26
que aquí ya 00:37:28
Me tengo que ir por dos ramas separadas 00:37:29
No hay otra 00:37:32
O me voy por una rama o me voy por otra 00:37:32
Porque hago dos cosas diferentes 00:37:35
Entonces aquí es cuando identifico que tengo que poner una sentencia de decisión 00:37:36
Digo, a ver 00:37:39
En función de una condición 00:37:40
O bien hago una cosa 00:37:42
O bien hago otra 00:37:44
¿Vale? 00:37:47
Aquí lo identifico 00:37:49
Que a partir de aquí mi programa se ramifican dos 00:37:50
Porque aquí ya sí que tengo que mirar 00:37:53
Como son los números 00:37:57
Y hago dos cosas completamente distintas 00:37:59
Completamente 00:38:01
Si son iguales a si son diferentes 00:38:02
Completamente 00:38:04
Entonces a partir de aquí no me queda más remedio 00:38:05
Que poner una sentencia de decisión 00:38:07
Con su sintaxis correcta 00:38:10
En la cual en función de una condición 00:38:12
O bien hago algo 00:38:14
O bien hago 00:38:16
Otra cosa 00:38:19
¿Vale? 00:38:21
Vamos a parar aquí antes de completarla 00:38:23
Y la completamos a la vuelta 00:38:26
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 - 11:15
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 28″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.10

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid