Saltar navegación

20251008 ProgEstr-Decision_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 8 de octubre de 2025 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, vamos a continuar con esto que es muy sencillo, ¿vale? 00:00:00
Recordad que lo que estamos viendo ahora es la programación estructurada, 00:00:07
que es elaborar algoritmos, lo que pasa es que esos algoritmos los escribimos directamente en un lenguaje de programación, 00:00:11
pero podríamos escribirlo con nuestro propio lenguaje, lee número, suma al número un 7, 00:00:20
podríamos escribirlo con nuestro propio lenguaje 00:00:28
pero bueno, los estamos escribiendo con Java 00:00:30
bueno, lo que estamos haciendo es 00:00:32
elaborar algoritmos 00:00:34
según los principios de programación estructurada 00:00:35
que son 00:00:38
el algoritmo, en nuestro caso 00:00:39
programa, porque está escrito en Java 00:00:42
pero es lo mismo, el algoritmo 00:00:44
barra programa 00:00:46
es una secuencia ordenada 00:00:47
es decir, una tras otra, pin, pin, pin 00:00:50
de sentencias 00:00:52
o instrucciones, una secuencia ordenada 00:00:53
infinita, por supuesto 00:00:56
tiene que acabar y 00:00:57
entre esas sentencias encontramos 00:00:59
muy poca variedad de tipos 00:01:02
una variedad de tipos muy pequeña 00:01:04
porque no hace falta más variedad 00:01:06
que es lo que estamos haciendo 00:01:07
asignar valores a variables 00:01:08
esos valores pueden venir de valores de una expresión 00:01:11
muy gordota o de muchas cosas raras 00:01:14
pero no deja de ser una 00:01:15
asignación, incluso cuando 00:01:17
leemos del teclado con el scan next in 00:01:20
es una asignación, es decir 00:01:22
dar valores a variables 00:01:24
ese es un tipo de sentencia 00:01:24
que es la que hemos hecho ahora 00:01:27
y ¿qué más tipos de sentencias 00:01:29
podemos manejar en la posición estructurada? 00:01:31
las decisiones y los bucles 00:01:33
y ya está, no hace falta 00:01:36
manejar más tipos de sentencias distintas 00:01:37
solo esas 00:01:40
las asignaciones 00:01:40
las decisiones y los bucles 00:01:42
combinando 00:01:44
en una secuencia ordenada y finita 00:01:46
de pasos 00:01:49
esas sentencias podemos 00:01:51
ejecutar, podemos 00:01:53
elaborar cualquier programa 00:01:55
para cualquier problema 00:01:57
que se nos presente, que 00:01:59
queramos que nos resuelva un ordenador. 00:02:01
¿Vale? Cualquiera. 00:02:03
Bueno, pues de las asignaciones tenemos todo lo que 00:02:05
tenemos que saber. Está más que 00:02:07
hiper mega sabido. 00:02:08
Entonces, vamos a incorporar la siguiente sentencia 00:02:11
dentro de los únicos tres tipos que tenemos 00:02:13
de actuación estructurada, que es la de 00:02:15
decisión, pues que ya sabes 00:02:17
lo que nos permite la sentencia de decisión 00:02:19
por su nombre, que es nuestro programa, en lugar de seguir siempre una única línea de ejecución, 00:02:21
ahora esto, ahora esto, ahora esto, ahora esto, pues vamos a en un punto determinado decir, 00:02:34
oye, perdona, en este punto de aquí yo a veces querré hacer esto o a veces querré hacer esto otro. 00:02:38
Vale, entonces la sentencia de decisión 00:02:46
Nos permite en algún momento 00:02:49
Vamos ejecutando 00:02:50
Uy, quiero abrir dos posibilidades 00:02:52
A veces querré hacer esto 00:02:54
O a veces querré hacer esto otro 00:02:56
Esas dos posibilidades 00:02:58
Luego cuando ya terminan 00:03:00
Continúan 00:03:03
Entonces la sentencia de decisión nos permite esto 00:03:04
Pasar de esto de aquí 00:03:07
A poder ya abrir 00:03:09
Dos posibilidades 00:03:11
Que mi programa haga esto 00:03:12
o que mi programa haga esto otro 00:03:14
ya le doy un poquito más de flexibilidad 00:03:18
entonces 00:03:22
esto lo tenemos que poder hacer efectivamente 00:03:23
porque hay veces que un programa 00:03:27
en función de los datos de entrada 00:03:29
nos interesa que haga una cosa o que haga otra 00:03:31
una calculadora en función del dato de entrada 00:03:34
operador o bien hace una suma 00:03:37
o bien hace una resta 00:03:39
un programa en función de si una contraseña que hemos introducido es correcta o no, 00:03:41
o bien te autentica y hace una cosa, o bien no te autentica y te reenvía a otro sitio. 00:03:48
Entonces, todos los programas admiten, lógicamente, varias posibilidades en función de datos de entrada. 00:03:54
Entonces, estas ramas no es que se abran de la nada. 00:04:02
Estas ramas dependerán de una condición. 00:04:06
estas ramas dependerán de una condición 00:04:11
que lógicamente 00:04:14
como consecuencia de haber 00:04:15
analizado bien el programa 00:04:17
de denunciado, haberlo entendido 00:04:19
pues iremos definiendo 00:04:21
¿vale? 00:04:23
entonces, esta es una situación 00:04:25
estándar 00:04:28
un enunciado, una aplicación 00:04:28
algo que tenemos que hacer 00:04:31
que después de analizarlo y estudiarlo 00:04:33
identificamos que a veces nos 00:04:35
interesará que haga una cosa 00:04:37
Y a veces nos interesará que haga otra 00:04:39
Entonces rápidamente nos damos cuenta 00:04:41
De que el programa no es una secuencia 00:04:44
Que siempre vaya a hacer lo mismo 00:04:45
A veces nos interesará que haga una cosa 00:04:47
Y a veces nos interesará que haga otra 00:04:49
Entonces si identificamos 00:04:51
Que ese programa está en esa situación 00:04:53
Que a veces nos interesará que haga una cosa 00:04:56
Y a veces nos interesará que haga otra 00:04:58
Automáticamente nos tiene que venir a la cabeza 00:04:59
La pregunta de ¿y de qué depende? 00:05:02
¿De qué depende que haga esta cosa 00:05:04
O que haga esta otra? 00:05:06
¿De qué depende? 00:05:08
Pues va a depender siempre de una condición. 00:05:09
De una condición que tendremos que elaborar, lógicamente, como parte del programa. 00:05:12
Luego la sentencia if me abre esta posibilidad. 00:05:18
¿Vale? 00:05:21
Entonces, el programa, no es que el programa empiece a hacer computación paralela, no. 00:05:24
Lo que pasa es que en una ejecución vendrá por aquí. 00:05:29
Sigue siendo una secuencia ordenada. 00:05:32
Pam, pam, pam, pam, pam, pam, pam, pam. 00:05:35
Pero a lo mejor en la ejecución de mañana 00:05:36
Como los datos de entrada han cambiado 00:05:39
Y la condición deja de cumplirse 00:05:41
Pues en la ejecución de mañana 00:05:43
Pues va por aquí 00:05:45
Siempre para cada ejecución 00:05:46
El programa hace una única cosa 00:05:50
O hace esto 00:05:52
O hace esto 00:05:54
Para cada ejecución hace una única cosa 00:05:55
Es decir, el programa sigue siendo 00:05:58
Una secuencia ordenada y finita de pasos 00:06:00
Esta, esta, esta, esta, esta, esta, esta 00:06:02
o esta, esta, esta, esta, esta, esta, esta, esta. 00:06:04
Una de las dos va a ser. 00:06:08
¿De qué va a depender en cada momento, 00:06:10
en cada ejecución que sea esta secuencia o que sea esta? 00:06:13
Pues repito, de una condición que tenemos que elaborar, 00:06:17
lógicamente, y definir cuál es. 00:06:20
¿Vale? 00:06:22
Bueno, pues cuando se abre, 00:06:24
se abren dos ramas. 00:06:26
Porque hemos puesto aquí una condición, 00:06:29
cuando se abren dos ramas, 00:06:30
no significa que ya el programa 00:06:32
automáticamente progresa en dos ramas independientes 00:06:34
el resto de su vida hasta que termine. 00:06:38
No, no, no. 00:06:40
Esas dos ramas que están asociadas a si la condición se cumple o no 00:06:41
serán hace esta cosa, que pueden ser una, dos, siete sentencias. 00:06:45
Hace esta cosa si la condición se cumple. 00:06:50
Si no se cumple, hace esta otra, 00:06:53
que pueden ser una, dos, tres, cuatro sentencias. 00:06:55
Pero cuando eso ha terminado, 00:06:58
el programa ya continúa 00:07:00
con su camino 00:07:02
¿vale? 00:07:04
no es que esto lo abra y cada programa ya 00:07:06
no, no, el programa una vez que se ha 00:07:08
hecho eso asociado a 00:07:10
¿qué ha pasado? 00:07:12
¿eh? 00:07:16
el que está cargando 00:07:16
bueno, da igual 00:07:18
esta pantalla es muy rara 00:07:21
una vez que se ha terminado de hacer esto 00:07:22
el programa continúa por aquí 00:07:25
luego, las dos ramas que se abren 00:07:26
Siempre confluyen en un punto 00:07:28
Esta es la peor pantalla de todo el instituto 00:07:30
Ni consigo que 00:07:36
Ah, ya está 00:07:37
Que responda el táctil 00:07:39
El resto de profesores no tienen problemas con ella 00:07:40
Solo yo 00:07:43
Bueno 00:07:44
Vale, entonces 00:07:47
Las dos ramas que se abren 00:07:49
Es importante que entendamos 00:07:50
Que confluyen a un punto 00:07:52
Si yo voy por esta rama 00:07:56
porque la condición es cierta, haré lo que sea 00:07:58
pero llego a este punto 00:08:01
y si voy por esta rama 00:08:02
porque la condición es falsa 00:08:04
haré lo que sea pero llego a este punto 00:08:06
luego puede ocurrir 00:08:08
que ese punto es el punto final 00:08:10
que ahí la aplicación termina 00:08:12
yo no quiero que pase nada más, bueno pues no pasa 00:08:14
pues entonces han concluido 00:08:16
en el fin 00:08:17
pero podría ser que no 00:08:19
que una vez que ya hemos hecho la alternativa 00:08:22
que toque, el programa siga 00:08:24
por su único camino 00:08:26
y a lo mejor luego más adelante 00:08:27
pues vuelve a abrirse otra vez 00:08:29
en buena condición, vuelve a abrirse 00:08:30
y luego vuelve a confluir 00:08:33
¿vale? 00:08:34
esto en el 00:08:40
los diagramas de flujo 00:08:41
porque el término de diagramas 00:08:44
de flujo que en entornos de desarrollo 00:08:46
a lo mejor 00:08:47
¿habéis visto algún tema ya en entornos de desarrollo? 00:08:48
que es el ciclo 00:08:52
de vida del software 00:08:53
análisis, diseño 00:08:55
que habéis tenido una clase 00:08:57
en tonos de desarrollo 00:09:04
bueno 00:09:04
pues en general 00:09:09
los diagramas de flujo 00:09:11
son dibujitos 00:09:13
que vienen muy bien 00:09:15
para ayudar 00:09:16
a entender programas 00:09:18
para documentar programas 00:09:20
son dibujitos, un diagrama de flujo 00:09:22
entonces, en general 00:09:24
aunque eso ya lo veréis en entornos de desarrollo 00:09:26
pues cuando se desarrolla 00:09:28
un software, una aplicación 00:09:30
un programa grandote 00:09:32
pues para que eso no sea un caos 00:09:34
y seguir más o menos 00:09:36
pautas de trabajo similares 00:09:38
en todos los contextos o en otras empresas 00:09:40
pues hay un procedimiento 00:09:42
que se concreta 00:09:45
en una cosa que se llama el ciclo de desarrollo 00:09:47
del software, que es los pasos que das tú 00:09:48
cuando vas a hacer un programa 00:09:50
¿qué pasos das tú cuando vas a hacer un programa? 00:09:52
o un software, hablando en términos más amplios. 00:09:55
Paso uno, análisis. 00:09:58
Todavía no habéis mencionado términos de análisis, diseño, 00:10:00
no os ha dado tiempo nada de eso en torno. 00:10:03
No, no, no. 00:10:05
Vale. 00:10:06
Pues pasos que sigue uno cuando va a hacer uno 00:10:07
o un equipo de proyecto, 00:10:10
cuando va a hacer un software o un programa. 00:10:11
Paso uno, análisis. 00:10:14
El análisis no tiene nada que ver con programar, 00:10:21
pero es la fase más importante 00:10:24
para que luego ese producto 00:10:27
que se desarrolla 00:10:28
realmente no nos lo tiren a la basura 00:10:30
y no hayamos perdido el tiempo 00:10:32
que el análisis es 00:10:34
¿qué quiero hacer? 00:10:35
¿qué tiene que hacer? 00:10:38
¿qué hago? ¿qué es lo que tengo que hacer? 00:10:40
y esto es lo que hacen los analistas 00:10:43
tratar de entender la situación 00:10:45
que les ha planteado el que ha pedido ese software 00:10:47
para entender exactamente 00:10:50
¿qué quiere? 00:10:52
que no es trivial porque la gente 00:10:53
o no se explica bien o tiene las ideas muy claras 00:10:55
entonces si tú no haces una buena fase 00:10:57
de análisis, te metes a desarrollar 00:10:59
un software y luego ese software no responde 00:11:01
a las expectativas 00:11:03
del cliente que te lo pidió, luego todo ese tiempo 00:11:04
que has dedicado no vale para nada 00:11:07
por eso esta fase es importante 00:11:08
toda esa serie 00:11:10
de entrevistas 00:11:13
de formas de proceder 00:11:14
que hay para 00:11:17
hacer un buen análisis, etc. 00:11:18
entonces 00:11:22
una vez que uno tiene muy claro que es lo que 00:11:22
hace, entra en la 00:11:25
fase de diseño 00:11:27
que ahora ya es, vale 00:11:28
¿cómo lo hago? y aquí era 00:11:30
a donde iba yo cuando 00:11:36
decía de los diagramas de Facebook 00:11:38
ahora ya sí 00:11:40
nos empezamos a plantear cosas de 00:11:41
como todavía no sabemos objetos 00:11:44
pues a eso igual nos puede sonar 00:11:46
un poco más raro, pero nos empezamos a plantear cosas 00:11:48
del estilo de 00:11:50
vale, ¿cuántas 00:11:52
entidades, cuántas 00:11:54
clases necesito para mi aplicación 00:11:57
pues una clase alumno, una clase 00:11:58
factura, bueno, eso ya lo entenderemos 00:12:01
pero sobre todo 00:12:02
entramos en, vale, ¿cómo voy a hacer las 00:12:04
cosas? si mi aplicación es 00:12:07
yo te voy a dar un número 00:12:08
y sácame el factorial 00:12:10
bueno, pues el analista 00:12:12
ha dicho, lo que tienes 00:12:15
que hacer es el factorial, que el factorial 00:12:16
de un número es, dado 00:12:19
el número n, multiplicarlo por 00:12:20
n-1 por n-2, así hasta 1 00:12:22
eso es, eso es lo que tienes que hacer 00:12:24
¿te has enterado que eso es lo que tienes que hacer? 00:12:27
sí, vale, esa sería la fase de análisis 00:12:29
de ese programita, entender exactamente 00:12:31
qué tengo que hacer 00:12:33
vale, ya he entendido lo que tengo que hacer 00:12:34
me dan un número n y tengo que 00:12:37
conseguir la multiplicación de n por n-1 00:12:39
por n-2, por n-3 00:12:42
porque ese es el factoría 00:12:43
vale, ahora ya me iría a cómo lo hago 00:12:44
cómo lo hago, ya entra 00:12:47
donde estamos nosotros, que es 00:12:49
¿qué sentencias necesito? 00:12:51
pues tendrás que leer datos 00:12:53
¿de dónde los lees? ¿cómo? 00:12:55
en este caso un dato, cuando tengas ese dato 00:12:57
¿qué haces para obtener ese resultado? 00:12:58
¿cómo lo haces? tendré que hacer un bucle porque son muchas 00:13:01
multiplicaciones, luego voy a tener que multiplicar mucho 00:13:03
pues hago un bucle, pues ahí ya entra 00:13:05
el diseño, que ahí ya sí que estamos 00:13:07
nosotros, y una vez 00:13:09
que uno tiene claro 00:13:11
cómo lo va a hacer, ya 00:13:12
lo programa en un lenguaje de programación 00:13:15
que sería la fase de 00:13:18
escritura de código, de codificación 00:13:21
entonces aquí ya entra 00:13:23
elegir un lenguaje de programación 00:13:25
claro, pero 00:13:27
la fase de diseño que es la crítica 00:13:28
después del análisis 00:13:31
claro, no necesita ningún lenguaje 00:13:33
de programación 00:13:35
y luego ya para completar y no quedarnos a medias 00:13:35
pues tendríamos la fase 00:13:39
de pruebas 00:13:41
en la que el código ya está 00:13:41
hecho, ya se puede ejecutar 00:13:45
y se le empiezan a meter 00:13:47
casos de pruebas 00:13:49
pruebas. Por ejemplo, si mi programa 00:13:50
hacía el factorial, pruebo con negativos, 00:13:52
pruebo con cero, pruebo con números enormes, 00:13:54
pruebo con números pequeñitos, 00:13:56
hago muchas pruebas a ver si en alguna 00:13:58
consigo que falle. 00:14:00
¿Vale? Entonces la fase de pruebas es 00:14:03
importantísima. Por eso está 00:14:04
también establecido una serie de procedimientos 00:14:06
para que se haga organizada 00:14:08
con un conjunto de casos de prueba que cubran 00:14:10
todas las posibilidades posibles, etc. 00:14:12
Que también lo veréis en entornos de desarrollo. 00:14:14
Y si ya el software ha pasado a la fase 00:14:17
de pruebas, se supone que ya 00:14:19
se sube a los servidores de 00:14:21
producción, ya se pone ahí a disposición 00:14:22
a los usuarios y entraría 00:14:25
en una fase que no acaba nunca 00:14:29
que es la fase de mantenimiento. 00:14:30
¿Vale? Porque esa aplicación 00:14:34
aunque la fase de pruebas haya sido 00:14:35
la más completa y la mejor del universo 00:14:37
seguro 00:14:39
que algún bug se ha colado. 00:14:40
Y lo más probable es que en algún momento 00:14:43
un usuario dentro de seis 00:14:44
meses te diga 00:14:47
uy, intenté hacer esto 00:14:48
y me cascó, no pude 00:14:51
¿vale? pues esa fase de mantenimiento infinita 00:14:52
es en la que 00:14:55
se mantiene la aplicación 00:14:57
según se van reportando bugs 00:14:59
o problemas que ha tenido 00:15:01
se la amplían porque el cliente que te pidió 00:15:02
el software a lo mejor dentro de un año te dice 00:15:05
jo, vale, está muy bien 00:15:06
pero por favor he incorporado un departamento nuevo 00:15:08
incorpórame estas funcionalidades 00:15:11
al software, porque quiero que haga 00:15:12
además esta cosita, bueno, pues todo esto 00:15:14
es esta fase infinita 00:15:16
hasta que ya el software desaparece 00:15:18
pues ya no se usa jamás 00:15:20
si, dime 00:15:21
bueno, si te piden una 00:15:22
o sea, en una aplicación que ya has hecho 00:15:23
y te piden algo nuevo, sería otra vez 00:15:26
hacer una análisis, diseño y tal 00:15:28
en el campo de mantenimiento, habría que hacerlo por eso 00:15:30
sí, claro, porque esto 00:15:32
que yo he dicho aquí es 00:15:34
el modelo más claro del ciclo 00:15:35
de vida del software, ciclo de vida del software 00:15:38
significa por qué pasos pasa el software 00:15:40
este es el ciclo de vida visualmente más 00:15:42
claro, que todos intuimos, análisis, diseño 00:15:44
codificación, pruebas y mantenimiento 00:15:46
pero efectivamente 00:15:48
no todo sigue un modelo tan sencillo 00:15:49
porque en función de la ampliación 00:15:52
que te llegue, pues tendrías tú 00:15:54
que volver a hacer todas las fases 00:15:56
entonces por eso, si vamos refinando 00:15:58
esto, llega una cosa que se llama el modelo en espiral 00:16:00
que refleja 00:16:02
lo que tú acabas de decir, en realidad yo voy 00:16:04
iterando 00:16:06
sobre lo mismo, que ahora quiero 00:16:07
ampliar lo nuevo, hago una nueva iteración 00:16:10
de análisis, diseño, vamos iterando 00:16:12
¿vale? pero todo esto os lo contará 00:16:14
abráis con más detalle. 00:16:16
Entonces, ¿para qué venía este rollo mío? 00:16:18
Bueno, pues que 00:16:21
según el equipo de 00:16:22
desarrollo de proyecto 00:16:24
va cubriendo estas 00:16:25
fases, pues las va 00:16:28
documentando, las tendrá que documentar 00:16:30
para que el resto de 00:16:32
miembros del proyecto se enteren 00:16:34
de los resultados. 00:16:36
Bueno, pues para documentar el análisis 00:16:39
hay un montón de documentos de Arama 00:16:40
su ML, un montón de rollos. 00:16:42
Y para documentar el diseño, ¿cómo lo hago? 00:16:44
pues tenemos nuestros diagramitas de flujo 00:16:46
que explican el programa 00:16:49
que tiene que hacer 00:16:51
diagramas de flujo y muchas otras herramientas 00:16:54
pero los diagramas de flujo 00:16:59
pues es una 00:17:01
¿ya? ¿está rápido? 00:17:04
ay bueno 00:17:07
déjale que se vaya 00:17:08
hasta luego 00:17:14
vale, entonces 00:17:18
los diagramas de flujo es una de tantas 00:17:20
herramientas 00:17:23
estándar para documentar 00:17:25
los resultados 00:17:27
de esta fase para que esté todo ahí documentado 00:17:29
entonces 00:17:31
todo esto ha venido 00:17:32
por cómo expresamos 00:17:35
la sentencia de decisión en un diagrama 00:17:37
de flujos, es una herramienta que 00:17:39
habéis visto mil veces, una forma de especificar 00:17:40
los diseños que habréis visto 00:17:43
por ahí mil veces, entonces 00:17:45
Entonces, nuestra sentencia I, en un diagrama de flujo, sería algo así. 00:17:47
Nuestra sentencia de decisión, perdón. 00:17:55
Lo de I no lo he dicho todavía. 00:17:57
Vale, pues a ver, los diagramas de flujo son un dibujito para ver lo que hace un programa. 00:18:06
¿Cómo lo hace? Un dibujito, es más que un dibujito. 00:18:13
Entonces, como un programa tiene un inicio y un fin, pues entra en un sitio, un punto, que es el inicio, 00:18:15
Pues ahí arranca el programita y ahora ya empieza la línea. Las asignaciones, pues las podemos expresar en un cuadradito y ya está. Pues n igual a 3. En particular, si la asignación viene de leer del teclado, o sea, si es una sentencia de entrada y salida, se suele expresar con un romboide en lugar de con un rectangulito. 00:18:20
Pero bueno, ¿vale? Por ejemplo, si la n en lugar de asignarle el valor directamente, lo que hacemos es asignarle el valor, pero de la consola, pues el simbolito que se puede usar es un roboide. 00:18:42
vale, entonces el programa continúa 00:18:55
y hace sus cosas 00:18:57
pues n más 3 00:18:59
n igual a n más 3 00:19:01
lo que sea, el programa continúa 00:19:03
y ahora, a lo mejor hemos 00:19:05
identificado que aquí 00:19:07
ahora ya queremos 00:19:09
hacer una cosa o queremos hacer otra 00:19:11
en función 00:19:13
de precisamente 00:19:15
si n 00:19:17
pues por ejemplo es negativo o positivo 00:19:19
por ejemplo 00:19:22
vale, voy a cortarlo aquí para que 00:19:23
por ejemplo, este podría ser 00:19:25
mi diagrama de flujo 00:19:33
entonces ahí me dicen 00:19:34
si n es 00:19:35
negativo 00:19:37
lo que tienes que hacer es 00:19:39
decirle que el número no es válido 00:19:41
si n es positivo 00:19:44
entonces en ese caso 00:19:46
solicitas otro número 00:19:48
y muestras la suma de los dos 00:19:50
por ejemplo 00:19:53
entonces esos son 00:19:53
dos caminos posibles, muy distintos 00:19:55
que va a hacer el programa 00:19:58
en una ejecución 00:20:01
hará uno, el de decir 00:20:03
el número no es válido 00:20:05
pero en otra ejecución puede que haga otro 00:20:06
el de decir, pide otro 00:20:08
número, sumarlo al primero, etc 00:20:10
son dos cosas muy distintas 00:20:13
las que hace 00:20:14
vale, me tendrán que especificar en función de que 00:20:16
pues si es negativo 00:20:19
lo único que va a hacer es decirte 00:20:20
el número no es válido 00:20:23
pero si es positivo son muchas más cosas 00:20:25
las que va a hacer 00:20:27
Bueno, pues ahí automáticamente identificamos que hay una decisión. 00:20:28
Bueno, pues en un diagrama de flujo esto lo expresamos así, 00:20:32
con un rombito donde ponemos la condición. 00:20:35
En este caso nuestra condición es n menor que 0. 00:20:39
Esa es nuestra condición. 00:20:42
La condición que define si nos vamos por un lado o nos vamos por otro. 00:20:44
Y del rombito saldrán dos ramas, la del sí y la del no. 00:20:49
si la condición se cumple 00:20:55
aquí ya pueden pasar 00:20:58
millones de cosas, las que yo quiera 00:21:00
y si no se 00:21:02
cumple, aquí millones de cosas 00:21:04
las que yo quiera 00:21:06
¿vale? y cuando esas millones de cosas 00:21:07
hayan terminado, tanto en un lado como en otro 00:21:10
el programa continuará 00:21:12
su camino 00:21:14
¿vale? las dos ramas 00:21:15
de la sentencia y decisión, ahí se juntan 00:21:18
aquí 00:21:20
pasarán un montón de cosas, las que yo 00:21:22
quiera que pasen, si n es negativo 00:21:24
y aquí pasarán las cosas que yo quiero 00:21:26
que pasen si n es mayor o igual que cero. 00:21:28
Y luego el programa continuará. 00:21:31
Por ejemplo, ¿cómo? Pues a lo mejor despidiéndose. 00:21:32
¿Vale? 00:21:44
Entonces, esta sentencia 00:21:45
ya va fuera 00:21:47
de la sentencia de decisión, porque 00:21:48
el despedirse lo hago 00:21:51
tanto si voy por esta 00:21:53
rama como si voy por esta otra. 00:21:55
El despedirse lo hago en ambos 00:21:57
casos. Pues entonces el despedirse 00:21:59
lo he puesto aquí, ya a continuación 00:22:01
cuando ya las ramas se han juntado 00:22:03
si solo me quisiera despedir 00:22:04
cuando el número 00:22:07
es positivo 00:22:09
pues pondría la despedida aquí 00:22:09
¿vale? 00:22:13
para que la despedida solo se hiciera si el número 00:22:14
es positivo 00:22:17
pero yo me quiero despedir en ambos casos 00:22:18
pues esto ya va fuera y es otra sentencia más 00:22:22
y el programa podría seguir 00:22:24
porque la decisión abre dos caminos 00:22:25
que 00:22:28
son independientes un tiempo 00:22:29
luego ya 00:22:32
y podría seguir en un camino 00:22:34
y luego abrir otra 00:22:36
sí, sí, sí, claro 00:22:38
entonces ahora 00:22:40
imagina aquí el programa en algún momento terminará 00:22:41
pues por ejemplo aquí termina, vale 00:22:44
entonces ahora aquí ya podemos seguir 00:22:45
refinando efectivamente 00:22:48
este es el diseño de mi programa, va a hacer esto 00:22:49
vamos a seguir refinando 00:22:51
ahora ya pienso, en el caso de que 00:22:53
sea menor que cero, ¿qué quiero que haga? 00:22:56
y solo en ese caso 00:22:58
solo en ese caso 00:23:00
pues hemos dicho mostrar 00:23:01
no válido. Estoy poniendo aquí 00:23:03
un romboide porque mostrar también 00:23:05
es sentencia de salida y los romboides 00:23:07
se asumen para sentencias tanto 00:23:09
de entrada de datos como de salida. 00:23:11
Y mostrar por consola es salida 00:23:14
también. Entonces, pues aquí 00:23:15
podría ser mostrar no válido. 00:23:17
¡Hala! 00:23:21
Esa rama ya no tiene más 00:23:22
que hacer. El resto 00:23:23
de cosas que haga 00:23:26
ya son independientes de la decisión 00:23:26
porque se van a hacer tanto 00:23:30
si sí como si no. 00:23:31
Luego esa rama no tiene más que hacer. 00:23:33
Ahora, en el caso de que sea negativo, ¿qué quiero yo que pase? 00:23:35
Pues puedo querer que pase un montón de cosas. 00:23:40
Pues, por ejemplo, a lo mejor quiero que pase leer un número m, 00:23:42
leer m y mostrar en la propia variable n, guardar n más m, 00:23:47
es decir, a n sumarle m y guardar eso en n. 00:23:56
y ahora pues a lo mejor 00:23:59
quiero mostrar ese valor 00:24:02
quiero aquí ahora ya 00:24:04
mostrar el resultado de n 00:24:08
mostrar n por ejemplo 00:24:11
y ya hemos terminado 00:24:14
entonces las ramas son independientes 00:24:16
cada uno hace una cosa completamente distinta 00:24:19
pero llega un momento 00:24:21
en que esta ya ha terminado con su cometido 00:24:22
y llega aquí 00:24:25
y llegará un momento en que esta ya ha terminado 00:24:26
con su cometido y llega aquí 00:24:29
Y el programa continúa. Esa sentencia ya terminó. La sentencia de decisión terminó. El programa continúa. ¿Vale? Bueno, pues todo esto que tenemos aquí dibujado, todo esto es una sentencia de decisión. 00:24:30
Una sentencia de decisión 00:24:49
Es una sentencia que 00:24:52
Podemos decir que es una sentencia compleja 00:24:54
Porque mete un montón de cosas dentro 00:24:56
No es como una sentencia de asignación 00:24:58
La sentencia de asignación es sencilla 00:25:00
La sentencia de asignación es nombre de variable 00:25:02
Igual a valor 00:25:05
La sentencia de asignación es una sola línea 00:25:06
Por decirlo así, es una línea 00:25:09
Pero la sentencia de decisión 00:25:10
Son un montón de cosas dentro 00:25:13
Es la condición 00:25:15
Lo que hago en caso de que se cumpla 00:25:17
lo que hago en caso de que no se cumpla 00:25:19
un montón de líneas 00:25:21
es la sentencia de decisión 00:25:22
pero repito, es una única sentencia 00:25:24
lo que pasa es que es compleja, tiene muchas líneas 00:25:27
a su vez tiene metidas 00:25:30
dentro sentencias de asignación 00:25:31
o de las que me den la gana, etc. 00:25:33
¿Vale? Pues la representación gráfica 00:25:41
en un diagrama de flujo, una sentencia de decisión 00:25:43
nos permite rápidamente 00:25:45
entender claramente qué es lo que hace 00:25:47
lo que se hace en cada rama 00:25:49
se hace lógicamente una sola vez 00:25:55
no lo confundamos con un bucle que es esto mismo 00:25:58
pero repetido, pero eso ya es un bucle 00:26:00
¿vale? bueno pues 00:26:02
una vez que tenemos nuestro 00:26:09
programa entendido y claro visualizado 00:26:11
en la cabeza o incluso a lo mejor escrito 00:26:13
su diagrama de flujo para entender lo que queremos 00:26:15
hacer, es decir, tenemos su diseño 00:26:17
ahora ya pasar 00:26:19
esto a código, sea Java 00:26:21
sea Python, sea el que sea 00:26:23
esto ya es muy fácil 00:26:24
esto sabemos pasarlo a código 00:26:26
una sentencia con el escáner 00:26:29
para leer, eso se va a pasar a código 00:26:31
que es un sistema println 00:26:33
pues como pasamos a código 00:26:35
toda esta sentencia gordota 00:26:37
pues con la sentencia if 00:26:38
entonces 00:26:41
como pasamos a código, esto si que es chulo 00:26:42
vale 00:26:45
como pasamos a código 00:26:46
esto 00:26:48
vale 00:26:52
pues este programa, pasarlo ahora a código 00:26:53
sería leer n 00:26:57
pues ya lo sabemos 00:26:58
tenemos el escáner, vamos a suponer que tenemos 00:26:59
el escáner ya declarado. 00:27:02
Next if, lo que sea. 00:27:08
Esa sentencia ya está. 00:27:10
Ahora, ¿qué nos viene después? 00:27:12
Toda una sentencia if. 00:27:14
Una sentencia if, que es una cosa gordota. 00:27:16
Es la condición con sus ramas. 00:27:18
Toda esa es la sentencia if. 00:27:20
Vale, pues ¿cómo pasamos esto a código? 00:27:22
Pues la sentencia de decisión empieza con un if, ¿vale? 00:27:25
¿Y qué es lo que ponemos a continuación? A continuación ponemos la condición, la condición que sea, bueno, en nuestro caso ya la teníamos. 00:27:32
Y ahora, ¿qué ponemos después? Lo que ponemos después es lo que se hace en el caso de que la condición se cumpla. 00:27:44
¿Y cómo lo ponemos? Pues lo ponemos entre llaves. De nuevo, para seguir las pautas de una programación, de un código elegante que más o menos se entienda, la llave se abre a continuación del ir y se cierra en algún momento. 00:28:04
cuando ya he terminado la sentencia 00:28:24
estaba en la rama del sí, se cierra 00:28:26
a la altura donde empezó el ir 00:28:28
para que cuando uno lo visualiza vea muy claro 00:28:30
que esta llave 00:28:33
cierra esto 00:28:34
entonces esto sería 00:28:36
lo que va aquí dentro sería todo lo que 00:28:38
se hace en el caso 00:28:40
de que se cumpla en esta rama 00:28:42
en este caso 00:28:44
¿qué es lo que se hace? pues un system out 00:28:46
de no válido, no se hace nada más 00:28:48
no se hace nada más que eso 00:28:50
una única sentencia 00:28:54
Bueno, ¿cómo programo lo que se hace en el caso de que no se cumpla? 00:28:57
Pues pongo aquí a continuación el SE 00:29:03
Y lo mismo, abro una llave justo detrás 00:29:05
Que cerraré a la misma altura del IF 00:29:09
Para que el código quede claro 00:29:12
Que repito, no es obligatorio 00:29:14
Puede uno hacer un código a limatías 00:29:17
Pero muy mal, así no tiene futuro 00:29:19
Y allá entre estas llaves ponemos lo que queremos hacer aquí 00:29:22
que en este caso pues sí que sería un poco más largo 00:29:26
pues sería leer m 00:29:28
a n 00:29:30
sumarle 00:29:37
más igual m 00:29:39
vale 00:29:44
esa es la siguiente sentencia 00:29:46
a n sumarle m y meterlo en n 00:29:48
y luego 00:29:50
mostrar n, hemos dicho que todo eso 00:29:52
se hace ahí, por ejemplo 00:29:54
vale 00:29:56
todo eso se hace en el caso del no 00:29:58
pues va en estas llaves 00:30:00
y esta sentencia ya está terminada de programar, ya se acabó, está terminada de programar, ya ha terminado. 00:30:01
Luego esto que yo tengo aquí en rojo es esto de aquí, ¿vale? Esto de aquí está programado así, de esa manera. 00:30:11
Aquí la condición, aquí lo que se hace en caso de que se cumpla y aquí lo que se hace en caso de que no se cumpla. 00:30:25
esta es la versión básica 00:30:32
del libro, luego ya admite 00:30:35
modificaciones, matices, cosas 00:30:36
que ahora vamos a ir diciendo 00:30:38
pero bueno, esta es la versión básica 00:30:40
¿vale? ahora cuando la 00:30:42
sentencia de edición ha terminado, que es en este punto 00:30:46
aquí, mi programa 00:30:48
sigue haciendo lo que tenga que hacer 00:30:50
dime 00:30:52
si, las mismas, toda la misma altura 00:30:53
para que quede claro que esto está 00:30:58
asociado a la sentencia 00:31:00
¿vale? 00:31:01
Ahora, cuando esa sentencia ha terminado, que es en este punto de abajo, cuando esta sentencia ha terminado, que es en este puntito de abajo, aquí y aquí, o sea, este punto y este punto son el mismo, ahí ya las dos ramas terminaron su ejecución, o sea, terminaron su camino y se acabó. 00:31:04
y ahora ya mi programa continúa 00:31:28
y lo que continúa haciendo a partir de aquí 00:31:30
ya no depende de ninguna condición 00:31:32
mucho menos de esta, esto ya se hace 00:31:34
como una sentencia más, una tras otra 00:31:36
una tras otra, en este caso 00:31:38
la única sentencia añadida 00:31:39
que tiene el programa es mostrarle adiós 00:31:42
pues venga, aquí iría un adiós 00:31:44
y ya está 00:31:47
y esta sentencia 00:31:50
que es esta, ya está fuera del if 00:31:52
ya se hace 00:31:54
cuando esto ya ha terminado 00:31:56
cuando estos dos caminos 00:31:58
y ahora ya, empezamos a ejecutar esto 00:31:59
en alguna ejecución 00:32:05
vendrá, el programa hará esto 00:32:06
dentro de dos minutos 00:32:08
lo ejecutamos y el programa 00:32:11
hace esto, a lo mejor en la siguiente 00:32:12
ejecución vuelve a hacer esto, en la siguiente 00:32:15
vuelve a hacer esto, luego en 00:32:17
cada ejecución 00:32:18
o va por aquí o va por aquí 00:32:20
lógicamente, en cada ejecución 00:32:23
o se hace una cosa o se 00:32:25
hace la otra, dependiendo de esto 00:32:26
pero las dos posibilidades 00:32:29
están contempladas, las dos 00:32:31
luego es una sentencia 00:32:33
imprescindible, cualquier programa 00:32:38
nos tiene 00:32:40
cualquier situación 00:32:41
normalmente nos plantea 00:32:43
esta situación, oye es que 00:32:46
no quiero que hagas siempre esto 00:32:48
a veces querré que hagas esto 00:32:50
y a veces querré que hagas esto otro 00:32:52
eso cualquier situación nos lo va a plantear 00:32:54
cualquiera, pues eso lo tendremos 00:32:56
que programar de esta manera 00:32:58
¿vale? 00:33:00
pequeñas cosas antes 00:33:02
de ver algún ejemplo 00:33:07
pequeñas cosas 00:33:09
si después 00:33:11
si en alguna de las ramas 00:33:13
si en alguna de las ramas 00:33:14
solo hay una sentencia 00:33:16
como es aquí en el caso del sí 00:33:18
las llaves son opcionales 00:33:21
no hay por qué ponerlas 00:33:23
¿vale? 00:33:25
entonces si yo no pongo estas llaves 00:33:26
estas de aquí 00:33:28
la máquina virtual, el compilador 00:33:32
interpreta que la única 00:33:37
sentencia que va asociada a la rama 00:33:39
del sí, que es la de if, es la primera 00:33:41
que hay, interpreta que es la única 00:33:43
entonces cuidado 00:33:45
si en alguna de las ramas 00:33:47
hay varias cosas 00:33:49
como es este caso 00:33:51
tiene que estar entre llaves 00:33:52
porque si no, el programa va a interpretar 00:33:54
que es solo la primera de ellas 00:33:57
¿vale? 00:33:59
pero si solo hay una sentencia 00:34:01
puedo enviar las llaves 00:34:03
tanto en el if como en el else 00:34:05
si el else solo tuviera una sentencia 00:34:07
de todas estas 00:34:10
podría quitar las llaves 00:34:11
y no habría confusión sobre si este 00:34:13
está dentro o no, no habría porque al no haber 00:34:17
llaves, solo la primera 00:34:19
está dentro del else, las demás ya 00:34:21
están fuera 00:34:24
entonces 00:34:25
si se pone no pasa nada 00:34:26
y muchas veces 00:34:29
lo deja mucho más claro 00:34:31
esto sí que va un poco por maní 00:34:32
Estefano siempre pone 00:34:35
llaves haya una o no 00:34:37
por costumbre suya 00:34:39
pero yo si hay una 00:34:41
pues me es más ágil no ponerla 00:34:44
porque además a nivel de código 00:34:46
es que se ve muy claro porque siempre tabulas 00:34:47
lo que va adentro lo tabulas 00:34:50
entonces 00:34:51
si solo es uno 00:34:53
no tienes que poner la llave 00:34:55
y nunca va a haber confusión 00:34:56
porque 00:34:59
si lo has hecho bien 00:35:00
si hay otra sentencia más, esa ya se asume que está fuera 00:35:02
¿vale? 00:35:05
Eso por un lado. 00:35:07
Y por otro, antes de parar un momento, 00:35:08
la rama esta, esta es opcional. 00:35:12
Puede estar o puede no estar. 00:35:18
Es decir, no tiene por qué haber siempre un if asociado a un el si. 00:35:22
La rama del si siempre tiene que estar. 00:35:26
Pero la rama del no puede no estar. 00:35:30
¿Eso qué significa? 00:35:32
Significa que en el caso de que no se cumpla, yo no hago nada. 00:35:34
Ya está. 00:35:37
Entonces, si yo pongo una sentencia de decisión, lo que es obligatorio y siempre tiene que estar es el if con la condición. Eso es obligatorio y siempre tiene que estar. Lo que yo ponga detrás será lo que se haga si se cumple. 00:35:37
Si en el caso de que no se cumpla 00:35:58
Yo no quiero hacer nada 00:36:00
Pues quito el ELSE directamente 00:36:01
No hace falta que ponga un ELSE con unas llaves vacías dentro 00:36:03
Quito el ELSE tal cual 00:36:06
Es decir, si yo no pongo ELSE 00:36:08
Sería como 00:36:18
Tener este programa 00:36:20
¿Vale? 00:36:23
Y esto se puede programar 00:36:28
En el caso de que se cumpla, hago algo 00:36:30
Si no se cumple, nada 00:36:32
¿Esto cómo se programa? 00:36:35
Quitando el ELSE tal cual 00:36:39
Se quita el el si y se acabó 00:36:40
Pero el if o lo que es lo mismo 00:36:42
La rama del si siempre tiene que estar 00:36:44
La rama del si siempre tiene que estar 00:36:46
La del no, que es la del el si 00:36:50
Si yo no quiero que se haga nada 00:36:52
La quito enterita 00:36:53
Y ya está 00:36:55
No, no se apaga 00:36:56
Continúa 00:37:03
Con lo que haya después de la sentencia de decisión 00:37:04
Continúa por aquí 00:37:07
Aquí no hace nada y continúa por aquí 00:37:08
Continúa por ahí 00:37:10
Claro, entonces me diríais, hombre, si yo tengo un programa que lo que quiero es que haga algo cuando no se cumple la condición y que no haga nada cuando sí se cumple, pues no pasa nada, ponemos la condición al revés, ¿vale? Ponemos la condición con el no delante, porque lo que se programa siempre es la rama del sí y la del no es opcional, la del no es opcional. 00:37:12
entonces yo aquí pongo la condición esta 00:37:36
con el no delante cambiada en función 00:37:38
a lo que me interese 00:37:40
para la que, porque la que tiene 00:37:42
que aparecer siempre es la del sí 00:37:44
es decir, si yo quiero un programa 00:37:46
que me muestre no válido 00:37:53
en este caso en la rama del no, por ejemplo 00:37:55
quiero cambiarlo 00:37:57
y quiero que me muestre 00:37:59
no válido aquí 00:38:05
y que aquí me lo muestre vacío 00:38:06
entonces 00:38:08
yo quiero hacer este programa 00:38:12
diagrama de flujo no entiende 00:38:15
de Java no entiende de nada, es un diagrama de flujo 00:38:17
válido, si n es menor que 0 00:38:19
no hagas nada 00:38:21
y si no lo es, haz esto 00:38:22
diríamos, jolines, pues 00:38:24
entonces yo lo tendré que programar 00:38:27
poniendo el if sí o sí 00:38:28
con un n menor que 0, aquí unas 00:38:30
llaves vacías, que feo porque no hace 00:38:33
nada, y aquí un else 00:38:35
y ahora aquí ya sí hacer esto 00:38:37
vale, esto programa 00:38:39
lo de arriba, está bien, no hay problema 00:38:41
pero que feo, un if vacío 00:38:43
y un else 00:38:45
para poner la rama del no 00:38:46
¿cómo programaríais esto en realidad? 00:38:48
¿cambiaríais la condición? 00:38:53
diríais, si 00:38:54
la cambiada, la negada 00:38:56
de n menor que 0, que sería 00:38:58
si n mayor o igual que 0 00:39:00
vale, si n 00:39:02
mayor o igual que 0 00:39:04
pues entonces 00:39:05
esto, y si no 00:39:07
nada, quitaría el else porque no 00:39:12
lo que tienes que cambiar es el n mayor que o menor que 00:39:14
claro, si mi programa 00:39:18
tiene esta forma en su diagramación 00:39:19
de esta manera, yo quiero hacer algo 00:39:21
si no se cumple la condición 00:39:23
lo único que tengo que hacer es cuando lo programe 00:39:24
poner la condición al revés con el no delante 00:39:26
entonces esta rama va al sí 00:39:29
y esta va al no 00:39:31
si yo esta condición la cambio 00:39:32
esta rama va aquí 00:39:35
y esta va aquí 00:39:37
con lo cual ya puedo hacer un if sin su else 00:39:38
normal y corriente 00:39:41
¿cuál? 00:39:42
con el else if 00:39:49
no, no es la inversa, o sea es abrir 00:39:51
otro if dentro de otro if 00:39:52
dentro del else abrir otro if 00:39:54
y dentro del else 00:39:57
abrir otro if, sería eso 00:39:59
luego lo vemos, ¿vale? 00:40:01
sería como anidar más condiciones 00:40:03
dentro del else 00:40:05
vale 00:40:06
bueno, pues ahora con ejemplo se verá más claro 00:40:08
vamos a parar 00:40:11
unos minutejos 00:40:13
Gracias. 00:40:14
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
8 de octubre de 2025 - 17:03
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
40′ 16″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
2.22

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid