Saltar navegación

20241017 ProgrEstruct-Bucles_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 20 de octubre de 2024 por Raquel G.

23 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, ya llegó. 00:00:00
Y eso ha sonado a risa irónica. 00:00:04
¿Ah, sí? ¿Él dice eso? 00:00:09
¿En serio? No tenía ni idea. 00:00:12
Pues nada, tenemos más compenetración de la que parece. 00:00:14
Vale, vale. Bueno, pues esta que sí es vuestra asignatura favorita, redes, no sé. 00:00:17
Ah, mejor. 00:00:22
Esa es la favorita. 00:00:25
Ya, lo que pasa es que os está exigiendo mucho trabajo. 00:00:27
Ese es el único problema que yo le veo. 00:00:30
Pero bueno, esta semana voy a llamar a vuestra profe 00:00:32
y le voy a decir que ya está, que se acabó. 00:00:35
Que venga ya de una vez. 00:00:37
Se acabó tu baja. 00:00:39
Se acabó tu baja. 00:00:40
Lo decido yo, que tengo la titulación médica. 00:00:41
Eso. 00:00:44
Así que nada, yo confío que ya pronto tengáis profe. 00:00:45
Venga, pues a ver. 00:00:48
Estábamos con la sentencia iterativa, ¿vale? 00:00:50
Como rápido repaso para los que el otro día 00:00:53
después de corregir el examen, 00:00:56
Pues estaban ahí un poquito ya 00:00:58
Desconectados o lo que fuera 00:01:01
¿Vale? 00:01:02
A ver, recordad que la sintaxis 00:01:04
De la sentencia iterativa 00:01:06
Es esto 00:01:08
Es esto, ¿verdad? 00:01:10
Donde aquí se pone una condición 00:01:13
Esta es 00:01:15
¿Vale? 00:01:17
Entonces, esta es una sentencia 00:01:19
Una sentencia 00:01:21
Igual que el if 00:01:22
Donde poníamos una condición 00:01:25
Esto también era una sentencia 00:01:27
Esto también era una única sentencia 00:01:31
Y si hay un else 00:01:33
Pues también 00:01:35
Todo esto es una única sentencia 00:01:37
¿Vale? Entonces son sentencias 00:01:39
Complejas porque tienen 00:01:40
Varias líneas de código pero son una sola 00:01:43
Son una sola 00:01:45
¿Vale? Entonces 00:01:46
¿Cómo funciona el while? El while 00:01:49
Permite repetir 00:01:51
Varias veces 00:01:52
Las sentencias que pongamos aquí dentro ¿Verdad? 00:01:54
entonces, la diferencia entre el while y el if, pues ya sabemos cuál es, 00:01:57
aparentemente son muy parecidas, ¿no? 00:02:06
Son muy parecidas porque en ambas se evalúa una condición, 00:02:10
aquí se evalúa una condición, aquí también, son muy parecidas, 00:02:17
si la condición es true, entro dentro, luego hasta ahí son iguales, 00:02:20
Y una vez que ya hemos terminado lo que hay dentro 00:02:28
Ahí es donde viene la diferencia entre el while y el if 00:02:31
Si es el while 00:02:34
Otra vez vuelvo arriba 00:02:35
Y vuelvo a evaluarla 00:02:37
Que sigue cumpliéndose 00:02:39
Hago esto de nuevo 00:02:41
Y otra vez 00:02:43
Vuelvo arriba, esa es la diferencia 00:02:45
Con el if, evaluábamos condición 00:02:47
Que se cumple, entro 00:02:49
Igual que el while, y se acabó 00:02:51
Y sigo por abajo, independientemente 00:02:53
De que condición siga cumpliéndose o no 00:02:55
Ya se acabó 00:02:57
Esto se va a hacer cero veces 00:02:58
O una máximo 00:03:01
En función de si condición es falsa o true 00:03:02
Estas cuantas se van a hacer 00:03:05
Ni idea 00:03:07
Se van a hacer entre cero 00:03:08
Si cuando yo llego por aquí 00:03:11
La condición ya es falsa de partida 00:03:12
En ese caso se harán cero 00:03:14
O un montón 00:03:15
¿De qué depende ese montón? 00:03:18
Pues que cuando vayamos a evaluar 00:03:21
Esta condición se haya convertido en falsa 00:03:23
En cuanto se convierta en falsa, ya no se hace más, ¿vale? 00:03:25
Entonces, para muchos problemas necesitamos hacer esto. 00:03:30
No hay forma de resolverlo si no podemos usar esa sentencia. 00:03:35
No podemos hacer cualquier cosa solamente con asignaciones y sentencias de decisión. 00:03:38
No podemos. 00:03:43
Hay veces que hay que repetir un código varias veces. 00:03:43
En ese caso vamos a tener que usar esta sentencia. 00:03:48
Vale. 00:03:51
Entonces, el funcionamiento está claro, ¿no? 00:03:52
Entonces, como ahí va siempre una condición 00:03:54
Esto lo podríamos poner 00:04:01
Esto lo podríamos poner, ¿no? 00:04:02
Pero esto, feo, malo 00:04:04
Esto no lo queremos, ¿vale? 00:04:07
Esto muy mal 00:04:09
Todo mal esto 00:04:10
Un bucle, porque esto ya sabemos 00:04:11
Lo que va a conducir 00:04:14
Esto va a conducir a un programa 00:04:16
Que nunca jamás va a terminar 00:04:18
Ahí hasta el infinito 00:04:23
¿Vale? Nunca jamás va a terminar 00:04:25
Eso no tiene que ocurrir 00:04:27
Porque yo ahora mismo no tengo más opción que irme al sistema operativo y matar este proceso. No tengo otra alternativa que matar este proceso. Afortunadamente el eclipse me da este botoncito y este botoncito es el kill. Me lo da, pues bueno. Pero nunca jamás debería acabar un programa porque mato el proceso. Siempre tiene que haber una salida. 00:04:28
Entonces, por ejemplo, esto ya sí que te da 00:04:53
Yo aquí pongo una condición 00:04:58
Por ejemplo, mientras n sea diferente de 0 00:05:03
Por ejemplo, esta condición ya es una condición que puede ser true o puede ser false 00:05:08
Lo que pasa es que, aun así, si yo hago esto, por ejemplo 00:05:13
vale 00:05:19
vale, entonces 00:05:40
ahora este bucle, esta condición 00:05:42
en principio no es 00:05:48
true ni false, depende del valor 00:05:50
de n, pero claro 00:05:52
aquí ahora mismo este programa también 00:05:54
sigue siendo 00:05:56
muy feo, yo lo ejecuto 00:05:57
y si a n 00:06:00
le doy un 7, pues 00:06:01
estoy en las mismas 00:06:04
¿no? 00:06:05
no, en las mismas dosis, las un 7 no entran 00:06:07
a no, en el distinto 00:06:09
claro, si 00:06:12
vale 00:06:14
ahí estoy, le doy 7 00:06:16
y estoy en las mismas 00:06:20
claro, obviamente, ¿verdad? 00:06:22
bueno, mato el proceso porque es que no tengo 00:06:24
otra manera de salir 00:06:26
claro, ¿cuál es el problema? 00:06:27
que aquí dentro del bucle 00:06:30
no hay nada que permita 00:06:32
que esta condición pase 00:06:34
de ser true a false, no hay nada 00:06:36
entonces si tenemos un bucle 00:06:38
que lo que hay dentro es absolutamente 00:06:40
independiente de la condición 00:06:42
pues aquí hay algo raro, en este código alguna cosa rara va a haber diseñada 00:06:44
porque si de partida es true, va a ser true siempre 00:06:48
con lo cual nunca va a acabar ese bucle, nunca va a acabar 00:06:51
entonces normalmente los programas, los códigos que hacemos para resolver un problema 00:06:54
son tales que lo que ocurre aquí dentro 00:06:59
va alterando las variables que forman esta condición 00:07:03
de tal forma que alguna vez eso sea falso 00:07:08
Por ejemplo, aquí podríamos estar leyendo este número 00:07:10
Todo el rato 00:07:14
A ver, estoy poniendo ejemplos solamente 00:07:16
De situaciones en las cuales 00:07:24
El bucle terminaría, no terminaría 00:07:26
Vale, si yo esto no lo pongo 00:07:28
No es que 00:07:30
Representen un problema real que estoy resolviendo 00:07:32
Estoy solamente viendo códigos 00:07:34
En los cuales 00:07:36
Para ver cómo funciona la sentencia while 00:07:36
no estamos resolviendo ningún 00:07:39
vale, entonces aquí está claro, ¿no? que si yo de partida 00:07:41
meto un valor diferente de 0 00:07:44
voy a entrar 00:07:46
y este bucle no va a acabar en la vida 00:07:47
a veces uno hace su programa 00:07:49
que sí que está resolviendo un problema, lo que sea 00:07:52
y esas son cosas 00:07:54
que si las identificamos 00:07:56
nos podemos dar cuenta de que 00:07:58
uy, algo raro he hecho yo 00:08:00
algo raro he hecho yo porque es que este bucle es infinito 00:08:01
¿vale? entonces 00:08:04
en este caso, por ejemplo 00:08:06
en este caso 00:08:08
ahora la variable n 00:08:10
en cada iteración 00:08:12
¿vale? cada iteración es 00:08:13
cada una de las pasadas del bucle 00:08:16
en cada iteración el valor de n cambia 00:08:18
el valor de n cambia 00:08:20
con lo cual 00:08:22
n puede ser 0 00:08:24
en algún momento 00:08:26
entonces ahora ya sí, ahora ya este programa 00:08:27
tiene un bucle que termina 00:08:30
yo le meto primero 8 00:08:31
vale, y vuelve a pedir el número 00:08:34
7, me vuelve a pedir el número 00:08:36
3, me vuelve a pedir el número 00:08:37
0, ya está, terminó 00:08:39
¿Vale? Terminó 00:08:41
Entonces este bucle 00:08:43
Ya sí que termina 00:08:45
Termina por código 00:08:48
Que es la idea, tener una salida por código 00:08:51
¿Vale? 00:08:53
¿Alguien no se ha despertado todavía? 00:08:55
Vale 00:08:57
O esto mismo también podría ser 00:08:58
Por ejemplo 00:09:05
Por ejemplo, este programa 00:09:05
¿Qué haría? 00:09:10
un momento 00:09:13
vale, cuando digo que haría 00:09:15
no digo que me leáis las sílabas 00:09:22
pues repite, mientras n sea 00:09:24
diferente de 0, muestra un mensaje 00:09:26
y luego a n le resta 0, le resta 1 00:09:28
no quiero que me leáis 00:09:30
me interpretéis las líneas, lo que quiero es que me digáis 00:09:32
en conjunto cuál es el resultado final 00:09:34
de este programa, este programa en conjunto 00:09:36
¿qué hace? 00:09:40
no, no, no, pero no me 00:09:47
traduzcas Java 00:09:48
no me hagas un traductor de idioma 00:09:51
no me traduzcas Java, dime 00:09:53
este programa te hace esto 00:09:54
vale 00:09:56
eso es más parecido a lo que yo esperaba 00:10:00
te saluda, pero 00:10:03
y ya está, algo más 00:10:04
¿cuántas veces te saluda? 00:10:06
vale 00:10:10
eso sí, este programa te saluda tantas 00:10:10
veces como tú le hayas dicho al principio 00:10:13
es lo que hace, ¿no? 00:10:14
le metes un numerito y 00:10:16
te saluda 00:10:18
y lo decrementa 00:10:21
Con lo cual, ya te ha saludado una vez y ha contado esa vez. 00:10:22
Como no ha llegado a cero, te vuelve a saludar, ¿vale? 00:10:27
¿Vale? Pues este bucle ya sé que terminaría. 00:10:32
Entonces le metemos 7, pues hala, ahí tenemos las 7 veces, ¿vale? 00:10:36
Hay una manera fea también de salir de los bucles. 00:10:45
Por ejemplo, que es la famosa sentencia break que no nos gusta nada tampoco. 00:10:49
El bucle que yo he hecho de que te saluda siete veces o ocho o las n que metas, sería igual que hacer esto. 00:10:55
Pero por Dios, esto no nos gusta nada. 00:11:06
A ver, la sentencia break es una sentencia que en sí misma tiene un significado. 00:11:11
Ya no solo, hasta ahora la sentencia break la hemos usado solo para esto. 00:11:17
Para el switch case, la hemos usado solamente para esto. 00:11:21
Case 1, bla, bla, bla 00:11:25
Y luego poníamos aquí el break 00:11:28
Y así en cada caso 00:11:30
Y lo que decíamos era 00:11:32
El break lo que hace es 00:11:34
En ese momento 00:11:36
Para la evaluación de cases 00:11:37
Este es de aquí 00:11:40
No, no, no, no se mete en el siguiente caso 00:11:41
¿Vale? 00:11:52
El break lo que hace es una sentencia 00:11:53
Ahora ya podemos ver su significado general 00:11:56
Su significado general es 00:11:58
sale del bloque en el que 00:11:59
está metida, sale del bloque 00:12:02
entonces en el switch 00:12:04
hacía justo lo que queríamos 00:12:05
¿qué es uno? pues ejecuta esto 00:12:07
y ya sale 00:12:10
porque si no poníamos un break 00:12:11
se ponía a ejecutar todo lo que había 00:12:13
a continuación, independientemente de que 00:12:15
la condición, el valor 00:12:17
fuera cierto o no 00:12:20
entonces el switch era así 00:12:21
miraba el valor 00:12:23
de la variable que yo pusiera aquí 00:12:25
poníamos aquí una variable 00:12:27
que era igual a 1 00:12:29
hacía lo que hubiera dentro 00:12:31
y si no había un break, ya seguía 00:12:33
seguía con todas las demás 00:12:35
aunque este número no coincidiera 00:12:37
ya seguía con todas 00:12:39
pero no queríamos eso, queríamos 00:12:40
que si esta variable era igual a este valor 00:12:43
o igual a este, una vez que 00:12:45
ha hecho lo que estaba dentro, ya está 00:12:47
saliera y dejara de evaluar cosas 00:12:49
saliera, pues para eso 00:12:51
poníamos el break, porque el break es 00:12:53
una sentencia que se puede usar 00:12:55
en más contextos que en el switch case 00:12:57
El break significa 00:12:59
Sal del bloque en el que estás 00:13:00
Abandona automáticamente el bloque 00:13:04
En el que estás 00:13:05
Entonces también la podemos usar en un while 00:13:06
Entonces 00:13:09
Este bucle es un while true 00:13:11
Pero si termina 00:13:13
Porque si n ha llegado a 0 00:13:15
Break, y break que significa 00:13:18
Sal de este bloque 00:13:19
Abandona, rompe 00:13:21
Si hay algo por aquí debajo, si hay más sentencias 00:13:22
O lo que sea 00:13:25
Ni llega a ellas 00:13:26
¿Y si el if lo pones como un bloque? 00:13:28
Ah, esto no llega 00:13:36
Bueno, da igual 00:13:37
Ah, vale 00:13:39
Ya sé lo que dices 00:13:41
Si sale de aquí y se va a este 00:13:43
No, sale del 00:13:45
Yo creo que sale del bucle enterito 00:13:47
Déjame comprobarlo 00:13:50
Porque normalmente se hacen para romper bucles 00:13:51
Espérate que quite esto 00:13:56
Vale, a ver 00:13:57
En este caso está claro, ¿no? 00:14:01
En este caso está claro 00:14:03
Para lo que sirve el break 00:14:04
Pero, repito, no se usa. 00:14:06
Es una sentencia que está puesta ahí. 00:14:08
Para que uno tenga el recurso, en un momento dado, 00:14:11
tiene que romper un bucle por las buenas, 00:14:13
pero jamás se programa así. 00:14:16
Tú, si quieres, ¿cómo indicas que el bucle finaliza? 00:14:18
Con la condición. 00:14:21
Porque si lo haces así, el que está mirando este código, 00:14:23
le complicas muchísimo la vida. 00:14:25
Dice un bucle infinito. 00:14:27
Ostras, me voy a tener que meter dentro 00:14:29
para ver qué hace que esto acabe. 00:14:30
y a lo mejor aquí dentro hay una llamada a un método 00:14:33
y muchas cosas y le complicas mucho la vida 00:14:36
entonces los códigos tienen que ser legibles 00:14:38
y cuando uno eche un vistazo entender que ocurre 00:14:40
y yo con un while true aquí no entiendo nada 00:14:42
pero si yo pongo un while 00:14:45
n diferente de 0 pues ya automáticamente 00:14:46
veo, ah, se repite n veces 00:14:49
vale, entonces 00:14:50
el break no es 00:14:52
una sentencia aconsejable de usar 00:14:54
más que nada porque no hace ninguna falta 00:14:56
no es necesaria en absoluto 00:14:58
no hace falta, siempre puedes salir de un bucle 00:15:00
Poniendo la condición correcta 00:15:02
Y es como debes hacerlo 00:15:04
Pero bueno, está ahí por herencia del pasado 00:15:05
Por si en algún momento dado tiene que usarla 00:15:08
Y en el switch case, ahí sí que es imprescindible 00:15:10
Ahí sí que es imprescindible 00:15:12
Es el único caso en el que hay que usarla 00:15:13
¿Vale? 00:15:17
Venga, pues entonces, aquí está clarísimo 00:15:18
Que saldríamos del bucle en cuanto llegamos a 0 00:15:20
Con lo cual esto nos saludaría 00:15:23
7 veces 00:15:24
¿Vale? 00:15:26
Nos hace las 7 00:15:29
¿Vale? 00:15:30
Y ahora, esto, que bueno, yo no lo he visto nunca, pero vamos a ver por curiosidad cómo funcionaría. 00:15:32
Si te saldría de este, con lo cual estaríamos en las mismas y seguiría siendo un bucle infinito, 00:15:42
o break significa sal del bucle más en el que estás, sal del bucle más interno en el que estás, que sería este. 00:15:48
Yo tengo una teoría, pero vamos a ponerle 4 para que sale del bucle en el que estás, efectivamente. 00:15:57
No, no, no, está bien 00:16:07
Porque hay pequeños detalles 00:16:10
Que son curiosidades 00:16:12
Que tienen sentido 00:16:14
Entonces el break es la sentencia de 00:16:15
Romper bucles 00:16:18
Pero no las usemos 00:16:19
No es necesario 00:16:21
Y el código va a quedar muy feo 00:16:23
Entonces nunca haríamos un código así 00:16:25
Nunca haríamos un código así 00:16:27
Este código lo cambiaríamos 00:16:29
Y lo pondríamos así 00:16:31
¿Vale? 00:16:33
Así ya sí que estaría 00:16:34
Un código mucho más bonito 00:16:36
¿Vale? 00:16:37
Entonces ya 00:16:42
De nuevo con un while 00:16:43
Se abre un bloque otra vez 00:16:45
Como con un if 00:16:47
No es obligatoria 00:16:48
Las llaves 00:16:51
Si solo se hace una sentencia 00:16:52
¿Vale? Por ejemplo 00:16:55
Si yo 00:16:57
Este 00:16:58
Este bucle 00:17:00
Fuera así 00:17:02
Sería infinito en este caso 00:17:04
Claro, vamos, no 00:17:06
Me gustaría si este bucle 00:17:07
Bueno, a ver, puedo hacer esto 00:17:09
Hola, concatenarlo con n 00:17:11
Y a n decrementarlo 00:17:14
Este ya no sería infinito 00:17:16
Hola, muestro el valor de n 00:17:17
Y lo decremento 00:17:20
Pues este bucle 00:17:22
Como solo tiene una sentencia dentro 00:17:25
Solo tiene una 00:17:27
La llave es opcional 00:17:28
¿Vale? La llave es opcional 00:17:29
entonces las sentencias que vengan a continuación 00:17:32
ya la máquina virtual sabe que están 00:17:34
fuera del while, no hay duda 00:17:36
aunque las tabulara, me da lo mismo 00:17:37
porque las tabulaciones son solo para dejar el código 00:17:39
claro, a la máquina virtual las tabulaciones 00:17:42
los espacios le dan igual 00:17:44
entonces si no hay llaves, por muchas sentencias 00:17:45
que haya aquí, el bucle 00:17:48
while solo tiene dentro esta 00:17:50
lo que pasa es que 00:17:52
para evitar efectivamente confusiones 00:17:54
y para no meter la pata 00:17:56
siempre es buena idea abrir un 00:17:57
bloque de llaves 00:17:59
siempre es buena idea abrirlo y así queda clarísimo 00:18:01
que hay dentro 00:18:04
pero recordad que desde el momento 00:18:04
en que abrís un bloque 00:18:08
como hacemos con un if 00:18:09
automáticamente se abre aquí 00:18:11
como si fuera un ámbito nuevo de variables 00:18:14
recordad que entonces 00:18:16
cualquier cosa que declaréis aquí 00:18:18
cualquier cosa que declaréis aquí 00:18:20
solo se puede usar 00:18:22
aquí dentro y solo es visible 00:18:24
aquí dentro para hacer lo que uno quiera 00:18:26
solo es visible ahí dentro 00:18:27
En cuanto el bloque termina 00:18:29
En cuanto el bloque termina 00:18:31
Esa variable m se ha ido a la basura 00:18:33
Y ha desaparecido 00:18:35
Y con ella su valor, fuera, a la basura 00:18:36
Entonces yo aquí si quisiera 00:18:39
Mostrar el valor que tiene m 00:18:41
Me dirían, pero ¿quién es m? 00:18:42
No tengo ni idea de quién es m 00:18:45
Porque m la declaraste dentro de este bloque 00:18:46
Luego se usó aquí dentro 00:18:49
Para todo lo que hiciera falta, se usó 00:18:51
Y cuando el bloque terminó 00:18:52
Y hemos venido a este punto, m a la basura 00:18:54
bueno, con un retune 00:18:57
sales del main, no 00:19:02
la única, es que tienes la opción 00:19:03
natural, que es declararla fuera 00:19:06
¿vale? 00:19:08
la declaras fuera y solucionado 00:19:10
¿vale? entonces, tú en 00:19:12
si vas a usar una variable en un sitio 00:19:16
tienes que asegurarte que esa variable está 00:19:18
declarada en el bloque al que pertenezca 00:19:20
esa sentencia, entonces, esta sentencia 00:19:22
¿qué bloque pertenece? 00:19:24
a este grandote de main, es en el que está 00:19:25
a este grandote, pertenece a esa 00:19:28
Pues entonces tiene que estar declarada ahí 00:19:30
¿Vale? Si solamente la usáramos 00:19:32
Aquí dentro 00:19:34
Y esta sentencia 00:19:35
Esta M solamente sirviera 00:19:38
Para ser usada aquí dentro 00:19:40
Solo, le doy un valor y la muestro aquí 00:19:41
Solo, pues entonces la declaro ahí 00:19:44
Porque como solo la voy a usar 00:19:46
Aquí dentro, la declaro ahí 00:19:48
¿Y qué ventaja tiene declararla ahí 00:19:49
En vez de fuera? 00:19:52
Que el resto del código ya no 00:19:54
Ya no molesta 00:19:56
Porque ya no está esa variable M ahí 00:19:57
ya ha desaparecido 00:20:00
entonces esta variable m solo va a existir 00:20:01
durante el tiempo que tarda en ejecutarse 00:20:04
el tiempo que tarda en ejecutarse 00:20:06
esa variable existe 00:20:08
eso ha terminado de ejecutarse 00:20:09
la variable se va a la basura 00:20:11
memoria que me ahorro 00:20:12
y confusiones 00:20:14
porque si aquí sigue habiendo una variable m 00:20:16
yo estoy en 30.000 líneas más abajo 00:20:18
intento declarar otra m 00:20:21
me dice no puedo declarar m 00:20:22
pero si yo no tengo ninguna m 00:20:23
si la tienes porque la has declarado más arriba 00:20:25
entonces es buena práctica 00:20:27
Declarar las variables 00:20:29
En el bloque más interno en el que se usan 00:20:31
Es buena práctica 00:20:34
Y así fuera de ese bloque no existen 00:20:35
No molestan 00:20:38
Y puede ser la misma 00:20:38
A ver, puedes declarar 00:20:40
Te refieres a esto 00:20:45
Te pones interno 00:20:48
Pero si la has clasificado fuera, usa esa 00:20:51
Porque luego te borrará 00:20:53
No, no, no 00:20:54
Entonces lo que lo estropeas es aquí 00:20:56
La estropeas ahí 00:20:58
te dice, oye, que la variable está duplicada 00:21:00
entonces 00:21:03
el problema es que aquí, si lo dejas así 00:21:04
aquí dentro, abre una ambigüedad 00:21:07
que es cuando yo digo M 00:21:09
a cuál me estoy refiriendo 00:21:10
a la que yo he declarado aquí dentro 00:21:12
y que sustituye a la otra 00:21:15
o me estoy refiriendo a esta 00:21:16
entonces para evitar esa ambigüedad 00:21:18
directamente no te deja 00:21:20
¿vale? pero aquí sí 00:21:22
¿vale? porque Java, no olvidemos 00:21:29
aunque 00:21:35
Java es un lenguaje extraño 00:21:35
porque no es ni compilado ni interpretado 00:21:38
es una mezcla de las dos cosas 00:21:41
entonces los lenguajes interpretados 00:21:42
¿qué significan? 00:21:44
que se van interpretando línea por línea 00:21:46
con lo cual podemos entender 00:21:47
que cada línea es independiente de las demás 00:21:50
y que van de abajo 00:21:52
perdón, de arriba a abajo 00:21:54
entonces primero se hace esta 00:21:55
luego se hace esta otra 00:21:57
entonces cuando se hace esta 00:21:59
lo que hay abajo todavía no se ha mirado 00:22:01
con lo cual no molesta 00:22:04
esos son los programas interpretados 00:22:05
En los compilados se mira todo en su conjunto, entonces lo que se compila todo, entonces lo que hay arriba sí se puede ver afectado por lo que hay abajo, de ahí vienen los errores de compilación, ¿verdad? Los errores de compilación es que, oye, aquí has hecho una cosa y no me casa con lo de abajo, entonces no te dejo que compiles ni ejecutes. 00:22:08
entonces los compilados se mira en bloque 00:22:28
a ver si todo casa y todo está bien 00:22:31
y luego ya una vez compilados se ejecuta 00:22:32
y los interpretados puros 00:22:35
se va a línea por 00:22:37
ni se compila ni nada, se va 00:22:39
línea por línea, cuando yo hago una línea 00:22:41
lo que hay abajo ni lo he mirado todavía 00:22:43
me da exactamente igual, yo voy línea por línea 00:22:44
lo que puede ocurrir cuando ejecuto una línea es que esa línea 00:22:46
esté mal, esté mal escrita lo que sea 00:22:49
pero cuando yo ejecuto una línea 00:22:51
lo de abajo ni se mira 00:22:53
esos serían los interpretados puros, entonces Java es una mezcla 00:22:54
de los dos, recordad que primero se hace 00:22:57
una especie de pre-compilación 00:22:59
y en ese sentido algunas cosas 00:23:01
que hay abajo sí que pueden afectar a lo que hay 00:23:03
arriba y te dice, oye, esto no me está 00:23:05
casando, arréglalo 00:23:07
pero es una pre-compilación 00:23:08
solo, luego se hace un código 00:23:11
intermedio que ya la máquina virtual de Java 00:23:13
va interpretando 00:23:15
vale, pues ese medio 00:23:16
carácter de interpretado que 00:23:19
tiene, ese medio carácter a veces 00:23:21
da la cara 00:23:23
que es muy malo, lo de ser 00:23:23
interpretado es malo 00:23:27
¿cuál es la ventaja que tiene? que es independiente 00:23:28
de la plataforma, porque yo tengo el 00:23:31
intérprete que me hace la traducción a cada 00:23:32
equipo, ¿vale? 00:23:34
entonces si tú tienes un 00:23:37
traductor en cada país 00:23:38
tú puedes hablar un único idioma 00:23:41
y al país que vayas 00:23:42
ese traductor, ese intérprete 00:23:44
te lo va a traducir al chino, al 00:23:46
japonés, al que sea, tú puedes 00:23:48
hablar el único idioma, y ese es el 00:23:50
lenguaje interpretado 00:23:52
¿vale? pues entonces 00:23:53
esa es la ventaja de los interpretados 00:23:55
que las pautas 00:23:58
de programación son únicas y universales 00:24:00
y ya cada equipo se preocupa 00:24:02
de interpretar, por eso Java 00:24:04
intenta ser una mezcla de ambos 00:24:06
esa es la única ventaja que tiene 00:24:08
pero el problema es que no hay 00:24:09
esa 00:24:12
especie de verificación de si todo 00:24:12
casa entre sí, que no la hay 00:24:16
eso es malo también, entonces por eso 00:24:17
Java es una mezcla de los dos, bueno pues 00:24:20
lo que estaba diciendo es que su 00:24:22
carácter, su pseudo carácter 00:24:23
su pequeña parte que tiene interpretado 00:24:26
a veces sale 00:24:27
y aflora, y este es uno de los ejemplos en los que 00:24:29
aflora, fijaos la diferencia 00:24:31
entre yo haber declarado M 00:24:33
aquí arriba 00:24:35
que esta 00:24:36
se ha fastidiado 00:24:39
y haber declarado M 00:24:40
aquí abajo 00:24:43
que esta no se fastidia 00:24:44
¿vale? 00:24:47
entonces, yo aquí he declarado mi variable 00:24:49
mi variable M 00:24:51
Hace lo que tenga que hacer 00:24:53
Asigna su valor, se muestra y desaparece 00:24:55
Y se va a la basura 00:24:57
Y ahora después aquí al rato 00:24:58
Vuelvo a declarar otra M 00:25:00
Y esta M 00:25:02
Es válida 00:25:04
Para cualquier momento 00:25:08
A partir de aquí, y es una M nueva 00:25:11
Es una M nueva que yo puedo usar tranquilamente 00:25:13
A partir de aquí 00:25:15
Pero antes no 00:25:16
Recordad que no podemos usar una variable 00:25:19
Antes de que sea declarada 00:25:21
A ver, es que los lenguajes puramente compilados 00:25:22
Normalmente tienen unas reglas 00:25:28
C por ejemplo 00:25:30
Te obligaba a declararlas todas al principio 00:25:31
Para facilitar la tarea de los compiladores 00:25:34
Y todo eso 00:25:38
Vale, aquí por ejemplo 00:25:39
La variable m está declarada 00:25:42
Y está declarada en el bloque gordote 00:25:43
Que es en este 00:25:45
Pero eso no significa que la pueda yo usar aquí 00:25:46
No puedo usarla aquí 00:25:48
Porque la estoy usando antes de estar declarada 00:25:52
¿Vale? 00:25:55
Bueno, pues todo esto 00:26:01
En respuesta, aunque no lo parezca, a tu pregunta 00:26:02
¿Puedo declarar otra M fuera? 00:26:04
Puedes, pero si está después 00:26:06
Del bloque, si está después del bloque 00:26:08
Y será una M nueva 00:26:10
Que no tiene nada que ver con esta porque está ya desaparecido 00:26:11
Y se ha ido a la basura 00:26:14
¿Vale? Pero antes no porque entonces 00:26:15
Aquí habría una ambigüedad 00:26:18
Y la ambigüedad sería esta M 00:26:19
¿Cuál es? ¿Esta cajita o la cajita de arriba? 00:26:22
habría una ambigüedad, vale 00:26:25
vale 00:26:26
ah, vale 00:26:29
lo que estábamos diciendo era 00:26:33
que while las llaves son 00:26:34
opcionales, pero recomendables 00:26:37
para que quede claro el código 00:26:39
y si 00:26:40
abrís llaves 00:26:43
recordad que en ese momento lo que abrís es 00:26:44
un espacio, un ámbito nuevo 00:26:47
un ámbito más pequeñito, lo que se declare 00:26:49
ahí, fuera desaparecido 00:26:51
venía a cuento de todo esto, ¿no? 00:26:52
vale, ¿y qué más cosas de... 00:26:55
Entonces, esta es la única sintaxis que en realidad que hace falta para hacer bucles. 00:26:56
No hace falta más. 00:27:02
Lo que pasa es que igual que ocurría con el if, 00:27:03
hay otras formas de escribir bucles, ¿vale? 00:27:05
Que para algunos ejercicios pegan más y los dejan más bonitos. 00:27:08
Pero solamente porque los dejan más bonitos. 00:27:12
Es como el switch case que deja más bonito un programa 00:27:14
si tú quieres ver, hacer algo en función de si n es un valor u otro. 00:27:17
Se queda más bonito con switch case que con if, else if, else if. 00:27:20
pero se puede hacer todo con el if, el se 00:27:24
pues aquí igual, se puede hacer todo con el while 00:27:27
pero hay veces que queda más bonito 00:27:29
con otras dos variantes más 00:27:31
tres, que las incorporaremos 00:27:33
en breve, vale 00:27:35
y el otro día también, ya hablando 00:27:36
de bucles ya, dijimos que ahora ya 00:27:39
hay cosas que podemos hacer ya con los bucles 00:27:41
que antes no podíamos hacer 00:27:43
como por ejemplo contar, vale 00:27:44
entonces ahora ya hay patrones de 00:27:47
algoritmia, patrones de algoritmia 00:27:49
que ya tenemos que ir incorporando 00:27:51
porque ya con los bucles se complica 00:27:53
con las decisiones, los patrones de algoritmo 00:27:54
eran muy claros, yo me he dado cuenta 00:27:56
en un programa que tiene 00:27:58
dos posibilidades, un if 00:28:00
ya está, un if, no tengo que pensar más 00:28:02
de que depende una a la otra 00:28:04
de esto, pues eso para la condición 00:28:06
me he dado cuenta en un programa que tiene hasta 00:28:08
tres posibilidades, pues un if con un 00:28:10
elseanidado o un if 00:28:12
elseif, o si depende del valor de una 00:28:14
variable, un switch case, y no teníamos 00:28:16
en realidad que 00:28:18
pensar más, lo teníamos 00:28:19
Relativamente claro 00:28:22
Luego ya lo complicado podía ser 00:28:23
Traducir yo las condiciones 00:28:26
A Java, traducirla a una condición 00:28:28
Que está en lenguaje natural, traducirla a Java 00:28:30
Eso podía ser más complicado, pero no teníamos más que pensar 00:28:32
Vale, ahora con el bucle 00:28:34
Hay como más patrones mentales en la cabeza 00:28:36
Se abren más cosas 00:28:38
Más posibilidades 00:28:40
Bueno, pues una de las cosas que se abren 00:28:41
En un programa yo puedo necesitar contar 00:28:43
Contar cosas 00:28:46
Como subparte, como pequeña parte 00:28:47
De algo más grande 00:28:50
como pequeña parte de algo más grande 00:28:51
¿vale? pues eso ya es 00:28:52
un patrón que ya incorporamos el otro 00:28:55
día en esos ejemplos, por ejemplo 00:28:57
aquí podríamos 00:28:59
incorporar, este 00:29:00
n ya es un contador, ¿no? 00:29:03
ya es un contador, ya está funcionando como un contador 00:29:05
lo que pasa es que 00:29:07
me está descontando 00:29:08
en lugar de ir hacia arriba, ¿vale? 00:29:10
me está 00:29:14
descontando cuantos 00:29:15
olas 00:29:17
Cuento, pero en general 00:29:18
Cuando uno quiere contar lo que sea 00:29:20
Por ejemplo 00:29:22
Lo que hicimos el otro día, pues 00:29:23
Contar pares 00:29:25
Entre uno 00:29:30
Bueno, contar pares 00:29:33
Ya sabemos que es una tontería 00:29:35
Entre uno y un 00:29:37
Porque serán la mitad de lo que nos han dado 00:29:39
Pero bueno, entre uno y un número solicitado por teclado 00:29:41
Vale, vamos a suponer 00:29:44
Que nos piden este ejercicio 00:29:50
¿Cuántos números pares habrá entre uno 00:29:51
Y un número que me dan por teclado 00:29:54
Vale, habrá la mitad, es una tontería 00:29:56
Vale, pero vamos a contarlos 00:29:58
¿Eh? 00:29:59
Sí, pero bueno, podrías hacer la diferencia 00:30:04
Y hacer la mitad igualmente 00:30:06
Pero bueno, venga, vamos a poner 00:30:07
Contar múltiplos de 3 00:30:10
Que así parece que 00:30:12
Bueno, da igual, dejamos así, da lo mismo 00:30:14
Vale 00:30:16
Vale 00:30:16
Pues venga, pedimos el numerito por teclado 00:30:18
ala, el número ya está pedido 00:30:21
y ahora 00:30:29
la parte de datos de entrada 00:30:31
la tenemos, hay que pedir un único número 00:30:33
ya lo tengo pedido, y ahora pensamos 00:30:35
¿qué tengo que hacer aquí? 00:30:37
tengo que contar cosas, tengo que contarlas 00:30:39
un while voy a necesitar 00:30:42
sí o sí 00:30:44
voy a necesitar un while 00:30:44
para ir 00:30:46
incrementando esa cuenta 00:30:49
que empieza desde cero 00:30:51
tengo que contar cosas, entonces si tengo que 00:30:52
contar cuántas veces ocurre 00:30:57
algo, cuando yo identifico que tengo que 00:30:59
contar cuántas veces ocurre algo 00:31:01
esto va a estar en mi programa 00:31:03
va a estar esto sí o sí, tengo que contar 00:31:05
cuántas veces ocurre algo 00:31:07
vale, pues entonces 00:31:08
ahora ya nos vamos a la siguiente 00:31:11
parte que es, bueno, venga 00:31:13
pues que tengo que contar 00:31:15
como lo plasmo aquí 00:31:17
pues tienes que contar 00:31:18
los números pares 00:31:20
que hay entre uno y el que te han dado, con lo cual 00:31:23
eso se traduce a decir, tengo que 00:31:25
contar cada número que sea par 00:31:27
es decir, yo voy contando 00:31:29
tengo que contar números 00:31:31
es como si contara alumnos, ¿cuántos alumnos son rubios? 00:31:32
voy pasando alumno por alumno 00:31:35
este, este, este, me paro en el que es rubio 00:31:37
este, este, este, me paro en el que es rubio 00:31:38
pues aquí no contamos alumnos 00:31:40
que cumplen una condición, sino que contamos 00:31:43
números que cumplen una condición 00:31:45
luego hago un barrido sobre 00:31:46
números, ¿vale? 00:31:49
entonces lo primero que tengo que identificar es 00:31:50
mi barrido para ver quién cumple la condición 00:31:52
sobre qué concepto es 00:31:55
¿Sobre qué cosa es? 00:31:56
En este caso, sobre números. 00:31:58
Yo tengo que ir sobre el 1, luego sobre el 2, luego sobre el 3, luego sobre el 4. 00:31:59
Vale, pues entonces, alguna variable tendré que tener para que guarde esos elementos por los que yo voy barriendo. 00:32:04
Si yo tuviera que contar cuántos alumnos tienen gafas, pues tendría que tener una variable para el alumno. 00:32:13
Y ahora ya, en esa variable irían entrando los alumnos. 00:32:22
venga tú, entra, entra, entra, a ti te cuento 00:32:25
a ti no, a ti te cuento, a ti no 00:32:27
en este caso no son sobre alumnos 00:32:28
sobre lo que cuento, sino sobre números 00:32:31
pues tendré que tener una variable 00:32:33
en la que voy metiendo los números 00:32:35
por los que voy pasando 00:32:36
vale, pues entonces 00:32:38
aquí me voy a declarar una variable 00:32:41
como son números enteros 00:32:43
pues por ejemplo, num 00:32:47
y ahora, esta variable 00:32:49
tiene que ir recibiendo 00:32:52
tiene que ir recibiendo 00:32:54
Todos los elementos sobre los que yo estoy haciendo el barrido 00:32:55
¿Vale? 00:32:58
Como si tuviera mi variable 00:33:00
Para contar alumnos, pues primero recibe a Andrea 00:33:01
Luego así, luego no sé qué 00:33:04
¿Vale? Para irlos contando 00:33:05
Pues este tiene que ir recibiendo esta variable 00:33:07
Todos los elementos sobre los que voy barriendo 00:33:09
¿Vale? Y ahora pienso 00:33:10
Pues, ¿por cuáles tengo que 00:33:13
Barrer? ¿Cuáles son? Pues entre uno 00:33:15
Y el que te han dado 00:33:17
¿Vale? Pues venga, voy a empezar con el primero 00:33:18
Ups 00:33:21
Pues entonces la inicializo a uno 00:33:22
vale 00:33:24
y ahora yo ya 00:33:26
lo siguiente que me queda es 00:33:28
este cumple la condición 00:33:30
de ser par 00:33:32
pues lo cuento 00:33:34
y me voy al siguiente 00:33:38
para seguir haciendo el barrido 00:33:41
vale, me voy al siguiente 00:33:42
vale 00:33:44
entonces ya he avanzado muchísimo 00:33:46
primero he identificado 00:33:50
que tengo que contar 00:33:51
con lo cual tengo ahí mi estructura de contador 00:33:52
empieza valiendo 0 00:33:55
y se irá incrementando, ahora 00:33:57
tengo que pensar, ¿qué tipo 00:33:59
de elemento es sobre el que yo estoy 00:34:01
navegando para contar? ¿qué tipo de 00:34:03
elemento? son números 00:34:05
pues una variable tendrá que 00:34:06
tener esos elementos 00:34:09
secuencialmente, primero uno, luego otro 00:34:11
luego otro que voy contando, pues es esta 00:34:13
vale, ahora 00:34:15
¿de dónde se nutre esa variable 00:34:17
para ir recibiendo todo con lo que yo voy 00:34:21
contando? pues entre uno y el que 00:34:23
me han dado? Bueno, pues 00:34:25
empiezo por 1 00:34:27
y voy incrementándolo. 00:34:27
¿Vale? 00:34:31
Y ahora ya sí que hago la cuenta. ¿La cuenta cuál va a ser? 00:34:32
Esto. Y ya sólo 00:34:35
me falta cuándo termino de contar. 00:34:37
¿Cuál sería la condición? 00:34:39
Cuando el 1 haya llegado al número que te han dado. 00:34:40
Claro, me han dicho, cuenta solamente 00:34:43
entre los extremos 1 00:34:45
y el que te han dado. 00:34:46
Pues entonces la condición será, mientras 00:34:48
este numerito, 00:34:50
que es sobre el que yo estoy 00:34:52
haciendo el barrido, sea menor o igual 00:34:54
que el que me han dado 00:34:56
vale, bueno, esto 00:34:57
pues claro, uno 00:35:06
en un momento dado, pues lo 00:35:08
lo puede ver claro 00:35:10
lo puede hacer del tirón y ya está 00:35:12
no hay por qué desglosarlo en pasos 00:35:14
pero de alguna manera el proceso mental 00:35:16
al que responde 00:35:18
es a este que os digo 00:35:20
entonces ese proceso mental no lo perdéis de vista 00:35:21
porque es necesario en muchos contextos 00:35:24
más complicados, entonces cuando hay 00:35:26
una cuenta, hay un contador 00:35:28
eso está claro, un contador que se va incrementando 00:35:30
en un bucle 00:35:32
y hay una variable 00:35:32
que es la que va recibiendo 00:35:35
todo lo que yo me voy fijando 00:35:37
para contar 00:35:40
que se corresponderá al tipo de dato 00:35:40
de los elementos 00:35:43
que yo estoy contando 00:35:46
entonces una vez que ya lo tengo 00:35:47
pues ya habrá una condición 00:35:50
que indica si toca contarlo o no toca contarlo 00:35:51
una condición 00:35:54
y luego ya tendré que centrarme 00:35:54
primero en que esa variable 00:35:57
vaya cambiando, que esa variable 00:35:59
vaya pasando al siguiente, vaya pasando al siguiente 00:36:02
y luego ya en la 00:36:03
condición en la que paro de contar, no puedo 00:36:05
estar contando hasta el infinito, en algún momento 00:36:07
yo cuento los alumnos 00:36:09
que tienen gafas de aquí, no del 00:36:11
universo entero 00:36:13
¿vale? 00:36:15
¿vale? pues entonces 00:36:21
en el aula 00:36:23
virtual 00:36:26
Hay un montón de ejercicios de esto 00:36:28
Desde muy facilitos hasta más complicados 00:36:32
Vamos a empezar 00:36:34
O vais a empezar ahora con los facilitos del principio 00:36:35
Que alguno creo que es este 00:36:39
O bueno, no es exactamente este 00:36:40
Pero es muy parecido 00:36:41
Yo tenía un teléfono 00:36:42
¿Yo no tenía un teléfono en algún lado? 00:36:46
Uh, sí 00:36:53
Y lo sigo teniendo 00:36:54
Bueno 00:36:56
si no me conecto 00:36:59
a la 55 de John y ya está 00:37:10
ah, no sé 00:37:12
quién es la 55 de John 00:37:15
será él, ¿no? 00:37:17
en un momento me dice la password y listo 00:37:19
o sea, la hackeo 00:37:21
casi, casi 00:37:22
¿y por qué pones 00:37:25
más más? 00:37:35
porque esta variable 00:37:38
los números que yo estoy contando 00:37:40
parten desde el 1 00:37:42
pero tiene que pasar por todos 00:37:43
el 1, y luego el 2, y luego el 3, y luego el 4 00:37:45
yo tengo que hacer esa comprobación con todos 00:37:47
desde el 1 hasta n 00:37:49
entonces para pasar por todos 00:37:50
los tengo que ir incrementando 00:37:52
a ver 00:37:54
¿Qué pasa? ¿Tienes frío? 00:38:30
Gracias. 00:39:00
Venga, pues este listado de aquí. 00:39:30
Bueno, vamos a aprovechar y parar aquí en este momento. 00:39:43
Y luego ya reenganchamos. 00:39:49
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
23
Fecha:
20 de octubre de 2024 - 18:26
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 52″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
150.04 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid