Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 9-10-23 - 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 9 de octubre de 2023 por Raquel G.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, no perdáis nunca el contexto de donde estamos, porque tenéis que conocer de qué estamos hablando para luego poder vosotros hablar con propiedad cuando se hagan entrevistas o tengáis que empezar a trabajar, ¿vale? 00:00:00
No olvidéis nunca saber en qué contexto nos estamos moviendo. 00:00:12
Vale, pues ahora nos estamos moviendo en el contexto de la programación estructurada, ¿verdad? 00:00:18
Y a ver, ¿alguien me podría decir por qué se caracterizaba la programación estructurada? 00:00:24
¿Quién me lo dice? ¿Algún voluntario? 00:00:45
No exactamente, ¿qué era lo más característico de ella? 00:00:52
La programación estructurada, ¿por qué está basada exclusivamente en qué? 00:00:57
En dos tipos de sentencias, ¿vale? 00:01:04
Recordad que el teorema de la estructura decía 00:01:06
que cualquier problema que yo quiera resolver con un ordenador 00:01:09
lo puedo hacer combinando en secuencia, una tras otra, 00:01:13
combinando en secuencia, sentencias selectivas y repetitivas. 00:01:17
Entonces, una vez llegada esa conclusión, 00:01:24
se desarrollan lenguajes de programación que tienen esas sentencias 00:01:28
y punto de pelota, añadiendo, por supuesto, la posibilidad de usar variables, 00:01:32
Porque es inevitable, si los programas trabajan con datos, esos datos tienen que estar en algún sitio. 00:01:37
Bueno, pues obviamente los lenguajes de programación tienen la posibilidad de declarar, crear y asignar valor a las variables 00:01:43
y luego ya con esos valores que están en las variables, cualquier cosa que uno quiera hacer, cualquier transformación que uno quiera hacer con esos datos, 00:01:50
cualquier operación, cualquier problema que se le plante, lo puede hacer combinando en secuencia estructuras selectivas y repetitivas. 00:01:58
o lo que es lo mismo, que nos suena más el nombre, decisiones y bucles, y ya está. 00:02:07
El problema es decidir exactamente cuál es la secuencia para construir algoritmo, ¿verdad? 00:02:13
¿Vale? Pues esa es la programación estructurada y esa es toda la programación que hay. 00:02:19
Otra cosa es que luego la metamos en unas estructuras más eficientes para reutilizar, 00:02:24
como la programación en todo objeto. 00:02:28
Pero la programación que conocemos y que programamos, salvo para aplicaciones muy específicas, 00:02:31
o basadas en otro tipo de computación o inteligencia artificial, todas son estructuradas, sí o sí. 00:02:37
Entonces, da igual que aprendáis Java, que aprendáis Python, que aprendáis lo que sea, porque es lo mismo. 00:02:42
Bueno, pues entonces, si cualquier programa se puede realizar combinando estructuras selectivas y repetitivas, 00:02:48
vámonos con la primera, ¿verdad? 00:02:54
Porque todo lo relacionado con variables primitivas, claro, con variables primitivas, 00:02:56
aunque ahora no entendamos lo que significa primitiva. 00:03:02
Primitiva es entender qué significa que no es variable objetos. 00:03:04
Hay dos tipos de variables, primitivas y objetos. 00:03:09
Las objetos no las conocemos todavía si las hemos manejado. 00:03:11
Y sobre las variables primitivas, que son las que hemos visto, ya sabemos todo lo que hay que saber. 00:03:14
Bueno, pues vamos a incorporar entonces las estructuras, las sentencias selectivas. 00:03:20
que es lo que 00:03:31
o ya podemos llamar 00:03:33
las sentencias de decisión 00:03:36
bueno pues esto incluye 00:03:38
la primera de dos necesidades 00:03:43
que hay que satisfacer 00:03:45
y solo esas dos, repito 00:03:47
solo esas dos 00:03:48
que es la posibilidad de 00:03:49
en función de una condición 00:03:52
y siempre en función 00:03:55
de una condición 00:03:57
no hay otra, en función de una condición 00:03:58
ya sabemos lo que es una condición 00:04:01
Una condición es algo que puede ser true o false 00:04:03
Solo tiene dos posibilidades 00:04:06
Una condición no es verdad o es mentira 00:04:07
Una condición no puede ser 7 o puede ser 5 00:04:08
O puede ser, hola, ¿qué tal? 00:04:11
No, una condición es algo que puede tomar solo dos valores 00:04:13
Verdad o mentira 00:04:16
Entonces lo podemos guardar en variables Boolean 00:04:17
Si queremos 00:04:20
Bueno, pues en función de una condición 00:04:21
Que ya entendemos lo que es 00:04:23
Y sabemos cómo construirlas en Java 00:04:25
Operadores relacionales 00:04:27
Y a su vez combinados con Anior 00:04:30
No hay otra 00:04:32
Bueno, pues en función de una condición decidir un camino. 00:04:33
¿Mi programa va por el camino 1 o mi programa va por el camino 2? 00:04:36
¿Vale? 00:04:42
Pues satisface esta necesidad que tiene todo el sentido del mundo. 00:04:44
Yo puedo querer que mi programa haga una cosa o haga otra en función de valores de datos de entrada, 00:04:48
en función de cosas que han pasado, es decir, en función de cosas que yo meto en una condición. 00:04:53
¿Vale? 00:04:59
pues entonces en función de cosas que yo meto 00:05:00
una condición que normalmente es 00:05:03
efectivamente calibra datos de entrada 00:05:05
en función de eso 00:05:07
pues yo tiro, mi programa tira por un camino 00:05:08
o mi programa tira 00:05:11
por otro camino 00:05:13
¿vale? recorre 00:05:14
esa necesidad que es inevitable 00:05:16
el programa puede hacer cosas distintas 00:05:18
en función de 00:05:21
circunstancias distintas 00:05:23
¿vale? 00:05:24
entonces el programa 00:05:28
Si la condición se cumple, tira por un lado 00:05:29
Si la condición no se cumple, tira por otro lado 00:05:32
No hay otra 00:05:34
Porque la condición no se cumple, no 00:05:35
¿Vale? 00:05:36
No es que esto de 00:05:38
Así, esta estructura así 00:05:40
Varios caminos en función de una condición 00:05:43
No tiene sentido 00:05:46
Porque la condición no es verdad o es mentira 00:05:47
Con lo cual, de una condición 00:05:50
Solo pueden salir dos caminos 00:05:51
¿Vale? 00:05:53
Esa primera cosa 00:05:55
Que parece trivial, pero tenemos que tener clara 00:05:56
para tener la cabeza estructurada 00:05:58
de una condición solo pueden partir dos caminos 00:06:00
esto es lo que se representa 00:06:03
¿recordáis del primer día o segundo día de clase? 00:06:06
cuando hablábamos de que hay herramientas 00:06:09
cuando uno está en esa fase previa de análisis y diseño 00:06:13
que es la fase más importante de la programación 00:06:15
cuando uno está entendiendo lo que tiene que hacer 00:06:18
y empezando a pensar cómo puede construirlo 00:06:21
todavía sin lenguaje de programación 00:06:24
sino grabador y sin nada, con papel y lápiz y ya está 00:06:27
pues cuando estábamos en esa fase 00:06:29
hablábamos de que uno entonces 00:06:31
pues se hace sus diagramitas, se escribe sus cosas 00:06:33
y uno de los diagramitas 00:06:35
que más sirven para clarificar 00:06:37
cómo podemos hacer un algoritmo 00:06:39
mencionamos que eran 00:06:42
los diagramas de flujo 00:06:43
¿verdad? 00:06:45
entonces un diagrama de flujo 00:06:56
es la expresión gráfica 00:06:57
de un algoritmo 00:06:59
entonces ahora ya si nos es más útil 00:07:01
pues para entender nuestros algoritmos 00:07:03
que tienen decisiones, bucles 00:07:05
ahora ya sí que puede ser más interesante 00:07:07
cuando solamente teníamos asignación a sentencias 00:07:09
el diagrama de flujo no tenía nada 00:07:11
ahora ya sí que puede ser más útil 00:07:13
expresión gráfica 00:07:15
de un algoritmo 00:07:19
recordad que el algoritmo 00:07:26
es la secuencia ordenada 00:07:30
de sentencias 00:07:32
pues la expresión gráfica de esa secuencia de sentencias 00:07:33
bueno pues una sentencia 00:07:36
sentencia de una sentencia selectiva, ¿qué aspecto tiene en un diagrama de flujo? Pues 00:07:40
el siguiente, los diagramas de flujo, cuando los veis en documentación, cuando estáis 00:07:52
estudiando por internet para entender algoritmos, para hacer cosas, los diagramas de flujo 00:07:56
veréis que suelen tener este aspecto. Un punto que es el punto que es el que se considera 00:08:00
de inicio. Ahí el programa arranca, inicio, ahí empieza nuestro algoritmo. El programa 00:08:04
tiene una línea de ejecución, va por aquí 00:08:10
el programa y va haciendo las sentencias 00:08:12
una tras otra 00:08:14
las sentencias de asignación 00:08:15
que son las únicas que hemos dado hasta ahora 00:08:18
asignar valor a una variable, sentencias de asignación 00:08:19
pues se mete en un cuadradito 00:08:22
por ejemplo, si yo quisiera 00:08:23
a una variable n asignarle el valor 7 00:08:25
pues 00:08:28
lo podría ir en un cuadradito 00:08:29
por ejemplo, ¿vale? 00:08:31
cualquier sentencia de asignación, un cuadradito 00:08:33
para decir, aquí asigno este valor, aquí asigno este valor 00:08:35
son las únicas sentencias que hemos visto hasta ahora 00:08:37
las que asignan valores a variables 00:08:39
para que os familiaricéis con los diagramas de flujo 00:08:42
cuando la asignación a una variable viene del exterior 00:08:47
de la consola, de un fichero 00:08:52
este cuadradito se cambia y se convierte en un romboide 00:08:55
porque el romboide implica sentencia de entrada desde el exterior 00:09:00
o salida al exterior 00:09:05
Entonces, si yo aquí quisiera leer del exterior 00:09:07
Pues lo que se suele poner es esto 00:09:11
Leer n 00:09:13
Pues esto ya sabemos cómo se programa en Java 00:09:15
Pues n igual a scan.nextin y ya está 00:09:18
Esto ya como se programa en Java es lo de menos 00:09:23
¿Vale? 00:09:25
Pero esto es una asignación más 00:09:26
Una asignación más donde a n 00:09:28
Lo que se le asigna es un valor recogido de fuera 00:09:29
Pero es una asignación 00:09:34
¿Vale? 00:09:35
pero bueno, para indicar que es una asignación especial 00:09:36
porque el valor viene recogido de fuera 00:09:38
en los derramas de flujo 00:09:40
se puede resultar con el romboide 00:09:42
y cuando mostramos por consola 00:09:44
igual, cuando mostramos por consola 00:09:46
como se entiende que es una salida hacia afuera 00:09:47
pues también se pone como un romboide 00:09:49
por ejemplo así 00:09:52
mostrar n 00:09:53
y ya sabemos como se muestra n en java 00:09:55
si luego queremos programar esto en java 00:09:57
pues system.out.print n 00:09:59
bueno, entonces las sentencias que hemos visto 00:10:01
hasta ahora eran esas, asignaciones 00:10:04
a variables previamente declaradas 00:10:05
claro, previamente declaradas 00:10:08
y ya está 00:10:10
y mostrar por consola 00:10:11
vale 00:10:13
en los diagramas de flujo las declaraciones 00:10:14
no tienen sentido 00:10:18
porque que una variable se declare o no 00:10:19
ya dependerá del lenguaje de declaración 00:10:22
que estemos usando, el lenguaje de declaración 00:10:24
que exige la declaración previa 00:10:25
es decir, esto 00:10:27
antes de que la variable se pueda usar 00:10:29
para lo que sea 00:10:32
y hay lenguajes que no exigen la declaración previa. 00:10:33
En el momento en el que se usa por primera vez, 00:10:37
el lenguaje de pronunciación automáticamente la declara. 00:10:40
Entonces la declaración como tal, como es específica ya del lenguaje, 00:10:44
no se incluye en los diagramas de flujo. 00:10:49
Los diagramas de flujo se incluyen las acciones, lo que hace cosas, 00:10:52
pues como asignaciones, lecturas desde el exterior o llevar cuentas. 00:10:56
vale, bueno, pues entonces 00:11:02
vamos a suponer que nuestro diagrama de flujo 00:11:03
además tenemos una decisión 00:11:07
en función del valor de n 00:11:08
es decir, primero lo leemos 00:11:10
leer la variable n 00:11:14
tendríamos la primera sentencia de nuestro 00:11:18
algoritmo 00:11:21
y ahora 00:11:22
este programita ejemplo 00:11:24
pues que va a hacer 00:11:26
pues por ejemplo lo que hicimos el otro día 00:11:28
mostrar si la variable 00:11:29
es par o impar 00:11:31
¿vale? entonces 00:11:32
el programa puede hacer 00:11:35
dos cosas distintas, o lo que es lo mismo 00:11:37
el programa tiene dos caminos 00:11:39
o bien el programa 00:11:41
me muestra 00:11:43
es par 00:11:44
o bien el 00:11:46
programa me muestra 00:11:49
es impar, tiene dos caminos 00:11:50
en realidad 00:11:56
¿vale? pero esto no se puede poner así, lógicamente 00:11:57
¿Y cuándo voy por este camino y cuándo voy por este otro? 00:12:01
Pues depende de una decisión 00:12:04
En cuanto a un programa se le abren dos caminos 00:12:06
Es decir, tiene la opción de hacer dos cosas distintas 00:12:08
Si yo lo identifico 00:12:12
Y este lo tiene identificado claramente 00:12:13
Tiene la opción de hacer dos cosas distintas 00:12:15
O mostrar es par o mostrar es impar 00:12:17
Pues cuando yo identifico que un programa tiene dos caminos 00:12:19
Automáticamente, como ya hemos practicado con ese operador ternario 00:12:23
Pues automáticamente tenemos que pensar 00:12:27
En función de qué condición 00:12:29
Si hay dos caminos posibles, tiene que haber una condición asociada 00:12:31
No hay otra 00:12:34
En cuanto yo identifico dos posibles ramas 00:12:35
De actuación del programa 00:12:38
Automática ya tengo que decir 00:12:39
Vale, ¿y cuál es la condición? 00:12:41
Que fija si voy por aquí o soy por aquí 00:12:43
Bueno, pues en este caso 00:12:45
Ya pusimos el otro día que hicimos el programa 00:12:47
Dijimos, bueno, pues la condición para ver si un número es par 00:12:49
O impar es 00:12:51
Si el resto de dividir 00:12:53
Ese número entre dos 00:12:55
Me da igual a cero 00:12:57
vale, esto es escrito en Java 00:12:58
vale, esto ya es escrito en Java 00:13:00
pero la condición en realidad es 00:13:02
resto de dividir entre 2 es 0 00:13:04
vale, pues ya tengo la condición 00:13:05
pues entonces esto en el diagrama de flujo 00:13:07
lo veríamos así 00:13:10
la condición 00:13:12
se pone siempre en un rombo 00:13:14
vale 00:13:17
entonces lo puedo poner en mi propio lenguaje 00:13:18
aquí no estoy programando 00:13:27
vale, aquí no estoy programando 00:13:28
aquí yo sé que la condición es n es par 00:13:29
esa es la condición 00:13:32
ahora otra cosa es como la programe yo cuando vaya a codificar 00:13:33
esto, dependerá del lenguaje 00:13:36
pero yo tengo que aislar la condición 00:13:37
la condición para indicar 00:13:39
si voy por un camino o si voy por otro 00:13:41
es que n sea par 00:13:43
¿vale? bueno, pues del rombito 00:13:45
que diga la condición, tienen que salir 00:13:47
dos ramas obligatoriamente 00:13:49
dos, tienen que salir 00:13:51
la rama de lo que se hace, cuando 00:13:53
sí se cumple y la rama de la que no 00:13:55
y cuando se cumple 00:13:57
nos llevará ya a una sentencia 00:13:59
o muchas. No te duermas, anda. ¿Vale? A una o muchas. Y cuando es que no, me tiene que 00:14:01
llevar por otro camino, a otra serie de sentencias, a una o muchas. En este caso solo hay una, 00:14:09
pero bueno, a lo mejor podría haber más por aquí. En este caso solo hay una, podría 00:14:16
haber más por aquí. Entonces, este es el diagrama de control de flujo de una sentencia 00:14:19
de decisión o selectiva. El problema viene por donde venga. Tiene una única línea de 00:14:25
ejecución, viene por aquí, de repente se encuentra una condición y en función de 00:14:29
esa condición hay solo dos posibilidades, dos caminos, o voy por aquí o voy por aquí, 00:14:36
hay dos caminos, si voy por aquí, aquí habrá ya una o más sentencias, en mi caso solo 00:14:42
una, mostrar es par, si voy por aquí habrá una o más sentencias, en mi caso solo hay 00:14:48
una muestra de sin par 00:14:54
y luego que pasa, el programa sigue 00:14:55
en dos ramas hasta el infinito 00:14:57
no, si el programa está bien construido 00:15:00
el algoritmo 00:15:03
si el algoritmo está bien construido 00:15:04
y lo he diseñado bien 00:15:06
estas dos ramas 00:15:07
una vez que se ha terminado lo que se hace 00:15:09
en el caso de que sea par 00:15:12
y una vez que se ha terminado lo que se hace cuando sea impar 00:15:13
estas ramas tienen que juntar 00:15:15
y ahora ya el programa continúa por aquí 00:15:17
haciendo lo que sea que tenga que hacer 00:15:20
hasta que ya termine 00:15:23
¿vale? este sería el inicio 00:15:25
y este sería el fin 00:15:28
¿vale? 00:15:32
pues esta es la expresión de la sentencia de decisión 00:15:35
en el diagrama de flujo 00:15:37
entonces verla 00:15:39
nos ayuda sobre todo a entender una cosa 00:15:40
y es 00:15:43
que la sentencia de decisión en realidad es una única sentencia 00:15:44
para Java, ¿qué es todo esto? 00:15:48
¿qué es todo esto? 00:15:49
es una única sentencia 00:15:51
todo esto 00:15:52
lo que pasa es que es una sentencia compleja 00:15:53
porque involucra muchas cosas dentro 00:15:56
esta sentencia de asignación 00:15:58
o lectura, esta sería 00:16:00
la sentencia 1 00:16:02
de mi algoritmo 00:16:03
es sencilla, la sentencia 1 00:16:05
la puedo programar solamente por una línea 00:16:07
scan, next y lero 00:16:10
sentencia 2, la sentencia 2 00:16:12
esta es una sentencia 00:16:14
selectiva ya 00:16:16
esta es más compleja 00:16:17
porque involucra poner la condición 00:16:20
poner lo que hago en la rama del sí, poner lo que hago en la rama del no 00:16:23
pero es una sentencia más que tiene que acabar 00:16:26
tiene su inicio, que es aquí, y su fin, que es aquí cuando se juntan las dos cosas 00:16:28
y es una sentencia dos 00:16:33
ahora, después, vendrá una sentencia tres 00:16:34
si es que la hay 00:16:38
pero el programa siempre va a ser, como hemos dicho desde el principio 00:16:39
una secuencia de sentencias, una tras otra 00:16:47
una tras otra, esta de lectura 00:16:50
esta selectiva, ahora la que hay después 00:16:52
que puede ser despedirse, lo que sea 00:16:55
siempre es una secuencia de sentencias 00:16:58
y lo tengo que ver claro en mi diagrama 00:16:59
de flujo, porque si no, he hecho un programa 00:17:02
que no es estructurado y no lo puedo programar 00:17:03
me puedo empezar a plantear 00:17:06
empezar a programarlo y me sale 00:17:08
algo que no tiene ningún sentido 00:17:10
entonces el algoritmo, yo tengo que ver 00:17:11
gráficamente claro que, hombre, que sí 00:17:13
que esto es una secuencia de sentencias 00:17:15
válidas 00:17:17
esta es válida porque se va a programarla 00:17:18
esta es válida, es la sentencia de decisión 00:17:21
tal y como la hemos 00:17:23
definido, las que vengan por aquí 00:17:25
después 00:17:27
vale, importante esto 00:17:28
que cuando se acaba la rama 00:17:31
del sí, lo que se hace cuando se cumple 00:17:33
y cuando se acaba 00:17:35
la rama del no, lo que hace cuando 00:17:36
no se cumple 00:17:39
ambas ramas vienen al mismo punto 00:17:40
y el programa continúa por aquí 00:17:42
vale, continúa por aquí 00:17:45
y todo esto se seguirá 00:17:48
haciendo independientemente 00:17:49
de la condición porque ya está afuera 00:17:51
Voy a poner el diagrama un poco más arriba 00:17:53
Vamos a poner la sentencia aquí un poquito más arriba 00:18:00
Esta es la condición 00:18:15
La que sea 00:18:16
Rama de sí se cumple 00:18:18
Rama de no 00:18:23
Aquí puede haber un montón de sentencias 00:18:25
Las que sean, me dan igual 00:18:27
Aquí puede haber un montón de sentencias 00:18:29
Las que sean, me dan igual 00:18:32
Cuando estas han terminado 00:18:33
El programa ya continúa por aquí 00:18:36
Cuando estas han terminado 00:18:38
El programa continúa por aquí 00:18:40
¿Vale? 00:18:41
Imaginamos que esta sentencia 1 00:18:43
Sentencia 2 00:18:45
Sentencia 3 00:18:46
Sentencia 4 00:18:47
Sentencia 5 00:18:48
El programa continúa hasta que termine 00:18:49
Y el programa viene por donde venga 00:18:52
¿Vale? 00:18:53
Entonces el programa siempre tiene que ser tal 00:18:56
Que cuando ya he terminado por esta rama 00:18:58
O cuando ya he terminado por esta rama 00:19:01
sigo por el mismo camino, sigo por aquí 00:19:03
y esta sentencia la voy a hacer igual 00:19:05
si la condición se ha cumplido o no 00:19:09
porque esta sentencia ya está, la sentencia 5 ya está fuera 00:19:11
de esta, ya está fuera 00:19:15
de la decisión, ya está fuera 00:19:18
si yo esta sentencia la quiero condicionar y que se haga solo 00:19:20
si se cumple la condición o si no, entonces la tendría que mover 00:19:24
ahí dentro, la tendría que mover 00:19:27
¿vale? 00:19:29
Pero si no, esta sentencia 00:19:31
Será la que se continúe 00:19:34
Ejecutando, tanto si voy por la rama del sí 00:19:36
Como si voy por la rama del no 00:19:39
¿Vale? 00:19:40
A ver, podría ocurrir 00:19:43
Que aquí el programa terminara 00:19:45
Que no hubiera más sentencias, vale, pues ha terminado 00:19:46
Estas dos ramas se han juntado 00:19:48
Y lo que hay que hacer a continuación es ya 00:19:50
Nada, por el programa terminado 00:19:52
Bueno, pues no pasa nada, el programa terminado no se hace nada 00:19:54
Pero tiene por qué, el programa puede ser que continúe haciendo cosas 00:19:56
¿Vale? 00:19:59
bueno, pues esto 00:20:01
aunque es una sentencia compleja 00:20:03
esto tenemos que verlo 00:20:05
como una única sentencia 00:20:07
lo que pasa es que es una sentencia compleja 00:20:09
porque a la hora de programarla 00:20:13
tengo que programar un montón de cosas 00:20:15
pero es una única sentencia 00:20:16
que va detrás de una y delante de otra 00:20:18
en secuencia 00:20:21
una detrás de una y otra delante de otra 00:20:22
y así tenemos que ver el programa 00:20:25
porque cuando entendamos 00:20:27
que eso es así, es una secuencia de cosas, es cuando ya podemos pensarlo, podemos pensar, 00:20:30
cuando tenemos la atención concreta ya podemos pensar cómo programarla, tenemos que entender 00:20:36
antes bien el funcionamiento, entonces es una secuencia, una sentencia tras otra y esta 00:20:39
es una de ellas, la de selección. Bueno, pues entonces, para usarla uno tiene que identificar 00:20:45
primero que la necesita, fundamental 00:20:53
¿vale? 00:20:55
entonces, después de leer un enunciado 00:20:57
entenderlo, pensarlo, es cuando uno identifica 00:20:59
si la necesita, porque dice 00:21:01
ah, vale, mi programa 00:21:03
que este es su resultado, esto es lo que tiene que hacer 00:21:04
o hace esto 00:21:07
o hace esto otro 00:21:09
o va por aquí o va por aquí 00:21:10
depende de una condición, ah, vale 00:21:13
pues identifico entonces que necesito 00:21:15
una sentencia de 00:21:17
selectiva 00:21:19
vale, lo identifico 00:21:21
que la necesito. Pues ahora ya la incorporo y voy construyendo mi programa. Pero primero 00:21:23
tengo que identificar la necesito. Entonces la necesito, es una sentencia más y la pongo 00:21:28
en mi programa. La pongo en mi programa dentro del conjunto de sentencias que él tenga. 00:21:33
¿Vale? Bueno, pues la tenemos clara y entendida, ¿cómo la programamos? Pues ya la parte de 00:21:38
programarla es inmediata. En el ejemplo de en es par o impar. Aquí mostramos un mensaje, 00:21:53
aquí mostramos otro. Y el programa llega por aquí y nos dice luego adiós. Entonces 00:22:09
el adiós identificamos que va fuera, claro, porque decir adiós lo va a decir tanto si 00:22:16
ha dado que es par o que ha dado que es impar 00:22:23
entonces el adiós va afuera 00:22:25
¿vale? lo que va adentro solamente 00:22:27
decir si es par 00:22:29
o decir si 00:22:31
es impar 00:22:36
¿vale? eso es lo que va 00:22:36
lo que va afuera 00:22:39
vale 00:22:41
bueno pues ahora programar esto 00:22:56
es inmediato 00:22:58
la parte de antes 00:23:00
que sería leer n 00:23:02
bueno pues nuestro par vendría 00:23:03
por aquí con su main 00:23:08
Vendría por aquí 00:23:10
Y ahora ya programarlo 00:23:13
Pues es una tras otra 00:23:16
Una tras otra 00:23:17
Leer n, pues bueno, tenemos el escáner 00:23:18
No sé qué, vamos a 00:23:21
Aquí lo que fuera 00:23:22
Para leer, ahora lo voy a escribir 00:23:26
Porque me voy a... 00:23:27
N ya está leído con un valor del teclado 00:23:28
Y ahora ya tenemos que programar 00:23:32
Esta sentencia 00:23:34
Esta 00:23:35
Vale, pues esa es una única sentencia, repito 00:23:36
Que toca programar 00:23:39
Pues como se programa 00:23:40
Bueno, pues en cuanto tengo una sentencia de decisión la programo 00:23:41
Empiezo con un if 00:23:44
Pongo entre paréntesis la condición 00:23:46
Ahora es el momento en el que tengo que pensar 00:23:51
¿Y cómo expreso yo mediante una condición este enunciado? 00:23:53
Pues ahí ya enlazamos con lo del otro día 00:23:57
Pues a ver, tengo un enunciado que en lenguaje natural lo entiendo perfectamente 00:23:59
Ahora tengo que convertirlo a lenguaje Java 00:24:02
Una expresión con operadores relacionales, operadores booleanos 00:24:05
Bueno, en este caso ya la convertimos el otro día 00:24:08
Y llegamos a la conclusión de que la expresión Java 00:24:11
Que expresa esa condición es esta 00:24:17
El resto de dividir entre 2 es igual a 0 00:24:19
Vale, pues una vez que ya tenemos la condición 00:24:22
Ahora ya tenemos que decir 00:24:26
¿Qué hacemos en la rama del sí y qué hacemos en la rama del no? 00:24:27
Pues en la rama del sí 00:24:32
Hacemos lo que metamos en unas primeras llaves 00:24:33
Por cuestiones de estilo 00:24:38
Para que el código no sea un chapucero 00:24:40
Y te echen al día siguiente 00:24:42
La llave se abre siempre 00:24:43
Igual que en el mail 00:24:46
La llave se abre siempre, la misma línea 00:24:47
Donde arranca 00:24:49
Y se cierra a la misma altura 00:24:51
Donde empecé 00:24:54
La sentencia en la que la abrí 00:24:55
¿Vale? 00:24:57
Por favor, seguid siempre esas reglas de estilo 00:25:00
Para que vuestros programas no sean un desastre 00:25:02
Desde el principio 00:25:04
Bueno, pues se abre aquí 00:25:05
y le acero la misma línea 00:25:07
y todo lo que ponga aquí, todo lo que ponga 00:25:09
que puede ser una sentencia dos o mil 00:25:11
todo lo que ponga 00:25:13
es lo que se hace en la rama 00:25:14
esta del sí, en este caso 00:25:17
lo que se hace en la rama del sí era muy sencillo 00:25:19
que era mostrar 00:25:21
es par 00:25:22
en este caso era solo esto 00:25:24
pero podría ser 00:25:29
más cosas, porque el programa hiciera más cosas 00:25:31
en la rama del sí, en este caso es esto 00:25:34
pues ya no meto más 00:25:36
Ahora, ¿cómo indico lo que hago en la rama del no? 00:25:36
Pues pongo aquí un else 00:25:40
De nuevo, regla de estilo a continuación de la llave 00:25:42
Y abro su llave 00:25:47
Llave que voy a cerrar a la altura de la línea donde abrí la llave 00:25:49
A esa altura 00:25:57
¿Vale? 00:25:59
Y aquí pongo lo que se hace cuando no 00:26:01
Lo que se hace cuando no 00:26:03
En este caso, simplemente mostrar por consola es impar. 00:26:05
¿Vale? Pues ya está. 00:26:15
Esa es la codificación tal cual de esa sentencia. 00:26:24
Y la condición. 00:26:27
La condición. Parte complicado, obviamente. 00:26:29
Pensar qué condición necesitamos. 00:26:32
La condición. Puede ser pequeña o puede ser enorme. 00:26:34
La condición que sea. Puede tener un montón de andeos, la que sea. 00:26:37
Entre las llaves bien colocadas, 00:26:41
esto por estilo, no por obligación, 00:26:43
Todas las sentencias que hago cuando sí 00:26:45
Y cuando no 00:26:47
Pues dentro de las llaves bien colocadas 00:26:49
Después del else 00:26:52
Y ya está 00:26:53
Y ahora ya este punto 00:26:54
Que es en el que se unen las dos 00:26:56
Es este punto 00:26:58
Ahora ya mi programa continúa por aquí 00:26:59
Mi programa sigue a partir de aquí 00:27:02
Y todo esto se va a hacer 00:27:04
Me da igual que yo haya entrado 00:27:06
Por sí, por el if 00:27:08
O que haya entrado por el else 00:27:10
Me da lo mismo 00:27:11
El programa continúa con su siguiente sentencia 00:27:12
¿Veis? Tenemos ahora mismo dos 00:27:15
Tenemos esta, que es la sentencia 1 00:27:17
Esta otra, otra sentencia más 00:27:20
Sentencia 2, llamémosle 00:27:23
Y a partir de aquí las sentencias que sigan 00:27:26
Sentencia 3, es una secuencia, una tras otra 00:27:28
Una sentencia, otra, otra 00:27:31
Y así se van ejecutando una tras otra 00:27:34
Lo que pasa es que esta es una sentencia compleja 00:27:35
Que incluye dos ramas 00:27:38
Se hace esta o se hace la otra en función de esta condición 00:27:40
Pero me da igual 00:27:43
Haber entrado aquí que haber entrado aquí 00:27:45
Me da igual 00:27:47
Luego, una vez que ya he terminado con esto 00:27:47
El programa continúa por aquí 00:27:51
Que en este caso, pues podría ser mostrar 00:27:52
El adiós 00:27:55
O sea, el adiós, ahí lo muestro 00:27:59
¿Vale? 00:28:01
Y esta sentencia se va a hacer 00:28:07
Repito 00:28:09
Me da igual haber entrado aquí que aquí 00:28:09
Bueno, pues esa es la codificación 00:28:11
Y con eso 00:28:20
esa es la única sentencia selectiva 00:28:21
que necesitaríamos, la única 00:28:23
lo que pasa es que 00:28:25
luego se hacen otras variantes 00:28:27
para expresar 00:28:29
de forma más sencilla a lo mejor situaciones 00:28:31
concretas, que ya vamos 00:28:33
a ir incorporando, pero otras variantes 00:28:35
no son necesarias, son como diferentes 00:28:37
posibilidades, es como hacer mesas 00:28:39
de diferentes colores, pues con tener 00:28:41
una del color que fuera 00:28:43
podríamos tirar, pero si nos las dan 00:28:45
de diferentes colores, pues mira, a lo mejor 00:28:47
me pega mejor con la alfombra 00:28:49
Pues aquí igual, la única sentencia que damos para programar 00:28:51
En lo que a decisiones se refiere es esta 00:28:55
Con esto podemos hacerlo todo 00:28:59
Pero bueno, tiene pequeñas variantes 00:29:00
Pues para adaptar situaciones 00:29:04
Y que te quede el código más bonito 00:29:07
Solamente para eso, que te quede el código más bonito 00:29:09
Para nada más 00:29:11
Bueno, alguna duda 00:29:13
Entonces aquí los pasos son 00:29:20
Primero, el más importante 00:29:22
cuando uno está analizando y diseñando 00:29:23
un código 00:29:26
identificar cuando necesita 00:29:27
esa sentencia, eso es lo más importante 00:29:30
esto, lo que es escribir Java 00:29:32
eso es lo de menos, es lo que menos nos importa 00:29:34
en este módulo, en programación 00:29:36
lo que menos nos importa es teclear código 00:29:38
lo que más nos importa es 00:29:39
identificar estructuras e incorporar 00:29:40
patrones de pensamiento 00:29:44
y destrezas lógicas 00:29:47
es lo que nos importa, escribir código 00:29:48
no nos da igual 00:29:50
entonces, aquí lo importante es 00:29:51
que cuando uno está en esa fase, analizar y enseñar un código 00:29:54
identifique en un momento dado 00:29:56
que lo que necesita es 00:29:59
efectivamente dos ramas 00:30:00
porque o bien hago esto o bien hago lo otro 00:30:01
identificarlo 00:30:04
pero tengo identificado 00:30:05
dar el salto de y de que dependo 00:30:07
pues ahí viene otra parte complicada 00:30:10
que es 00:30:12
identificar bien esa condición 00:30:13
identificarla bien y luego ya 00:30:16
ver como programarla 00:30:17
eso ya sí, una vez que uno 00:30:21
haya identificado la condición en su lenguaje 00:30:23
natural, ver cómo 00:30:25
trasladarla al lenguaje de programación 00:30:26
la condición 00:30:28
y luego ya, mete en la rama del sí esto 00:30:29
en la rama del no esto 00:30:32
y ya está, y tira 00:30:33
¿vale? 00:30:36
vale 00:30:40
bueno, vamos a 00:30:40
bueno no, espera, como quedan tres minutos 00:30:42
vamos a dejar esto 00:30:44
entonces, en realidad hemos estado haciendo esto 00:30:45
todo el rato 00:30:48
cuando estábamos haciendo el operador 00:30:49
ternario este famoso 00:30:51
pero lo hemos estado haciendo para un caso muy concreto 00:30:52
o sea, esto tal y como yo lo he hecho 00:30:55
con el, mostrando aquí 00:30:57
system out, system out 00:30:59
no lo puedo hacer, el operador 00:31:01
ternario es una 00:31:03
abreviatura, una forma 00:31:05
sencilla de poner un 00:31:07
if cuando lo único que tengo 00:31:09
en la rama del sí y lo único que tengo en la rama del no 00:31:11
es una sentencia de asignación 00:31:13
como por ejemplo, si yo tengo un string 00:31:15
ese? ¿S igual a es par o S igual a es impar? ¿Vale? Luego en el caso concreto, en el caso 00:31:17
concreto de que yo tengo un if donde la única sentencia que tengo aquí es una asignación 00:31:26
a una variable y la única sentencia que tengo aquí es otra asignación a esa misma variable, 00:31:33
a esa misma, solo en ese caso, que es un caso reducido de if muy sencillo, normal es que 00:31:39
una estructura de selección, tengamos aquí un tropecientas 00:31:44
sentencia y otro tropecientas. 00:31:46
Bueno, pues en el caso de que sólo tenga 00:31:49
aquí una, que es una asignación, 00:31:50
y sólo tenga aquí otra, que es otra asignación, 00:31:52
pero a la misma variable, 00:31:54
pues en ese caso esto lo podemos convertir en lo que 00:31:56
ya lo hemos convertido muchas veces. 00:31:58
¿A ese qué le asigno? 00:32:01
Pues le asignas 00:32:03
par o le 00:32:04
asignas impar. 00:32:06
¿Y en función de qué se lo 00:32:09
asignas? De una condición. 00:32:10
entonces el operador ternario es un if 00:32:12
pero lo que haces en la rama del sí 00:32:19
y lo que haces en la rama del no 00:32:21
es simplemente una asignación 00:32:22
y a la misma variable 00:32:25
entonces si tú tienes un if 00:32:27
en lo que haces una asignación y a la misma variable 00:32:30
y solo haces eso 00:32:33
pues lo puedes abreviar así 00:32:34
pero en el caso general 00:32:35
que lo que hagas en la rama del sí o del no sean un montón de cosas 00:32:39
Pues a la vez pedir otro número 00:32:42
Compararlo con no sé qué, la rama del no 00:32:44
Pues pedir otra cosa 00:32:46
Pues ahí no tiene sentido ya meter esto 00:32:47
¿Vale? Esto lo metes solo 00:32:50
Cuando lo que haces en función de la condición es 00:32:52
Asignar un valor a esto 00:32:55
O asignar otro valor a esto 00:32:57
En ese caso no se puede simplificar 00:32:59
¿Vale? 00:33:01
Vale, venga, pues ahora sí que vamos a 00:33:04
A parar 00:33:06
A parar 00:33:11
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
9 de octubre de 2023 - 11:18
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
33′ 12″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
633.71 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid