Saltar navegación

20241003 ProgrEstruct-Decision_2 - Contenido educativo

Ajuste de pantalla

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

Subido el 7 de octubre de 2024 por Raquel G.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, a ver, pues esto de la sentencia de decisión en realidad ya nos permite aproximarnos un poquito más a este término, ¿vale? Ya nos permite aproximarnos un poco más a este término, ¿vale? 00:00:00
un algoritmo es 00:00:20
un concepto que 00:00:21
está más allá de la programación 00:00:23
¿vale? más allá de la programación, un algoritmo 00:00:26
exclusivamente es 00:00:27
la secuencia de acciones 00:00:28
que conducen a la resolución 00:00:32
de un problema, ¿verdad? eso es un algoritmo 00:00:34
¿tenemos clase de algoritmo? 00:00:36
no, eso es 00:00:37
eso es pensar 00:00:39
¿vale? 00:00:41
no, hombre, no, es que 00:00:43
claro 00:00:46
sí, vale 00:00:46
entonces una secuencia de pasos para resolver un problema 00:00:50
entonces pues bueno 00:00:52
quiero viajar a París 00:00:53
busco 00:00:56
un billete, lo pago 00:00:58
me voy al aeropuerto 00:01:00
monto en el avión, aterrizo 00:01:01
si Dios quiere, bajo del avión 00:01:04
y llego a París 00:01:06
pues eso es un algoritmo 00:01:06
una secuencia de pasos para resolver 00:01:09
mi problema de que quiero llegar a París 00:01:12
vale, en programación 00:01:14
también lo que buscamos es resolver 00:01:17
problemas 00:01:19
tengo 15 usuarios 00:01:20
y quiero ver de esos 15 00:01:24
cuál es el que más ha pagado 00:01:25
15 clientes 00:01:28
vale, pues mi problema 00:01:30
aplicación que he dado 00:01:31
los clientes de una base de datos 00:01:32
mire cuál es el que más ha pagado 00:01:35
problema, a resolver 00:01:37
¿cómo? con un algoritmo que programamos 00:01:39
¿vale? un algoritmo en términos generales 00:01:42
es eso, una secuencia 00:01:44
de acciones para resolver un problema 00:01:46
que queremos resolver, que necesitamos 00:01:47
resolver. Y eso es lo que hacemos cuando 00:01:49
programamos. Programamos exclusivamente 00:01:52
para eso. ¿Para qué un problema 00:01:54
que queremos resolver, en lugar 00:01:56
de hacerlo nosotros, que no lo podemos 00:01:57
hacer porque somos demasiado lentos 00:02:00
calculando, 00:02:01
o no tenemos una capacidad de almacenamiento 00:02:03
de datos demasiado grande, no podemos memorizar 00:02:05
mil millones de clientes a la vez, 00:02:08
pues algo que nosotros podríamos 00:02:10
hacer, pero nos falta 00:02:11
memoria y nos falta 00:02:13
velocidad, pues se lo damos 00:02:15
a alguien que no sabe hacer absolutamente 00:02:17
nada, pero a cambio 00:02:19
tiene memoria y 00:02:21
tiene velocidad. Es lo único que nos 00:02:23
aporta un ordenador. Memoria y 00:02:25
velocidad nos aportan nada más. 00:02:27
Entonces, bueno, pues entonces 00:02:29
yo le digo lo que tiene que hacer, 00:02:31
se lo digo paso por paso, 00:02:34
pa, pa, pa, pa, y él lo 00:02:35
hace. ¿Vale? Y no va a hacer nada 00:02:37
que no le hayamos dicho nosotros. 00:02:39
Bueno, pues ese paso por 00:02:41
paso que tenemos que hacer 00:02:43
es el algoritmo. 00:02:45
Bueno, pues entonces 00:02:48
Ya ese término, cuando ya hablamos de programación, pues ya se ha refinado un poquito más y algoritmo implica ser una secuencia de pasos para que el algoritmo sea válido y yo me planté programarlo, cuidado no os olvidéis que tiene que ser finito, ¿vale? 00:02:49
Y secuenciado, tiene que ser una sentencia tras otra, es decir, una sentencia tras otra o una orden tras otra, como lo queráis llamar, y tiene que acabar, ¿vale? 00:03:08
Entonces, si yo consigo 00:03:37
Especificar 00:03:40
Cómo hacer algo 00:03:42
Con una sentencia, una instrucción 00:03:43
Tras otra, gira a la derecha 00:03:46
No sé qué, no sé cuánto, patatín, patatín, patatín 00:03:47
Y además, tiene un fin 00:03:49
Tiene un fin 00:03:51
Entonces habré hecho un algoritmo válido 00:03:52
Pues cuando yo he llegado a un algoritmo válido 00:03:55
Que lo puedo expresar en mis propias palabras 00:03:57
Con diagramas de flujo 00:03:59
Como sea, cuando yo he llegado a un algoritmo válido 00:04:01
Ahora ya, lo programo 00:04:03
¿Vale? 00:04:06
en el lenguaje de programación que elija 00:04:07
y ese ya lo hace, ese va a seguir 00:04:08
pum pum como un tonto lo que le vamos diciendo 00:04:11
pues es tonto, o sea lo único que sabe hacer 00:04:13
es operaciones aritméticas y lógicas 00:04:15
no sabe hacer nada más que eso 00:04:17
operaciones aritméticas y lógicas, lo que pasa es que las hace 00:04:19
muy deprisa y además 00:04:21
puede almacenar a la vez 00:04:23
millones de números que nosotros no podemos 00:04:25
numerizar, bueno pero tenemos que 00:04:27
decir que hacer 00:04:29
y se lo decimos con un algoritmo 00:04:30
bueno pues entonces 00:04:32
Entonces, para construir ese algoritmo, nosotros primero recogemos datos, datos de entrada. Eso es evidente, eso estaría como al margen del algoritmo. El algoritmo trabaja con datos de entrada que hemos recogido. Y ahora, a partir de ahí, empezamos a combinar estas sentencias o estas acciones, como lo queráis llamar, empezamos a combinarlas. 00:04:35
vale, pues cuál es una de estas sentencias 00:04:56
o acciones que podemos empezar ya 00:04:59
a combinar para conseguir un algoritmo 00:05:01
pues una de esas sentencias 00:05:03
o acciones es la sentencia 00:05:05
de decisión, vale 00:05:07
o selectiva según el manual que 00:05:08
estudiéis o como sea 00:05:17
vale, es 00:05:19
obvio que para 00:05:24
poder hacer algo, para poder 00:05:27
solucionar un problema, yo 00:05:29
tengo que tener una manera 00:05:31
de expresar, si ocurre 00:05:32
esto, haz esta cosa 00:05:35
y si no, haz esta otra 00:05:37
porque eso ocurre en cualquier situación 00:05:39
entonces 00:05:41
problema que yo quiero resolver 00:05:43
quiero 00:05:45
cruzar la calle 00:05:46
ahora me planteo hacer el algoritmo 00:05:48
mires el semáforo 00:05:50
si está en rojo 00:05:53
esperas, si está en verde 00:05:54
sigues 00:05:57
entonces siempre, cualquier algoritmo 00:05:58
que uno quiera plantear, siempre va a haber 00:06:01
puntos en los cuales tenga que pensar 00:06:03
evaluar una condición 00:06:05
y en función de esa condición hacer una cosa 00:06:06
u otra, siempre, yo me quiero ir a París 00:06:09
vale 00:06:11
pero tengo este dinero 00:06:12
eh, miro 00:06:14
eh, billete de avión 00:06:17
¿el precio es menor 00:06:19
que mi dinero? sí, cojo 00:06:21
el avión, ¿el precio es mayor 00:06:23
que mi dinero? no, voy a mirar 00:06:25
la web de autobuses, vale, siempre 00:06:27
cualquier algoritmo que uno se vaya a plantear 00:06:29
para resolver un problema, va a necesitar tener la posibilidad de expresar esta sentencia. 00:06:31
¿Qué esta sentencia es? ¿Esto se cumple? Si hago esto, no se cumple, hago esto otro. 00:06:37
Y esto no es un tema de lenguaje de programación, es una idea, una idea que tenemos que poder expresar. 00:06:43
¿Vale? ¿Cómo expresamos esa idea al margen de cualquier lenguaje de programación? 00:06:50
Bueno, para eso están los diagramas de flujo, son una herramienta. 00:06:56
Los diagramas de flujo son una herramienta gráfica muy chorra y muy sencillita 00:07:16
para visualizar un algoritmo que yo ya tengo hecho, ¿vale? 00:07:19
Los diagramas de flujo son una herramienta para visualizar algoritmos de forma gráfica. 00:07:25
Entonces, cuando estamos en la fase de pensar yo mi algoritmo, 00:07:50
que todavía no estoy programando porque no me hace falta, 00:07:55
cuando estamos en la fase de pensar yo mi algoritmo, 00:07:57
a veces podemos hacer un pequeño diagrama de flujo para verlo. 00:08:00
y de hecho, pues cuando uno está haciendo un software 00:08:02
y está todavía en la fase de diseño 00:08:05
de ver cómo lo hace, para qué, para qué, para qué 00:08:07
pues cuando le quiere pasar 00:08:08
lo que ha hecho a otro para que el otro 00:08:11
continúa, pues le pasa un diagrama de flujo 00:08:13
con lo que ha pensado, no le pasa un código 00:08:15
escrito, le pasa un diagrama de flujo 00:08:17
el otro con el diagrama de flujo dice 00:08:19
ah, vale, este algoritmo lo has hecho así, voy a incorporarle 00:08:21
esto a otro, entonces es una herramienta 00:08:23
para la fase de elaboración 00:08:26
del algoritmo, vale, lo que pasa es como 00:08:27
la usamos tanto, se usa 00:08:29
tanto y está tan extendida 00:08:31
pues tiene ciertas 00:08:32
ciertas reglas, para que todos 00:08:35
usamos las mismas reglas, pero vamos 00:08:37
las reglas 00:08:39
básicas para esta herramienta gráfica 00:08:40
pues son que el diagrama 00:08:44
de flujo tiene un inicio, ¿vale? 00:08:45
eso está claro, tiene un inicio 00:08:47
se puede marcar así o con 00:08:49
un puntito así sin más, tiene el inicio 00:08:51
y ahora a partir de ahí ya empieza 00:08:53
el caminito del algoritmo, y el caminito 00:08:55
es una línea, que va por aquí y por aquí 00:08:57
es una línea, cualquier programa es una línea 00:08:59
que se va ejecutando 00:09:01
sentencia, sentencia, sentencia 00:09:02
vale, y esta línea 00:09:05
se va cruzando ya con acciones 00:09:07
se va cruzando con acciones 00:09:09
las acciones de asignar valor a variables 00:09:11
o de mostrar valor que son las 00:09:14
de entrada y salida 00:09:15
pues se suelen representar con los romboides 00:09:16
estos 00:09:19
¿vale? por ejemplo 00:09:20
pues yo quiero decir leer 00:09:23
mi variable n 00:09:25
por ejemplo 00:09:26
un algoritmo que 00:09:28
recibe dos números 00:09:30
y muestra la suma 00:09:32
pues lo primero que tenemos que hacer 00:09:34
leer del teclado 00:09:36
una variable, pues como eso es una sentencia 00:09:38
de entrada y salida, pues romboide 00:09:40
vale, que es lo siguiente que hago 00:09:42
leer la variable m, pues otra sentencia 00:09:44
de entrada y salida 00:09:46
leer m, vale, aquí 00:09:47
esto es una expresión de lo que 00:09:52
se va a hacer, esto no es lenguaje de planación 00:09:55
aquí no, eso de declarar 00:09:56
no sé qué, no 00:09:58
es una visualización de lo que hay que hacer 00:09:59
vale, mi algoritmo sigue 00:10:03
por aquí, ahora que tengo que hacer 00:10:05
ahora ya una sentencia 00:10:07
una expresión, una operación 00:10:08
para asignar, pues esas 00:10:10
sentencias generales que son operaciones 00:10:12
pues con un cuadradito normal y corriente 00:10:14
pues aquí diríamos 00:10:17
pues por ejemplo, el resultado 00:10:19
que lo llamo r 00:10:21
igual a n más m 00:10:22
vale, sentencias generales 00:10:24
que evalúan expresiones y lo asignan a valores 00:10:26
vale, una vez que he hecho esto 00:10:29
¿qué tengo que hacer? una sentencia de salida 00:10:31
porque ahora lo muestro por pantalla 00:10:33
pues un romboide porque es sentencia de salida 00:10:34
y pongo mostrar 00:10:37
vale, he acabado el algoritmo 00:10:41
para resolver el problema 00:10:44
de recibir dos valores y mostrar 00:10:45
la suma, pues sí, ya lo he acabado 00:10:47
pues nada, fin 00:10:49
ala 00:10:50
vale, pues este es un algoritmo válido 00:10:52
Porque es una secuencia de cosas una tras otra 00:10:56
Y eso tiene que ser así siempre 00:10:59
Una secuencia de cosas 00:11:01
Pa, pa, pa, pa 00:11:02
Una tras otra 00:11:04
Aquí no pasan cosas en paralelo, nunca 00:11:04
Una tras otra, pa, pa, pa, pa 00:11:07
¿Vale? 00:11:10
Y además acaba, en un fin 00:11:11
Si no acaba no es un algoritmo válido 00:11:12
Bueno, pues yo ya visualizo esto 00:11:14
Y viendo esto digo 00:11:16
Ah, vale, pues sí, esto hace lo que yo quiero hacer 00:11:18
Y entonces ahora ya 00:11:21
Pues lo puedo pasar a un lenguaje para vaciar 00:11:22
una vez que tengo un diagrama de flujo 00:11:25
pasar al lenguaje de pronunciación 00:11:29
ya es inmediato 00:11:30
bueno, ¿significa esto que vosotros cada vez 00:11:31
que hagáis un programa tenéis que hacer un diagrama de flujo antes? 00:11:36
pues no, lo cuento como que es una herramienta 00:11:39
para visualizar de forma gráfica 00:11:41
algoritmos 00:11:44
y lo he puesto ahora porque para visualizar 00:11:44
gráficamente lo que es una sentencia de decisión 00:11:48
pues nos es muy útil 00:11:50
¿vale? pero nosotros 00:11:51
hacemos programas cortos 00:11:53
entonces pues sí, uno tiene que hacerse un diseño 00:11:56
con su lápiz y papel 00:11:58
cuando ya el programa tiene cierta complejidad 00:11:59
y cuando ya tiene claro lo que quiere hacer 00:12:01
ya se ha hecho sus 00:12:04
tachones y sus cosas en el papel 00:12:05
pues entonces ya 00:12:08
se pone a programa 00:12:09
que cuando estáis haciendo ese primer diseño 00:12:10
de esto como lo hago y ahora le sumo 00:12:13
pues entonces tengo que hacer esto, no sé qué 00:12:15
¿os viene bien usar un diagrama de flujo en vuestro papel y lápiz? 00:12:17
genial, pues lo usáis 00:12:20
¿vale? 00:12:22
Pero lo importante es que antes de hacer un programa, antes hay una, de codificar un código, antes hay una fase que es, ¿qué tengo que hacer? ¿Cómo lo voy a hacer? 00:12:23
Y ahí se hace uno sus graficitos y sus rollos hasta que tiene ya claro cómo lo va a hacer. 00:12:33
Y eso ya ni es Java, ni es Python, ni es nada. 00:12:39
Cuando tiene claro cómo lo va a hacer, pues ahora, hombre, se pone a codificar. 00:12:42
bueno 00:12:45
vale, pues entonces 00:12:47
vamos a incorporar 00:12:50
la sentencia de decisión en nuestros algoritmos 00:12:51
en los algoritmos 00:12:54
bueno, pues por ejemplo, en este algoritmo podría ser 00:12:55
leer n y m 00:12:57
y mostrar 00:13:00
la suma solo en el 00:13:02
caso de que sea positiva 00:13:04
si es negativa, pues mostrar 00:13:05
es negativo 00:13:08
entonces no es válido, por ejemplo 00:13:09
es un programa que necesita sumar 00:13:11
dos variables, pero la suma solo tiene sentido 00:13:14
para esa aplicación si fuera 00:13:16
positiva, por ejemplo, si es negativa 00:13:18
no, bueno, pues ya lo hemos cambiado 00:13:20
leer dos variables, mostrar suma si es positiva 00:13:22
y si no, pues decir 00:13:24
pues no, pues lo siento 00:13:25
el resultado no es válido 00:13:28
bueno, pues este algoritmo 00:13:29
se nos modificaría de esta manera 00:13:31
tendría su inicio 00:13:34
eso, obligatorio como siempre 00:13:37
tenemos que leer dos variables 00:13:40
pues nada, dos sentencias de entrada y salida 00:13:41
leer n 00:13:44
y leer m 00:13:46
vale 00:13:52
ahora obtenemos la suma 00:13:52
vamos pasito por pasito para 00:13:56
r igual a n 00:13:58
más m 00:14:00
y ahora 00:14:01
no saltamos aquí directamente 00:14:04
porque esto 00:14:06
no lo hacemos si o si 00:14:07
claro, aquí tenemos dos opciones 00:14:09
o mostrar r 00:14:12
o mostrar 00:14:13
el resultado inválido, entonces aquí a donde me voy 00:14:15
tengo dos opciones, tengo la opción de 00:14:19
mostrar R o tengo la opción de 00:14:22
no válido, mostrar no válido 00:14:28
tengo que expresar en el algoritmo que tengo esas dos opciones 00:14:30
claro, un algoritmo tiene que saber si nosotros lo hemos definido perfectamente 00:14:35
hay que definir de qué depende 00:14:40
que depende, él no lo va a decidir aleatoriamente 00:14:42
nunca un programa 00:14:45
un programa nunca puede decidir 00:14:47
aleatoriamente que hace, siempre hay que decírselo 00:14:51
todo perfectamente pautado, vale, pues depende 00:14:53
de una condición, ¿cómo expresamos eso aquí? 00:14:56
pues las condiciones se ponen en un rombito 00:15:00
así, y aquí pondríamos R mayor que 0 00:15:02
que esa es mi condición 00:15:06
y las condiciones tienen dos opciones 00:15:08
true o false 00:15:11
dos ramas, la rama del sí 00:15:12
y la rama del no 00:15:15
tienen dos opciones 00:15:18
la rama del sí y la rama del no 00:15:20
¿vale? que la condición 00:15:21
se cumple 00:15:24
el algoritmo tira por la rama del sí 00:15:25
que la condición no se 00:15:28
cumple, el algoritmo tira por la rama del no 00:15:30
y ya se ha acabado 00:15:32
esta sentencia 00:15:34
esto en el diagrama se expresa 00:15:35
que cerramos por aquí 00:15:38
y el programa sigue 00:15:39
el algoritmo sigue si es que tuviera que hacer 00:15:41
más cosas 00:15:43
vamos a suponer que lo que tiene que hacer es ahora decir 00:15:44
adiós, por ejemplo 00:15:47
pues nada, esto vendría aquí, mostrar 00:15:48
adiós, sentencia de salida 00:15:51
y fin, ¿vale? 00:15:53
bueno, pues esto 00:16:02
que en el diagrama de flujo es así 00:16:03
esto 00:16:05
esta es la sentencia de decisión 00:16:06
que se programa con una 00:16:10
única sentencia en el lenguaje Java 00:16:12
sentencia de decisión 00:16:14
o sentencia selectiva 00:16:17
¿Vale? 00:16:20
Toda esta 00:16:22
O sea, la sentencia de decisión 00:16:23
es una sentencia ya compleja 00:16:25
No es como la de asignación 00:16:27
que es una sola línea 00:16:28
A igual a 3 más B 00:16:30
No, la sentencia de decisión es una única sentencia 00:16:32
pero es gorda, tiene cosas dentro 00:16:35
pero es una única sentencia 00:16:37
No asociéis sentencia a línea 00:16:38
No, una sentencia 00:16:40
no es una línea 00:16:43
Eso será una línea de código 00:16:44
una línea de código es una línea de código 00:16:46
está claro, es una línea de mi fichero de texto 00:16:48
pero una sentencia 00:16:50
es otra cosa, una sentencia es un 00:16:52
cuerpo que hace algo 00:16:54
de forma autónoma 00:16:56
una sentencia de asignación lo es 00:16:58
esta es una sentencia 00:17:00
n igual a 3 más b 00:17:03
eso es una sentencia 00:17:04
pero esta, que ahora la escribiremos como es otra 00:17:05
es otra única sentencia 00:17:09
es otra, es una sentencia compleja 00:17:11
porque incorpora una decisión 00:17:12
Lo que hago en la rama del sí y lo que hago en la rama del no, pero es una única sentencia. ¿Que tiene varias líneas de código? Pues sí, tiene varias líneas de código. ¿Vale? Entonces, línea de código es una cosa, es la línea de texto y sentencia es otra. Es un conjunto de líneas de código que hacen algo en concreto. ¿Vale? 00:17:15
hasta ahora que sentencias hemos visto 00:17:36
repito, pues las de 00:17:39
declaración de variables 00:17:40
y las de asignación 00:17:42
asignación leyendo por teclado 00:17:43
o directamente, me da igual 00:17:48
pero son las únicas que hemos visto 00:17:49
y la de mostrar por pantalla 00:17:51
es de las sentencias que hemos visto 00:17:53
que coincidía que se escribían en una línea de código 00:17:55
pues sí, coincidía que se escribían en una línea de código 00:17:58
pero en el resto 00:18:00
de sentencias no, no se van a escribir 00:18:02
en una única línea de código 00:18:03
bueno pues esta es la primera 00:18:05
de ellas 00:18:08
entonces 00:18:08
la visualización gráfica está clara 00:18:10
el algoritmo se parte en dos ramas 00:18:13
pero eso no significa 00:18:16
que el algoritmo haga dos cosas en paralelo 00:18:18
nunca jamás hace dos cosas 00:18:20
en paralelo 00:18:22
el algoritmo o bien va por aquí 00:18:22
o bien va por aquí 00:18:25
depende de los datos de entrada 00:18:27
en una ejecución a lo mejor va por aquí 00:18:29
una única línea 00:18:32
pero dentro de tres días lo vuelvo a ejecutar 00:18:34
meto otros datos distintos 00:18:37
y va por aquí 00:18:39
luego solamente hay un camino 00:18:40
ese camino, ¿qué toma? 00:18:43
¿cuál es? pues depende 00:18:45
a veces tomará uno, a veces tomará otro 00:18:46
pero en cada ejecución 00:18:49
solo toma uno, ¿vale? 00:18:50
esto no es que haga varias cosas a la vez 00:18:53
porque a veces el diagrama de flujos y vemos dos líneas 00:18:54
y decimos, anda, está haciendo dos cosas a la vez 00:18:57
no, está haciendo dos cosas 00:18:59
o hace esto, o hace esto 00:19:00
luego el algoritmo es una 00:19:02
secuencia de cosas, pues esta lo es, esta, esta, esta, esta, esta y esta 00:19:04
para un caso de datos de entrada, o esta, esta, esta, esta, esta y esta 00:19:10
siempre es una secuencia de cosas, nunca se hacen en paralelo nada 00:19:15
y aprovechando ya la visualización del gráfico 00:19:18
la sentencia de decisión, las dos ramas, siempre se tienen que unir 00:19:25
en algún punto, es decir, esta sentencia tiene que terminar 00:19:29
esta sentencia arranca aquí 00:19:32
cuando se evalúa 00:19:35
la decisión, ahí arranca 00:19:37
y termina cuando ya ha completado 00:19:38
la rama que haya ejecutado 00:19:41
¿vale? 00:19:43
entonces, esta rama 00:19:45
se une con esta otra 00:19:47
y esta sentencia a veces 00:19:49
irá por aquí o a veces irá 00:19:51
por aquí, pero vaya por donde vaya 00:19:53
siempre tiene que llegar al mismo punto 00:19:55
siempre, y a partir 00:19:57
de ese punto ya el programa sigue 00:19:59
si es que tiene que hacer más cosas, ya sigue 00:20:01
¿vale? siempre tiene que llegar al mismo punto 00:20:02
no puede ser que esto se abra y a partir 00:20:05
de aquí ya hagamos 00:20:07
vida libre y esta otra hagamos 00:20:08
vida libre, pues entonces habría dos fines 00:20:11
no, solo hay un único 00:20:12
fin, un punto de terminación 00:20:15
solo hay uno, entonces estas dos ramas 00:20:17
se han abierto en función de esta condición 00:20:19
pero se unen cuando termina esta 00:20:21
sentencia, se unen y a partir de aquí 00:20:23
el programa sigue hasta llegar a su fin 00:20:25
¿vale? puede ser 00:20:27
que en una rama no nos interese hacer nada 00:20:31
si es mayor que 0 mostrar R 00:20:32
y si no, nos quedamos 00:20:35
enmudecidos 00:20:37
nada, esto se expresa así, ya está 00:20:38
¿vale? 00:20:41
claro 00:20:44
no, no, no, esto se expresa así 00:20:45
que se cumple, hago esto 00:20:47
y me vengo a este punto, para ya seguir 00:20:49
con el resto del programa 00:20:51
que no se cumple, hago esto 00:20:52
que es nada 00:20:55
y me vengo a este punto, que implica seguir 00:20:56
con el resto del programa 00:20:59
¿vale? y podría también 00:21:00
no tener nada esta 00:21:02
y ser esta la que lo tiene 00:21:03
podría también 00:21:06
entonces esta pues estaría así 00:21:08
y ya está 00:21:10
lo que no tiene sentido es que no tuvieran nada las dos 00:21:11
entonces esto directamente 00:21:14
no sirve para nada 00:21:16
pero una de las dos tiene que tener algo 00:21:17
¿vale? bueno pues entonces 00:21:20
ahora ya teniendo claro 00:21:28
que es esto ahora ya si podemos 00:21:30
codificar esto en lenguaje Java 00:21:32
ya tenemos clarísimo que significa 00:21:34
y como codificamos esto en lenguaje java 00:21:36
lo voy a escribir aquí 00:21:40
primero 00:21:42
vale, pues nuestro programita 00:21:44
ahora ya hacemos esto en lenguaje java 00:21:48
me ahorro el main y todo eso 00:21:50
esto primero de aquí 00:21:53
ya lo sabemos hacer 00:21:55
mi variable n la voy a leer del teclado 00:21:58
supongo que tengo el escáner por ahí arriba 00:22:00
a la leída 00:22:02
mi variable m también 00:22:08
Vale, ya he programado las dos primeras 00:22:11
Tengo una duda 00:22:23
Pero es más de estética 00:22:24
Estética 00:22:26
Cuando pones lo del lector 00:22:27
¿Compensa ponerlo en mayúsculas porque es un objeto? 00:22:30
No, no, no, no, no 00:22:32
Porque lector es el nombre de la variable 00:22:33
Los nombres de variable 00:22:36
Es recomendable que empiecen siempre por minúsculo 00:22:37
Da igual que sean variables tipo objeto 00:22:41
Lo que sí que empieza por mayúsculas 00:22:43
Es el nombre del tipo 00:22:45
El nombre del tipo sí 00:22:46
Escarne los mayúsculas, los nombres de las variables 00:22:47
para que se vea, son variables 00:22:50
para ver si son de tipo objeto o no 00:22:51
uno se va al tipo de la declaración 00:22:54
y dice, ah, entonces esto es tipo objeto 00:22:55
vale, entonces 00:22:57
ahora que nos falta, guardar una variable de resultado 00:23:00
pues venga 00:23:03
int r igual a n más m 00:23:03
y ahora seguimos 00:23:09
programando nuestro código 00:23:11
y decimos, ah, ahora me viene una 00:23:12
sentencia de decisión 00:23:14
que es, evalúo una condición 00:23:15
rama del sí 00:23:18
rama del no 00:23:20
vale, pues ahora ya nos vamos 00:23:21
a la sentencia de decisión, toda esta 00:23:25
pues toda esta sentencia de decisión 00:23:26
¿cómo es? 00:23:29
if entre paréntesis 00:23:30
la condición 00:23:33
una condición válida como las que ya sabemos 00:23:34
hacer, condición 00:23:37
todo lo larga o corta que 00:23:38
nos interese, r 00:23:40
es mayor que cero 00:23:42
¿vale? y ahora en general 00:23:44
la forma más general 00:23:47
entre llaves 00:23:48
que por cuestiones de estilo 00:23:49
pues la llave de apertura 00:23:53
la pongo detrás del if 00:23:55
y la de cierre 00:23:56
la pongo aquí a la misma altura 00:23:58
que el if, para que el estilo quede bonito 00:24:01
no es que sea obligatorio 00:24:04
podría ponerlo todo seguido, todo abajo 00:24:05
pero que haría un programa muy feo y con un estilo 00:24:07
cero, con lo cual nadie os contrataría 00:24:09
vale, pues aquí 00:24:11
entre estas llaves 00:24:13
lo que yo hago en la rama del sí 00:24:14
que puede ser una o muchas sentencias 00:24:17
no tiene por qué ser una, puede ser una 00:24:19
muchas, yo en este caso solo tenía una 00:24:21
que era mostrar el resultado 00:24:22
pues en este caso 00:24:24
solo tenía mostrar lo abrevio 00:24:26
y no tengo más, pero puede ser que aquí 00:24:30
tuviera muchas cosas 00:24:33
puede ser que tuviera muchas 00:24:34
vale, pues la rama del sí ha terminado 00:24:35
esta llave se cierra 00:24:38
¿cómo expreso lo que se hace 00:24:40
en la rama del no? 00:24:43
pues poniendo un else 00:24:45
abriendo otra llave 00:24:46
que se cierra 00:24:49
aquí por cuestiones de estilo 00:24:51
también, y aquí pongo 00:24:53
lo que se hace en esta 00:24:55
rama, que de nuevo puede ser 00:24:57
una o muchas, en este caso 00:24:59
era mostrar no válido 00:25:01
pues venga, no 00:25:03
válido 00:25:07
si, si, si 00:25:08
estas llaves 00:25:16
incluyen lo que se hace 00:25:18
en la rama del sí, luego 00:25:20
viene el se, y estas llaves incluyen lo que se 00:25:22
hace en la rama del no 00:25:24
Bueno, es que el ELSI ya significa 00:25:25
Si esta no, va asociado a esta 00:25:30
Va asociado al IF aunque vaya fuera 00:25:31
Claro, claro, el ELSI siempre va con un IF 00:25:33
Porque no ha puesto punto y coma para terminarla 00:25:36
Claro, claro, el ELSI siempre va con un IF 00:25:38
Siempre va con un IF 00:25:39
El ELSI se refiere si la condición del IF 00:25:41
Falsa 00:25:44
El ELSI suelto nunca puede ir 00:25:44
No va englobado como en el mismo 00:25:47
Claro, pero 00:25:49
Sí, claro 00:25:52
True esto, false esto 00:25:56
El else, si tú lo escribes solo en Java 00:25:58
El else no te dice 00:26:00
Y este else no ha salido 00:26:02
Tiene que haber un if siempre antes 00:26:03
Con unas sentencias metidas 00:26:05
Vale, que alguna de las dos ramas no tiene nada 00:26:06
Dejo esto en blanco 00:26:10
Ya está 00:26:12
No pasa nada, lo puedo dejar en blanco 00:26:12
¿Vale? 00:26:15
Una pregunta 00:26:17
En Java, en este caso 00:26:17
se va a identificar hasta else 00:26:20
que acaba ahí en la sentencia if 00:26:22
claro, entonces, cuando el else ya ha terminado 00:26:24
este cuadrito 00:26:27
es la sentencia if 00:26:29
que yo digo 00:26:32
que es esta, esto de aquí 00:26:32
o sea, esto es esto 00:26:34
la programación de esto es esto 00:26:36
y eso es una única sentencia 00:26:40
no, porque es no 00:26:43
o sea, sí o no 00:26:46
no hay más opciones 00:26:48
sí o no 00:26:49
una condición no es sí o es no 00:26:51
claro, puedes poner 00:26:53
efectivamente más sí, pero eso 00:26:55
es otra sentencia 00:26:57
claro, es otra 00:26:59
bueno, más que otra sentencia es otro formato 00:27:01
de lo mismo 00:27:03
pero sentencia de decisión como tal 00:27:04
solo existe esto 00:27:07
porque esto es lo único que vamos a hacer 00:27:09
en función de la condición y me he formulado otro 00:27:11
luego otra cosa es que hay situaciones 00:27:13
concretas que con otra 00:27:15
manera de describir esto a lo mejor nos es más fácil 00:27:17
de escribir, eso ya lo hemos hablado, ¿vale? 00:27:19
Pero esta es la única necesaria, no hace falta 00:27:21
nada más, no hace falta nada más 00:27:23
¿vale? Entonces 00:27:25
importante, que veáis 00:27:27
esto como una única sentencia 00:27:29
entonces 00:27:31
cuando Java ve el comienzo de un if 00:27:33
ya sabe que tendrá una condición 00:27:35
después, un bloque 00:27:37
esto que está entre llaves lo llamamos bloque 00:27:39
en general, lo que va 00:27:41
un código entre llaves lo llamamos bloque 00:27:43
¿vale? Entonces ya hemos 00:27:45
visto en realidad antes un bloque 00:27:47
porque cuando hacíamos el método main 00:27:49
ya abríamos una llave 00:27:51
y la cerrábamos, entonces ya 00:27:53
hemos trabajado con bloques, lo que pasa es que hasta 00:27:55
ahora nuestro bloque era 00:27:57
todo el programa enterito, todo el programa 00:27:59
que es lo que estaba en el main, todo era nuestro bloque 00:28:01
ahora fijaos que dentro 00:28:03
de todo nuestro programa 00:28:05
hemos abierto un subbloque 00:28:07
más pequeñito, eso tiene 00:28:09
implicaciones que ahora tampoco nos vamos a meter 00:28:11
en ellas, simplemente deciros 00:28:13
que un código entre llaves 00:28:15
se le llama bloque, en términos de 00:28:17
programación se le llama bloque 00:28:19
vale, pues entonces, la máquina virtual 00:28:20
en cuanto ve un if, ya sabe 00:28:23
que necesita una condición 00:28:25
después, si no la ve te va a avisar 00:28:27
te va a decidir la condición 00:28:29
y luego ya sabe que vendrá un bloque de sentencias 00:28:30
y luego ya sabe que vendrá 00:28:34
opcionalmente 00:28:37
o no un else, porque 00:28:39
este no es obligatorio 00:28:41
es decir, si nos ha 00:28:43
quedado una sentencia if así 00:28:45
podemos 00:28:47
quitar esto, es decir 00:28:49
podría yo poner esto 00:28:51
y a Java le parece estupendo 00:28:52
no pasa nada, pongo esto 00:28:55
pero poner else sin nada 00:28:57
adentro, se puede 00:28:59
poner como quitar el else 00:29:02
y ya está 00:29:04
entonces si Java 00:29:04
ve un if 00:29:07
y ve que después del bloque de la rama 00:29:08
del si no tiene nada aquí, no tiene 00:29:11
el else, asume que se 00:29:13
acabó, que terminó la sentencia ahí 00:29:15
porque la rama del no, no existe 00:29:17
con lo cual en ese caso la sentencia 00:29:19
ha terminado aquí 00:29:22
ahí terminó, y ya sigue 00:29:23
con lo que venga a continuación 00:29:26
que ya es otra sentencia distinta con lo que sea 00:29:27
¿vale? 00:29:29
¿que ve un else? 00:29:32
vale, pues si ve 00:29:34
un else, entonces 00:29:36
ahora ya 00:29:37
es porque hay sentencias 00:29:38
Y hacer las sentencias que sean. 00:29:43
¿Vale? 00:29:46
Pero el else puede no existir. 00:29:46
Pero siempre hay que poner i. 00:29:49
Eso sí. 00:29:51
Eso sí. 00:29:52
Claro. 00:29:53
Podría, imaginaos en el programa de antes, 00:29:54
que lo que no se hace nada es aquí 00:29:57
y aquí se hace una cosa. 00:29:58
Llamémosle a por abreviar. 00:30:01
Vamos a suponer que este es mi algoritmo, 00:30:02
que ahí me ha salido así. 00:30:04
Entonces yo pondría si r mayor que cero, 00:30:05
i vacío. 00:30:08
Y luego pondría else a. 00:30:09
la codificación de esto 00:30:12
es esto, claro, otra cosa 00:30:14
es que queda horrible 00:30:16
claro, para eso 00:30:18
cambias la condición y pones la negada 00:30:20
¿no? si ponemos 00:30:22
la negada, lo que va 00:30:24
en la rama del no pasa a la rama del sí 00:30:26
y lo que va en la rama del sí pasa a la rama del no 00:30:28
¿no? si esta condición 00:30:30
se cumple hago esto, y si no se cumple 00:30:32
hago esto, si la condición la pones al revés 00:30:34
si esta condición no se cumple 00:30:36
la rama del no pasa a la rama del sí 00:30:38
y al revés, entonces para 00:30:40
dejar este código así tan feo 00:30:42
ponemos la condición al revés 00:30:44
la negamos, no R 00:30:46
mayor que 0, con lo cual este 00:30:48
pasa aquí arriba y el 00:30:50
else se ha quedado vacío 00:30:52
y como ahora el else es el que se ha quedado vacío 00:30:53
el else ya sí que lo puedo quitar 00:30:56
entonces más bonito ese 00:30:58
código que el anterior, más bonito 00:31:00
¿vale? y luego ya 00:31:02
si lo terminamos de arreglar, no R 00:31:04
mayor que 0, hombre es más fácil poner 00:31:06
R menor o igual que 0, ¿verdad? 00:31:08
Pero es lo mismo 00:31:10
Pero ya si lo queremos dejar más bonito 00:31:11
Pues pondríamos R menor o igual que 0 00:31:13
Que es la negada 00:31:15
Pero eso ya, bueno, es solamente para retocar 00:31:15
Nada más 00:31:19
¿Vale? 00:31:20
Entonces la sentencia aquí se 00:31:22
Y esta es la única sentencia necesaria 00:31:23
Lo que pasa es que, repito 00:31:27
Luego hay muchas situaciones que se pueden repetir 00:31:29
Muchas veces casos prácticos 00:31:31
Pueden repetir 00:31:33
Entonces observamos, uy, pues 00:31:34
Ese caso práctico 00:31:37
para programarlo con el if-else 00:31:39
tengo que anidar un montón de if-else 00:31:41
luego lo vemos, bueno pues te permite 00:31:43
un atajo para escribirlo más rápidamente 00:31:45
ya está, es un atajo para escribirlo 00:31:48
más rápidamente, lo único que existe en realidad 00:31:49
es esto, el if y el else 00:31:51
es lo único que computacionalmente 00:31:54
se ejecuta, lo único que se ejecuta 00:31:56
vale, otra cosa es que lo podamos 00:31:58
escribir de otra manera más abreviada 00:32:00
en casos concretos 00:32:01
bueno, pues entendidísimo 00:32:03
esto 00:32:08
vale, solo un 00:32:09
pequeño matiz más ahora mismo, antes de hacer algún ejemplo 00:32:11
con mi fielse. Cuando solo tenemos 00:32:15
una sentencia dentro y solo una, 00:32:17
las llaves son opcionales. No hace falta que estén. 00:32:21
Si solo tenemos una, 00:32:24
¿vale? En mi ejemplo de antes, cuando yo solo tenía el este, 00:32:26
bla, bla, bla, bla, puedo quitar la llave. 00:32:30
No, no pondría punto y coma. 00:32:36
No pongo punto y coma en ningún lado. Bueno, perdón, aquí. 00:32:38
Sí, sí, sí, aquí sí 00:32:40
Claro, las sentencias que te referías 00:32:41
Después de... vale, vale, sí, sí 00:32:44
Ahí sí, claro 00:32:46
Si solo tengo una 00:32:46
Estas llaves son opcionales 00:32:50
Si tengo más de una 00:32:52
Esta, otra, otra, otra 00:32:54
Tengo que englobarlas 00:32:56
En un bloque, ¿vale? 00:32:57
Porque si no, Java se hace un lío 00:32:59
Porque fijaos la situación 00:33:01
Imaginaos que yo quiero meter dos sentencias 00:33:02
Esta y esta otra 00:33:06
Y me he olvidado de poner las llaves 00:33:07
me he olvidado de poner las llaves 00:33:10
entonces, aquí se genera 00:33:12
una ambigüedad gordísima 00:33:15
la máquina virtual empieza a interpretar 00:33:17
esto 00:33:19
si la condición se cumple 00:33:20
¿vale? 00:33:22
la siguiente sentencia 00:33:26
es esta, y él interpreta 00:33:27
ah, vale, no hay un else, es un if sin else 00:33:29
interpreta que este 00:33:32
ya es fuera de la sentencia 00:33:33
interpreta que ya es fuera 00:33:35
¿vale? como no has puesto llaves 00:33:37
pues entonces solo es una sentencia 00:33:39
entonces interpreta 00:33:42
que esta ya no hay un else 00:33:43
y esta ya está fuera 00:33:45
entonces si yo quiero que las dos se hagan 00:33:46
en la rama del sí 00:33:49
tengo que meterla entre llaves 00:33:50
¿vale? 00:33:53
es decir, en este caso 00:33:58
las dos se hacen 00:33:59
si la condición se cumple 00:34:01
las dos 00:34:02
pero si quito las llaves 00:34:03
él asume que es solo la primera 00:34:05
porque no hay llaves, solo la primera 00:34:08
vale, pues la rama del sí es la primera 00:34:10
y como luego no veo un else, dice 00:34:12
será que no hay else porque no hay rama del no, no hay else 00:34:14
y ya interpreta que esta ya 00:34:16
es la que hay que hacer después de que la sentencia 00:34:18
hizo acabado, después, la que vendría aquí abajo 00:34:20
la hace 00:34:23
y luego ya viene el se suelto, el se suelto no existe 00:34:24
no tiene sentido, entonces te marca 00:34:27
error de compilación, te dice y es el se suelto 00:34:28
a que viene, vale 00:34:31
entonces, para obtener esos errores 00:34:32
lógicamente cuando son varias 00:34:35
las sentencias es obligatorio 00:34:37
obligatorio, es obligatorio que estén entre llaves, ¿vale? Si solo es una, pues no hace 00:34:38
falta, ¿vale? Bueno, pues antes de complicarlo más, vamos a buscar algún ejemplo o algo 00:34:44
para practicar. Vale, y ahora, pregunta sin ninguna trascendencia práctica. ¿Cuántos 00:34:54
habéis acabado desconectando 00:35:23
en todo el proyecto que he contado ahí? 00:35:25
¿Lanzar la mano? 00:35:29
No es para quedarme con vuestra casa, 00:35:31
si con vuestra casa ya me he quedado. 00:35:32
Es por tener esa alimentación. 00:35:34
¿Cuándo se habéis acabado desconectando? 00:35:36
¿De verdad, con absoluta sinceridad? 00:35:37
No sé si entero. 00:35:40
No sé si entero. 00:35:42
La vez más y más. 00:35:43
Vale. 00:35:45
¿Los demás que han levantado la mano 00:35:46
no han acabado desconectando y lo han seguido? 00:35:47
Bueno, pues habéis desconectado unos cuantos. 00:35:50
¿Y por qué habéis acabado desconectando? 00:35:53
¿Por qué se ha terminado? 00:35:54
¿Por qué mucho rato hablando seguido? 00:36:00
Sí, pero bueno, a ver, si entiendes 00:36:12
que si esta condición 00:36:14
pones la negada, 00:36:16
lo que toca hacer cuando esta condición se cumple 00:36:18
tocaría hacerlo cuando no se cumple 00:36:20
porque has puesto la negada. 00:36:22
Y si tú esta condición, 00:36:24
llámale A. 00:36:26
Cuando A se cumple, haces esto. 00:36:27
Y cuando A no se cumple, haces esto. 00:36:29
Si en lugar de A pones 00:36:31
si en lugar de A 00:36:33
pones la negada de A, 00:36:37
cuando A se cumple, 00:36:40
entonces toca hacer lo que hay aquí. 00:36:42
Y cuando no se cumple, toca hacer esto. 00:36:43
Entonces, siempre que cambias con un negado delante 00:36:45
la condición que hay aquí, 00:36:48
lo que hay aquí pasa aquí, lo que hay aquí pasa aquí. 00:36:49
Claro, y estás haciendo lo mismo, en realidad. 00:36:52
¿Vale? 00:36:54
Entonces, ¿eso para qué lo hemos hecho? 00:36:54
Pues si te queda un if vacío 00:36:57
Que queda muy feo, porque el if es obligatorio 00:36:59
Y no lo puedes quitar, si te queda un if vacío 00:37:00
Cámbiala, y lo del else pasa al if 00:37:02
Y el if al else 00:37:05
Y al else, como se queda vacío, lo puedes quitar 00:37:06
Claro, para cambiar 00:37:08
Esto pasa aquí y esto pasa aquí 00:37:11
Si le pones el negado delante 00:37:14
Bueno, pues a ver 00:37:15
Tenemos aquí 00:37:18
Unos cuantos ejercicios 00:37:25
Bueno, algunos mejores que peores 00:37:28
Unos más ilustrativos, otros menos 00:37:30
Tampoco es que vaya en orden de dificultad 00:37:33
Van un poco bueno 00:37:35
Como hemos podido sobrevivir 00:37:37
A ver 00:37:39
Vale, pues venga 00:37:40
Si volvemos al aula 00:37:58
Ah, que ya los he descargado 00:38:00
Ah, no, no los he descargado 00:38:01
Ah, perdón 00:38:02
Vale, pues sí 00:38:13
¿Qué? 00:38:24
¿Que lo adelantemos? 00:38:28
Vale, lo adelantamos 00:38:29
Venga, vale, paramos aquí 00:38:33
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
7 de octubre de 2024 - 18:33
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 43″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.23

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid