Saltar navegación

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

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

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues estábamos todavía con el tema de programación estructurada. 00:00:00
La programación estructurada que es la base de la programación orientada. 00:00:24
Entonces, la programación estructurada combinaba en secuencia, 00:00:31
en secuencia, una tras otra, una tras otra, cuando una se acaba empieza la siguiente, 00:00:37
cuando una se acaba empieza la siguiente, sentencias, ¿verdad? 00:00:41
Y de esas sentencias las que hemos visto son las de asignación de valores a variables, 00:00:45
variables previamente declaradas, ¿no? 00:00:52
Entonces, variables previamente declaradas, asignarles valor. 00:00:55
Me da igual que sea como resultado una expresión o leídas del teclado, 00:00:59
con el objeto escáner, me da igual, en ambos casos son asignaciones, ¿no? 00:01:05
Asignación siempre, nombre de variable a la izquierda, 00:01:10
nombre de variable a la izquierda, valor que asignamos a la derecha, 00:01:16
esa es la asignación, ¿verdad? 00:01:23
Aquí una expresión cualquiera, un valor o leído del teclado, me da igual, 00:01:26
esta expresión a su vez puede involucrar otras variables, 00:01:31
bueno, todo eso es lo que tenemos que tener ya más o menos en la cabeza dominada. 00:01:34
Vale, aparte de las sentencias de asignación, ¿qué más sentencias conocemos? 00:01:38
Las de decisión, las sentencias de decisión, un IF normal y corriente, 00:01:42
o un IF con un ELSE, o un IF con varios ELSE-IF, 00:01:48
si es que uno quiere, porque se adapta a su situación, 00:01:57
en lugar de simplemente esta situación que si algo se cumple bien y si no hago esto, 00:02:03
y acabo la sentencia, pues si nuestra situación es, si algo se cumple bien y si no, 00:02:09
miro a ver si se cumple esta otra cosa, y si no, miro a ver si se cumple esta otra cosa, 00:02:14
si nuestra situación es esta, ¿vale?, varias ramas excluyentes, 00:02:19
pues podemos poner esta, y si nuestra situación es, 00:02:23
en función del valor de una variable hacer una cosa u otra, 00:02:27
pues elegíamos esta de aquí, ¿verdad? 00:02:31
Bueno, pues estas son las sentencias de decisión que ya conocemos, 00:02:37
sabemos usar y sabemos sobre todo identificar en qué situaciones me interesan a mí seleccionar. 00:02:44
Estos son sentencias, lo que pasa es que son sentencias complejas, 00:02:52
no como la de asignación, que es una sentencia que escribimos en una línea, 00:02:56
esta no la escribimos en una línea, esta sentencia es una sentencia compleja, 00:02:59
aunque es una única sentencia, la sentencia es esta, 00:03:03
es una sentencia compleja que a su vez puede tener aquí un montón de ellas dentro, 00:03:06
y aquí un montón de ellas dentro, y aquí un montón de ellas dentro a su vez, 00:03:11
que a su vez esas pueden ser otros if, eso ya uno va poniendo ahí los ladrillos 00:03:15
y las combinaciones que resuelvan lo que dan, ¿vale? 00:03:20
Bueno, pues solo nos falta un tipo de sentencia de la aprobación estructurada, 00:03:23
solo nos falta un tipo de sentencia, porque lo que decía el teorema de la aprobación estructurada 00:03:27
es que cualquier tarea que le queramos encomendar a un ordenador, 00:03:31
se puede hacer combinando en secuencia decisiones y bucles, 00:03:35
más la asignación de valores a datos, o sea, no lo dice ese teorema, 00:03:39
pero bueno, es evidente que habrá que asignar valores a datos. 00:03:43
Bueno, pues decisiones, sentencias, ya la tenemos, 00:03:46
pues solo nos falta entonces el otro tipo de sentencias, 00:03:49
que son las que se llaman las sentencias repetitivas, 00:03:52
o, en resumen, los bucles de toda la vida, ¿vale? 00:04:03
Los bucles de toda la vida. 00:04:08
Es el único tipo de sentencia en realidad que nos falta de la aprobación estructurada, 00:04:10
y con eso se puede hacer cualquier cosa, 00:04:14
claro, porque lo difícil no es conocer las sentencias y la sintaxis 00:04:17
y las diferentes variantes que hay de una versión de Java a otra, 00:04:20
eso no es lo difícil, eso sí que está en los papeles escritos, 00:04:23
lo difícil es entender un enunciado y a partir de ahí componer estas sentencias, 00:04:27
componerlas para que resuelvan lo que hemos pedido, ¿vale? 00:04:34
Lo difícil es eso, conocer la sintaxis de un lenguaje con sus detalles. 00:04:37
Bueno, pues vamos a terminar de conocer esos ladrillos 00:04:43
que podemos necesitar para construir ese programa. 00:04:47
Pues venga, vamos con los bucles entonces. 00:04:50
¿Vale? 00:05:04
Vale, pues las sentencias de decisión visualizamos ya en un diagrama de flujo, 00:05:17
ya lo visualizamos para entenderla, ¿qué es esto? 00:05:21
El programa viene por aquí y de repente tiene dos posibilidades, 00:05:24
o hacer una cosa o hacer otra. 00:05:30
Esas dos posibilidades irán en función de una condición, ¿vale? 00:05:32
Entonces si se cumple hago esto y si no hago esto. 00:05:39
Esta era nuestra sentencia de decisión visualizada en un diagrama de flujo, 00:05:42
¿vale? 00:05:49
Era esta, esta era nuestra sentencia de decisión, ¿vale? 00:05:50
Que la rama del no, no queremos que se haga nada, 00:05:58
entonces significa que esto se programa como ELSI. 00:06:01
Que la rama del no a su vez queremos abrir otra posibilidad, 00:06:03
pues eso sería el ELSI, el IF, el SEIF, ¿vale? 00:06:07
Pero al fin y al cabo todas las sentencias que hemos visto responden a esta estructura. 00:06:10
Otra cosa es que luego yo aquí abro la rama del no, la vuelvo a abrir, 00:06:15
entonces será un ELSI, pero responde a esto. 00:06:18
Pero en cualquier caso aquí no hay nada que se repita. 00:06:21
Si se cumple yo hago esto y si no se cumple hago esto. 00:06:24
Y ya está, pero lo hago una sola vez. 00:06:29
Y una vez que ya lo he hecho voy al punto de cierre, 00:06:32
ya se termina la sentencia IF-ELSI o IF-ELSI-IF, 00:06:37
si es que aquí tiene varios anidados, se termina y el programa continúa. 00:06:40
No hay nada que se repita, ¿vale? 00:06:44
Pero hay una situación que se puede dar a menudo 00:06:47
y es que necesitamos que un conjunto de sentencias se repitan varias veces. 00:06:49
A veces que es imprescindible que un conjunto de sentencias se repitan varias veces. 00:06:54
¿Vale? Es una situación, por ejemplo, cuando estamos haciendo un programa 00:06:59
que hemos hecho ahora varias veces, que leer un número entero 00:07:03
comprendido entre cero y mil, luego después con él hacer no sé cuántos. 00:07:07
Hasta ahora cuando hemos planteado un enunciado así, pues decíamos, 00:07:12
asumimos que el que va a usar la aplicación va a respetar las normas 00:07:17
y va a meter un número entre cero y mil, lo asumimos. 00:07:22
Pero imaginaos que ahora ya refinamos un poquito más el programa 00:07:26
y decimos, no, yo no voy a contar de partida con que el usuario 00:07:29
va a meter un número de cero a mil. 00:07:33
Entonces, yo le voy a pedir un número. 00:07:36
Si no está entre cero y mil, se lo voy a volver a pedir otra vez. 00:07:38
Si no está entre cero y mil, se lo voy a volver a pedir otra vez. 00:07:42
Entonces, si queremos que el programa sea un poquito más robusto 00:07:46
y que se esté ahí pidiendo números todo el rato hasta que se meta un número válido, 00:07:49
eso no lo podemos hacer con lo que conocemos, no lo podemos hacer, 00:07:55
porque eso implica automáticamente que la sentencia de pedir número 00:07:58
se haga un montón de veces. 00:08:02
¿Cuántas? No lo sabemos. 00:08:04
Depende de lo que tarde el tío en meter el número correcto. 00:08:06
Entonces, un ejemplo. 00:08:09
Es un ejemplo que estoy poniendo de situación que si uno quiere programarla 00:08:11
va a necesitar un bucle, porque necesita aquí un conjunto de sentencias 00:08:15
que en este caso pedir número y leerlas se repitan muchas veces. 00:08:19
Y como es ejemplo puede haber un montón de situaciones. 00:08:24
Pues ver si un número, ver los divisores que tiene. 00:08:27
Así muy en general. 00:08:33
Entonces, un número n. 00:08:35
¿Qué tendríamos que hacer? 00:08:37
Ir a n-1 y ver si lo divide. 00:08:39
Ir a n-2 y ver si lo divide. 00:08:41
Es decir, tendríamos que hacer un montón de veces, 00:08:43
ver si un número divide al n. 00:08:46
Un montón de veces. 00:08:48
¿Cuántas? No sé. 00:08:49
Depende del número n. 00:08:51
Si es 5, pues tengo que comprobar entre 4 y 2. 00:08:52
Si es 7, pues entre 6 y 2. 00:08:54
Depende. 00:08:56
Entonces, lo que estoy poniendo es ejemplos 00:08:57
de situaciones que cuando uno ya las analiza y las estudia 00:08:59
llega a la conclusión de que va a tener que hacer algo 00:09:02
un montón de veces. 00:09:05
A priori, no sabemos cuántas. 00:09:06
Depende de los datos de entrada. 00:09:08
En el ejemplo que he dicho antes, 00:09:11
cuando nosotros identificamos que nuestro programa va a tener que hacer 00:09:13
varias veces leer un número, 00:09:16
a priori no sabemos cuántas. 00:09:18
Si en una ejecución el usuario ha metido el número ya bien 00:09:20
la primera vez, se va a ejecutar solo uno. 00:09:23
Esa sentencia. 00:09:26
Pero en la siguiente ejecución, 00:09:27
si el usuario no mete el número correcto 00:09:29
entre 0 y 1.000 hasta la vez número 30, 00:09:31
pues eso se va a hacer 30 veces. 00:09:33
¿Vale? 00:09:35
Entonces, a priori no sabemos cuántas veces 00:09:36
se va a ejecutar un conjunto de sentencias 00:09:38
que nos hemos dado cuenta que se van a repetir. 00:09:40
No sabemos. 00:09:43
Depende de los datos de entrada. 00:09:44
Bueno, pues cuando identificamos que esa situación se da, 00:09:47
automáticamente identificamos que vamos a necesitar un bucle. 00:09:49
¿Vale? 00:09:52
Cuando identificamos que un conjunto de sentencias 00:09:53
se va a arrepentir unas cuantas veces, 00:09:55
que la pregunta inmediata sería 00:09:58
¿Cuántas? 00:10:00
Depende de los datos de entrada, 00:10:02
o sea, depende de la situación de la ejecución. 00:10:04
En alguna ejecución a lo mejor se repite más, 00:10:07
en otra a lo mejor se repite menos. 00:10:09
Depende. ¿Cuántas? 00:10:10
Pues esa situación se programa con un bucle, 00:10:11
con una sentencia repetitiva. 00:10:14
¿Vale? 00:10:16
Pues, en diagrama de flujo, 00:10:17
un bucle tiene este aspecto. 00:10:20
Aquí se evalúa una condición. 00:10:25
Que la condición se cumple, 00:10:28
hago todo lo que tenga que hacer, 00:10:31
una o mil sentencias, 00:10:34
las que yo crea que se quieren repetir. 00:10:35
¿Vale? 00:10:38
Y luego, bueno, 00:10:39
me he quedado sin, 00:10:41
voy a poner la rama del sí por abajo, 00:10:42
porque si no, 00:10:44
se me va a pegar con lo otro. 00:10:45
¿Que sí se cumple la condición? 00:10:48
Que sí se cumple. 00:10:50
Pues hago aquí todo lo que tenga que hacer, 00:10:51
conjunto de sentencias que se repiten. 00:10:53
Y ahora ya, 00:10:55
vuelvo arriba otra vez. 00:10:58
Y vuelvo a evaluar condición. 00:11:00
¿Se sigue cumpliendo? 00:11:02
Sí. 00:11:04
Pues hago lo que tenga que hacer. 00:11:05
Y el programa vuelve arriba otra vez, 00:11:07
vuelve a evaluar condición. 00:11:09
¿Se sigue cumpliendo? 00:11:11
Sí, hago lo que tenga que hacer. 00:11:12
Entonces, esto se parece a esto, 00:11:14
pero no es igual, 00:11:16
porque aquí en la rama del sí, 00:11:17
una vez que ejecuta lo que tenga que hacer, 00:11:18
se acabó, he terminado. 00:11:20
Y me voy. 00:11:21
Entonces, a veces confundís 00:11:22
esto con esto a la hora de programarlo 00:11:25
y no representan la misma situación. 00:11:28
Esta situación. 00:11:30
Evalúo condición. 00:11:31
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
20 de octubre de 2023 - 14:23
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
11′ 39″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
222.21 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid