Saltar navegación

20261022 Bucles-do-while - 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 25 de octubre de 2026 por Raquel G.

3 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues este enunciado, lo primero, como de costumbre, leerlo y entender lo que dice, programa que lee números, un número, otro número, otro número, otro número, que lee se refiere, que los va solicitando por teclado, introduzca número, píldole, introduzca número, píldole, así todo el rato, todo el rato, hasta el fin de los tiempos, no, hasta que el que está introduciendo los datos meta un cero, vale. 00:00:01
Pues muy bien, esa parte entendida 00:00:29
Ahí ya se nos activa la bombilla de decir 00:00:31
Vale, esto es un bucle 00:00:36
Porque hay una cosa que se hace un montón de veces 00:00:38
Que es solicitar número, leerlo, solicitar número, leerlo 00:00:41
Ya se nos activa la bombilla de que hay un bucle ahí 00:00:44
¿Vale? 00:00:46
Bueno, ¿y cuál es el objetivo del programa? 00:00:48
Algún objetivo tendrá, no estar todo el rato solicito, leo, solicito, leo, solicito, leo 00:00:51
Bueno, lo hice después 00:00:55
tendrá que contar 00:00:57
cuántos de esos números 00:00:59
que se han introducido previamente 00:01:02
es negativo 00:01:03
luego ahí se nos enciende ya otra bombilla 00:01:04
de ah vale, el objetivo del programa es contar 00:01:07
ya sabemos que contar 00:01:09
se hace siempre en el contexto de un bucle 00:01:11
siempre 00:01:13
para contar ya sabemos 00:01:14
porque nos lo hemos aprendido 00:01:17
porque ya lo hemos visto en ejemplo 00:01:18
entonces uno ya se lo aprende 00:01:19
primero lo entiende 00:01:21
después se lo aprende 00:01:23
y ya deja ahí el conocimiento 00:01:25
para que ese conocimiento pueda hacer 00:01:27
ese pin encendérsele a la bombilla 00:01:29
cuando tú le salgo 00:01:32
si no tienes el conocimiento ahí 00:01:33
nunca se te va a encender esa bombilla 00:01:35
vale, pues como nosotros ya hemos entendido 00:01:36
lo que es un contador y nos hemos aprendido 00:01:39
cómo se usa 00:01:41
pues ya está, esto va a implicar 00:01:42
que yo tenga que usar una variable contadora 00:01:44
que inicializa a cero 00:01:47
porque las cuentas siempre se inicializan a cero 00:01:48
y dentro del bucle 00:01:51
al cual está asociado el contador 00:01:54
porque los contadores siempre asociados 00:01:56
a un bucle, dentro de ese bucle 00:01:58
se tendrá que ir incrementando 00:02:00
la cuenta en cada iteración 00:02:02
se tendrá que ir incrementando la cuenta 00:02:04
conforme vayan ocurriendo 00:02:06
las cosas que tengo que contar 00:02:08
¿tengo que contar las todas? 00:02:10
las iteraciones 00:02:13
no, aquí tendré que contar sólo 00:02:13
las iteraciones que se correspondan 00:02:16
con números negativos 00:02:18
luego una cuenta 00:02:20
siempre está asociada 00:02:22
a una variable contadora que se inicializa a cero, y a un bucle. 00:02:24
Y ese contador se irá incrementando, irá contando en las iteraciones del bucle que corresponda, 00:02:29
en las que ocurra lo que tiene que contar, en las que ocurra, no todas. 00:02:38
Entonces mi cuenta, alumnos que pasan por la puerta que son rubios, 00:02:45
pues el bucle es alumno pasa, alumno pasa, alumno pasa. 00:02:51
Mi variable contadora, alumno pasa, moreno, bueno, lo incremento. 00:02:54
Alumno pasa, moreno, lo incremento. 00:02:59
Siguiente iteración, alumno pasa, rubio, ahí lo incremento, ¿vale? 00:03:01
Entonces, el contador se incrementa, su incremento ocurre siempre dentro del bucle, 00:03:04
pero no en todas las iteraciones, solo en las que se correspondan con el hecho que hay que contar. 00:03:10
bueno, pues entonces 00:03:15
automáticamente ya 00:03:19
tenemos el concepto de bucle en la cabeza 00:03:22
el concepto de contador 00:03:25
en cuanto leemos esto, pues ya vemos 00:03:26
vemos el problema en la cabeza 00:03:28
pues un bucle que está haciendo algo un montón de veces 00:03:29
un contador que se va incrementando cuando pase ese algo 00:03:32
ese algo que será 00:03:35
número negativo 00:03:37
¿sé poner número negativo en condición? 00:03:38
sí, menor que cero 00:03:41
pues ya casi tengo todos los elementos que necesito 00:03:42
para hacer este código 00:03:44
entonces ya 00:03:46
uno empieza a hacer su primera versión 00:03:47
sobre la que luego va iterando 00:03:50
empieza a hacer su primera versión 00:03:52
entonces como tenemos que leer del teclado 00:03:55
pues un escáner 00:03:57
habrá que usar 00:03:58
lógicamente 00:04:00
vale, y hemos dicho 00:04:02
esto va a necesitar un bucle 00:04:13
sí o sí 00:04:15
un bucle sí o sí 00:04:16
porque hago muchas veces algo 00:04:18
En este caso leer por el teclado. Bueno, pues va a necesitar un bucle, la estructura de bucle es algo así, aquí dentro del bloque de llaves lo que se repite. 00:04:22
Pues, ¿qué es lo que se repite? Pues en particular se repite lo de pedir número, leerlo, pedir número, leerlo. 00:04:31
pues venga, pedir número 00:04:37
y leerlo, ¿qué significa leerlo? 00:04:41
leerlo significa recoger el valor de la consola 00:04:50
y asignárselo a la variable que a mí me dé la gana, eso significa leer 00:04:53
un valor del teclado, ¿no? entonces, a una 00:04:57
variable, pues por ejemplo 00:05:01
esta, este es el número que yo voy a leer del teclado 00:05:04
bueno, pues ya he hecho parte del programa 00:05:09
que es, esto lo voy a hacer un montón de veces 00:05:15
introduzca número, léelo, introduzca número, léelo, introduzca número, léelo 00:05:18
vale 00:05:22
el objetivo del programa ya he leído antes que es 00:05:23
contar cuántos de estos números son negativos 00:05:27
pues contar va a implicar 00:05:30
una variable contadora 00:05:33
inicializada a cero 00:05:35
que es la que va a llevar la cuenta 00:05:37
Y ahora esa variable se va a incrementar dentro del bucle cuando corresponda, ¿vale? 00:05:39
En cada iteración del bucle, en cada vuelta, en cada iteración, toca incrementarla. 00:05:47
Hay que contar todas las iteraciones, todas, todas, todas. 00:05:54
No hay que contarlas todas, ¿no? 00:05:58
hay que contar solo 00:05:59
hay que contar solo 00:06:02
las iteraciones en las cuales 00:06:03
se haya ingresado 00:06:06
un número negativo 00:06:09
solo hay que contar 00:06:11
esas 00:06:12
entonces ya tengo bastante 00:06:13
hecho y para 00:06:19
eso pues me he apoyado en cosas que ya 00:06:20
he entendido de ejercicios 00:06:23
anteriores que hemos hecho 00:06:24
que pues ya me voy apoyando en eso 00:06:27
y digo ah vale ya tengo mi idea clara en la cabeza 00:06:28
pues la puedo aplicar a cualquier situación 00:06:31
cuando uno tiene ya los conceptos 00:06:33
claros ya puede dar el salto 00:06:35
de aplicarlos con las pequeñas 00:06:37
modificaciones que corresponda 00:06:39
de aplicarlos a cualquier otra situación 00:06:40
pues ala 00:06:42
el programa está acabado, lógicamente no hay cosas 00:06:44
aquí que me faltan 00:06:47
bueno, para empezar por supuesto me faltaría mostrar el resultado 00:06:47
final 00:06:51
han sido 00:06:51
con 00:06:56
números negativos 00:06:59
aquí para no arrastrar 00:07:03
esto como pequeño inciso 00:07:12
para no arrastrar cuando yo muestro 00:07:14
mensajes dentro de un system out 00:07:17
tan largos que son un rollo y que al final 00:07:18
los acabo poniendo aquí abajo para que 00:07:21
se vean en la pantalla 00:07:23
pero queda un poco feo 00:07:24
para no arrastrarlo 00:07:26
me voy a acostumbrar a 00:07:28
guardar primero 00:07:30
el mensaje que quiero mostrar 00:07:32
en un string 00:07:34
y luego pasarle el string 00:07:36
al system out este 00:07:39
lo voy a empezar a hacer de esta manera 00:07:41
porque se va a ver mejor el código 00:07:43
y que gano, me diréis 00:07:45
si ahora tengo que poner 00:07:47
la línea larga igualmente 00:07:49
no, porque tengo el string 00:07:51
multilínea 00:07:53
que os dije en su momento, que a partir 00:07:54
de cierta versión de java se puede usar 00:07:57
que es 00:07:59
que tú pones aquí 00:08:01
habido 00:08:02
En este caso, pues tampoco es que me ha habido, lo concateno aquí con número, hemos quedado, número y lo vuelvo a concatenar con otro, multilínea aquí y me voy aquí, números negativos. 00:08:06
Números negativos 00:08:39
Punto, aquí me aseguro que he puesto un espacio 00:08:45
Y aquí pongo otro 00:08:48
Vale, a ver, un string 00:08:50
Número, he puesto aquí 00:08:55
Ay, cont, jolines 00:08:58
Vale, entonces 00:09:03
Cuando tenéis que escribir un string muy largo 00:09:09
Un string muy largo 00:09:12
Pues el Java 00:09:13
Simplemente el compilador de Java 00:09:16
Te permite iniciarlo 00:09:17
y cerrarlo 00:09:20
con tres series de comillas 00:09:21
dobles, iniciarlo y cerrarlo con tres series de comillas 00:09:24
dobles, y aquí uno podría 00:09:26
poner todas las líneas que quisiera 00:09:28
¿vale? 00:09:29
entonces, ¿qué nos 00:09:32
permite el string este 00:09:34
multilínea iniciado y cerrado 00:09:36
con una secuencia de tres dobles 00:09:37
comillas? es string 00:09:40
ponerlo en varias líneas, y no tener que escribirlo 00:09:42
todo seguido, que solo 00:09:44
efectos de verlo, en el código aquí 00:09:46
de verlo, nada más, el string es el mismo 00:09:48
luego cuando se guarda en memoria, como variable 00:09:49
es el mismo, pero solo a efectos 00:09:52
de verlo, pues mucho más bonito 00:09:54
así, que si no 00:09:55
si yo quiero varias líneas 00:09:58
pues tendría que ponerlo así 00:10:00
ha habido 00:10:02
ahora 00:10:04
tendría que concatenarlo 00:10:06
con la línea 00:10:08
que fuera, bajándome aquí abajo 00:10:10
vale 00:10:12
no me puedo bajar 00:10:14
abajo de golpe, tendría que 00:10:16
partirlo y poner aquí el otro string que es un rollo entonces vale bueno pues os podéis 00:10:17
acostumbrar al string este porque lo vais a ver en cualquier situación vale empieza y se cierra 00:10:31
con triples dobles comillas y eso nos permite poner varias líneas sin necesidad de tener que 00:10:48
concatenar una línea con otra, una línea con otra 00:10:55
todo el rato, bueno pues entonces 00:10:57
yo voy a dejarlo así más cortito 00:11:01
ya está, vale 00:11:10
bueno pues 00:11:12
ya hemos hecho la parte del programa que nos 00:11:14
faltaba, que era mostrar el resultado 00:11:17
venga, muy bien, mostrar el resultado, pero este programa 00:11:19
sigue, le faltan cosas 00:11:21
porque el bucle cuando acaba 00:11:23
vale, me falta la condición 00:11:25
del bucle 00:11:27
y todos recordamos que significa la condición 00:11:28
que se pone ahí 00:11:31
Ahí se pondrá una condición que mientras sea cierta entramos en el bucle, entonces llegamos por primera vez, evaluamos condición, si es cierta entramos, llegamos y volvemos arriba, volvemos a evaluar, si es cierta entramos y volvemos arriba, que ya es falsa, salimos, ¿vale? 00:11:32
Ya sabemos lo que significa esa condición, ya la hemos entendido de varios ejemplos. 00:11:54
Vale, pues aquí nos tendremos que plantear poner una condición que cuando sea falsa, se acabó, salgo del bucle. 00:11:59
Y cuando sea cierta, vuelvo a entrar. 00:12:09
Entonces, para eso tenemos que recordar el enunciado, a ver qué me dice. 00:12:12
El programa tiene que estar leyendo números todo el rato hasta que se introduzca un cero. 00:12:17
Cuando se introduce un cero, tiene que cambiar. 00:12:21
Perdón, tiene que terminar. 00:12:24
Vale. 00:12:26
Pues entonces, ¿qué condición se os ocurriría poner aquí? 00:12:27
Para que el bucle, cada vez que tú introduzcas un número que no sea cero, vuelva otra vez arriba, vuelva otra vez arriba. 00:12:30
Cuando tú has introducido un número que es cero, ya no vuelve a pedirte más números y el bucle termina. 00:12:38
¿Qué condición pondríais ahí? 00:12:44
Venga, que alguien me diga, lo que sea. 00:12:52
Dictádmelo tal cual lo escribiríais. 00:12:59
con los nombres de variables que tengo yo ahí 00:13:00
y todo 00:13:03
los negativos también valen 00:13:03
o sea, la única condición 00:13:19
que hace que ya no haya 00:13:21
más peticiones es que tú pongas 00:13:23
cero 00:13:24
claro, tú piensa que ahí pones 00:13:25
la condición 00:13:32
opuesta a la de salida 00:13:33
la opuesta a la de salida 00:13:36
siempre 00:13:38
o sea, esta es la opuesta a la de salida 00:13:38
¿cuándo vas a salir tú? 00:13:46
claro, salimos 00:13:48
cuando el número sea igual a cero 00:13:50
entonces normalmente 00:13:52
nosotros identificamos más fácilmente 00:13:53
la condición que haga que salgamos 00:13:57
pues en este caso el número es igual a cero 00:13:58
o aquí pues cuando 00:14:00
están pasando alumnos 00:14:02
cuando Rubio, Moreno, yo voy contando 00:14:04
pues cuando pasa un alumno sin pelo 00:14:06
nosotros normalmente identificamos 00:14:08
más fácilmente de palabra 00:14:10
la condición que hace que el bucle termine 00:14:11
vale, pero lo que tenemos que pensar 00:14:13
es que la que ponemos aquí 00:14:15
tiene que ser justo la negada de esa 00:14:17
porque esta condición significa 00:14:19
si esto ocurre, vuelvo a entrar 00:14:22
no termino 00:14:24
con lo cual esta tiene que ser siempre 00:14:25
la condición opuesta o negada 00:14:27
de la que hace que el bucle 00:14:29
termine 00:14:31
entonces en este caso, el bucle cuando ya no va a pedir 00:14:32
más números y va a continuar 00:14:35
ya el programa o lo que sea 00:14:37
cuando el número sea igual a cero, pues aquí hay que poner 00:14:39
exactamente la negada 00:14:41
¿vale? entonces 00:14:43
si pusiéramos exactamente la negada 00:14:45
estaríamos poniendo esto, ¿verdad? 00:14:47
podríamos poner, mientras 00:14:49
número igual a cero, o sea, esta es mi condición 00:14:53
esta es mi condición 00:14:56
para que se vea mejor con los paréntesis 00:14:59
esta es mi condición de salida 00:15:01
cuando número igual a cero 00:15:03
me voy fuera 00:15:05
pero la que tengo que poner aquí dentro 00:15:06
es justo la opuesta 00:15:09
porque lo que se pone aquí dentro es la condición 00:15:11
que si se cumple 00:15:13
entras otra vez 00:15:15
luego tienes que poner la opuesta a la que te hace salir 00:15:16
¿vale? 00:15:20
entonces como la que te hace salir es número igual a cero 00:15:21
pues aquí la opuesta 00:15:23
¿vale? 00:15:25
pero claro, esto así escrito está bien 00:15:27
esta condición está bien, arreglamos eso del rojo 00:15:29
esto está bien 00:15:31
pero 00:15:32
es muy fea 00:15:34
decir no 00:15:37
número igual a cero es mucho mejor 00:15:38
poner número distinto de cero 00:15:40
es más bonito 00:15:42
entonces para qué poner no número igual 00:15:44
a cero si podemos poner número distinto 00:15:46
de cero y nos queda todo más chulo 00:15:48
¿vale? entonces esto empieza 00:15:50
ya a aproximarse, tiene el boceto de nuestro 00:15:54
programa final 00:15:56
mientras el número leído sea diferente 00:15:57
de cero 00:16:00
pues pido número 00:16:00
y si es negativo lo cuento 00:16:03
vale, tiene pinta de que esto ya 00:16:06
y luego ya muestro mi resultado 00:16:07
vale 00:16:09
pero aquí 00:16:10
ya hay algo raro y de hecho ya me está avisando 00:16:14
el compilador con un error de compilación 00:16:17
que me lo pone aquí en rojo 00:16:19
vale 00:16:20
entonces 00:16:22
sin mirar el aviso que me está dando 00:16:25
¿por qué creéis que el compilador 00:16:27
que esto ya nos ha salido 00:16:30
otras veces, ¿por qué creéis que el compilador 00:16:31
se está quejando ahí? 00:16:33
Y está diciendo, oye, no, dime, exactamente, porque una variable no puede usarse antes de su declaración, nunca. 00:16:35
Siempre tiene que estar declarada antes de su primer uso, ¿vale? 00:16:47
Entonces, aquí la estamos usando, la estamos usando para evaluar una condición. 00:16:52
pero la variable no está declarada 00:17:00
porque yo cuando estaba 00:17:04
haciendo el programa, como estaba tirando así 00:17:06
haciéndolo pipas pipas 00:17:08
pues la he declarado aquí en el momento de leerlo 00:17:09
entonces pues no es su sitio 00:17:12
tendría que declararla antes 00:17:14
¿vale? 00:17:16
entonces yo puedo arreglar esto 00:17:18
declarándola antes 00:17:19
¿vale? 00:17:21
vale, pues entonces 00:17:25
yo la declaro antes 00:17:27
y entonces 00:17:31
ya puedo usarla 00:17:36
a partir de este punto, puedo usarla 00:17:38
entonces según esto, pues yo quito esto 00:17:40
y se acabó, perdón, vale 00:17:42
vale 00:17:44
pero de nuevo, ya esto 00:17:47
podría acercarse más a mi resultado 00:17:50
final, pero de nuevo 00:17:52
el compilador me está diciendo 00:17:54
hay algo que no me gusta y que 00:17:56
no te dejo seguir, no te dejo 00:17:58
que ejecutes este programa, porque aquí hay algo 00:18:00
que no me gusta, por eso está en rojo 00:18:02
pues de nuevo, que no le gusta al compilador 00:18:03
y por qué 00:18:07
no nos deja 00:18:08
compilar y ejecutar ese programa. 00:18:09
Claro, no tiene 00:18:21
valor en este momento. Entonces, cuando 00:18:22
se usa 00:18:23
cuando se usa 00:18:24
un valor en una 00:18:27
expresión, en este caso es una expresión booleana, 00:18:32
pero podría estarse usando 00:18:34
para hacer una suma, lo que fuera. 00:18:36
Cuando se usa un valor dentro de una 00:18:38
expresión, 00:18:40
se asume que 00:18:42
una variable, perdón. Cuando se usa una variable 00:18:43
dentro de una expresión se asume que esa variable 00:18:46
ha llegado a este punto 00:18:48
ha llegado a este punto 00:18:50
con un valor dentro asignado 00:18:51
porque si no ha llegado con un valor dentro asignado 00:18:53
si esta es mi variable número 00:18:56
la cajita de memoria que tiene mi variable número 00:18:57
es esta 00:19:00
si no tiene nada asignado 00:19:01
no he hecho ninguna asignación 00:19:04
cuando ahora 00:19:06
la máquina virtual tenga que 00:19:08
coger el valor que tiene dentro 00:19:09
para compararlo con cero 00:19:11
pues dirá, uy, en esta caja no hay nada 00:19:13
nadie ha metido nada, no puedo usar 00:19:15
el valor de esta variable para la expresión 00:19:17
correspondiente, no puedo usarlo 00:19:20
porque nadie ha metido nada 00:19:22
entonces efectivamente 00:19:23
lo que nos está diciendo es 00:19:25
que número no está inicializado 00:19:28
entonces 00:19:30
a ver, en realidad sí lo está 00:19:31
porque 00:19:33
la RAM, sus ceros y unos 00:19:34
sus diestables 00:19:37
tienen que tener cosas, no tiene la nada 00:19:39
o tiene ceros o tiene unos 00:19:42
entonces 00:19:43
Java por defecto 00:19:44
cuando tú declaras una variable 00:19:47
inicializa cero 00:19:48
pero el compilador te dice 00:19:49
la inicialización que tienes 00:19:53
la inicialización por defecto 00:19:54
mira que me extraña que la inicialización por defecto 00:19:56
coincida con la que quieres tú 00:19:58
haz tú una explícita 00:19:59
es la que nos está diciendo 00:20:02
haz tú una inicialización que tú quieras 00:20:04
yo no voy a confiar en la de por defecto 00:20:06
que esa 00:20:09
te valga 00:20:10
¿Vale? 00:20:12
Bueno, pues entonces, ¿cómo podríamos arreglar esto? 00:20:14
Perfecto. 00:20:21
Hay una solución que es la más fácil, que es, 00:20:22
yo lo que quiero es que entre en el bucle una primera vez, 00:20:24
que entre en el bucle una primera, 00:20:28
porque la primera vez tiene que entrar sí o sí, 00:20:30
porque el primer número lo necesito. 00:20:32
El primer número lo necesito. 00:20:34
¿Qué es este? 00:20:36
Vale, ya no entro más veces. 00:20:37
Pero una primera vez tengo que entrar sí o sí para leer el primero. 00:20:38
pues como me las puedo apañar 00:20:41
para forzar 00:20:43
que esta condición 00:20:45
la primera vez 00:20:47
sea cierta si o si 00:20:49
queremos que la primera vez sea cierta si o si 00:20:50
pues le damos a número 00:20:53
cualquier valor diferente de 0 00:20:55
cualquiera 00:20:57
y entonces ya automáticamente el while 00:20:58
entra una primera vez 00:21:01
porque esa primera vez es que tiene que entrar 00:21:03
si o si, queremos que entre si o si 00:21:05
para leer el primero 00:21:07
entonces este sería el arreglo más sencillo 00:21:08
lo inicializamos a cualquier valor 00:21:11
diferente de cero 00:21:13
entra y ya lee el primero 00:21:14
y a partir de ahí ya lo cuenta 00:21:17
si es negativo 00:21:19
y vuelve, era cero 00:21:20
ese que has metido, ese último, no, no era cero 00:21:22
pues otro segundo 00:21:25
y lo cuenta si es negativo 00:21:26
era cero ese último, pues sí 00:21:28
resulta que era cero 00:21:31
pues ya está, se acabó 00:21:32
entonces esa podría ser 00:21:34
la solución más sencilla 00:21:38
lo inicializamos a cualquier valor 00:21:41
diferente de cero 00:21:44
entonces el programa ya 00:21:45
no tiene ni un error de compilación 00:21:49
¿vale? ni uno 00:21:52
y tiene pinta 00:21:54
de que se aproxima lo que queremos hacer 00:21:57
ahora pueden pasar varias cosas 00:21:59
que cuando lo ejecutemos 00:22:04
pete porque hay algo mal 00:22:05
le salen excepciones y ya entenderemos lo que son 00:22:08
o también puede ocurrir 00:22:10
que no le salgan excepciones y haga cosas 00:22:12
pero no sea lo que queremos 00:22:14
que esos son los errores complicados 00:22:16
los errores de compilación son muy fáciles 00:22:18
de arreglar porque es que estoy viendo ahí 00:22:20
que algo no funciona y lo arreglo 00:22:22
el verdadero 00:22:24
problema es cuando haces un software 00:22:26
y ese software funciona pero lo que 00:22:28
hace no es lo que tiene que hacer porque eso se 00:22:30
corresponde a que has hecho mal el algoritmo 00:22:32
has hecho mal el diseño y tienes que cambiarlo 00:22:34
desde el punto inicial 00:22:36
no es un error de sintaxis ni nada de eso 00:22:38
es un error sencillo 00:22:39
bueno vamos a probar esto antes de nada 00:22:40
ejecutamos esto 00:22:44
introducimos un número 00:22:49
vale, pues dos negativos 00:22:51
entonces, a ver, esta prueba no me debería 00:22:58
a mí permitir 00:23:00
concluir que funciona 00:23:02
en esta prueba sí, pero la idea es 00:23:03
probar con casos 00:23:06
los casos más raros 00:23:08
por ejemplo, introducir un cero 00:23:10
en este caso, el único caso raro que se me ocurre 00:23:12
es introducir un cero ya de partida 00:23:14
a ver qué hace 00:23:16
pues cero de partida 00:23:17
vale, pues sí, parece que es lo que quiero 00:23:21
bueno, pues parece que el programa funciona 00:23:24
nos quedamos con él, nos gusta y ya está 00:23:28
y no solo nos gusta 00:23:30
sino que nos ha permitido darnos cuenta 00:23:35
de una situación 00:23:37
que puede darse mucho 00:23:39
y que precisamente 00:23:41
porque se da mucho 00:23:43
Java nos ofrece 00:23:44
una sintaxis específica 00:23:47
para esa situación 00:23:49
no es necesaria 00:23:50
pero se adapta a una situación 00:23:52
que puede repetirse mucho 00:23:55
¿qué es la que ocurre aquí? 00:23:56
que tenemos un bucle 00:23:59
en el cual la primera vez 00:24:01
queremos que se ejecute 00:24:03
sí o sí 00:24:05
y ya las siguientes depende 00:24:05
era justo la situación de este bucle 00:24:07
la primera vez queremos que se ejecute 00:24:11
porque el primer dato lo necesitamos 00:24:13
y luego ya las siguientes depende de los datos 00:24:15
entonces 00:24:17
eso pasa en algunas situaciones 00:24:19
Hay veces en las que no, en función del tipo de problema que yo esté resolviendo, a lo mejor al bucle no tengo que entrar nunca, depende de mis datos de entrada, pero en situaciones como esta, en la cual tú estás pidiendo datos de entrada para hacer cosas, lo normal es que la primera vez quieras entrar sí o sí, porque los datos primeros los quieres, y luego ya los demás datos los querrás o no, dependiendo de lo que ocurra. 00:24:20
entonces esta es una situación típica 00:24:47
la única en la cual tú 00:24:49
quieres hacer un bucle en el cual 00:24:51
quieres entrar una vez 00:24:53
es así o sí independientemente de la 00:24:55
condición y luego ya las siguientes 00:24:57
ya sí que depende 00:24:59
de cómo han sido esos primeros datos etc 00:25:00
¿vale? 00:25:03
entonces esto aquí lo hemos arreglado 00:25:05
pues haciendo esa trampilla 00:25:06
entre comillas que es 00:25:09
pues a esta variable le pongo 1 y forzo a que esta condición 00:25:10
sea true ¿vale? y no pasa nada 00:25:13
lo único es que 00:25:15
aquí como el programa es pequeñito 00:25:17
está todo compacto, vale 00:25:19
no pasa nada, pero en otra situación 00:25:21
a lo mejor yo esta inicialización 00:25:23
que he hecho como trampa 00:25:25
para que esto sea true la primera vez 00:25:27
esta inicialización resulta que está 00:25:29
muy arriba, porque el bucle está muy 00:25:31
abajo o en otra clase incluso 00:25:33
porque mi programa es muy grande 00:25:35
entonces el que está viendo 00:25:37
el código ve esta inicialización 00:25:39
y algo le extraña y dice 00:25:41
¿por qué a uno? ¿por qué de partida tiene que 00:25:43
¿será uno? ¿significará eso algo? 00:25:45
¿vale? cuando uno lee un código 00:25:47
de alguien, la idea es que 00:25:49
echando vistazos, así, entienda 00:25:51
qué hace, de qué va 00:25:53
entonces, uno ve esto y dice, ah vale 00:25:54
es una cuenta, porque 00:25:57
¿y esto? ¿por qué un número 00:25:58
es uno? ¿ese uno pinta algo? 00:26:01
aquí no pinta nada, podría haber sido 00:26:03
13, 27, 2.500 00:26:05
nos daba igual, con que fuera diferente de 00:26:06
cero, o sea, no tiene un significado real 00:26:09
y sin embargo, el que 00:26:11
lo vea dice, ¿y ese uno por qué? 00:26:13
tiene un significado, pues no tiene ninguno 00:26:14
solamente que quiere un número diferente 00:26:16
de 0 00:26:19
bueno, pues precisamente para 00:26:19
hacer más elegante, más bonito 00:26:22
el lenguaje 00:26:25
hay otra sintaxis 00:26:26
de bucles 00:26:29
que es la do while 00:26:30
que es esta 00:26:32
en lugar de 00:26:39
esta otra que es 00:26:45
while condición 00:26:47
y aquí lo que tengas que hacer 00:26:51
que esta ya la conocemos 00:26:53
y la entendemos, mientras se dé esta condición 00:26:55
haz lo que sea, vuelves, se sigue dando, vuelves 00:26:58
pues hay esta sintaxis 00:27:00
que esta sintaxis, ¿cómo funciona? 00:27:01
el programa llega por aquí 00:27:03
ejecuta una primera vez 00:27:04
lo que hay aquí, y esa primera vez es 00:27:07
incondicional, ni mira condición 00:27:09
ni mira nada, lo ejecuta una primera vez 00:27:12
y ahora ya 00:27:14
las siguientes veces 00:27:15
las va a ejecutar 00:27:17
dependiendo de si la condición es cierta o no 00:27:20
luego lo ejecuto una primera vez 00:27:22
esa siempre 00:27:24
y ahora, la condición es cierta 00:27:26
voy a por la segunda 00:27:28
y vuelvo a mirar, la condición es cierta 00:27:30
voy a por la tercera y vuelvo a mirar 00:27:32
la condición es cierta, voy a por la cuarta 00:27:34
así hasta que se haga falsa 00:27:37
que entonces ya 00:27:38
no hacemos nada más 00:27:40
luego, este bucle de arriba 00:27:41
y este bucle de abajo 00:27:48
son iguales 00:27:50
con la diferencia 00:27:52
de que este bucle de arriba 00:27:54
hay una primera vez que esto lo hace 00:27:56
antes de mirar la condición 00:27:59
luego 00:28:00
nosotros tenemos 00:28:06
cualquier código con while 00:28:12
así, while condición 00:28:13
y aquí tenemos 00:28:16
la sentencia que sea 00:28:18
pues esto es exactamente 00:28:20
igual 00:28:24
es exactamente igual 00:28:24
que 00:28:26
perdón, si yo tengo 00:28:27
aquí quería poner un do while 00:28:30
vale, si yo tengo un bucle así 00:28:32
aquí las sentencias que sean 00:28:42
while la condición 00:28:45
que sea terminado con punto y coma 00:28:52
que hay que poner un punto y coma al final 00:28:54
porque las sentencias siempre acaban en punto y coma 00:28:55
pues esa también, acaba en punto y coma 00:28:58
vale, pues si yo tengo ese código 00:28:59
ese código 00:29:03
fijaos que es lo mismo que si yo escribiera 00:29:04
esto 00:29:06
la sentencia que sea 00:29:07
y ahora el bucle while 00:29:10
con la condición 00:29:12
y aquí la sentencia otra vez 00:29:17
pues el código de la izquierda 00:29:18
y el código de la derecha 00:29:26
son intercambiables 00:29:27
perfectamente intercambiables, hacen lo mismo 00:29:28
este que hace, ejecuta la sentencia 00:29:31
y a partir de ahí 00:29:34
se da la condición, la vuelve a ejecutar 00:29:35
se da la condición, la vuelve a ejecutar 00:29:37
se da la condición, no, se acabó 00:29:39
que es justo lo que hace éste ejecuta la sentencia y a partir de ahí se da la condición si lo vuelvo 00:29:41
a ejecutar se da así lo vuelvo a ejecutar se da no termino luego el código de la izquierda y el 00:29:47
de la derecha son intercambiables entonces en situaciones en las cuales lo que yo hago dentro 00:29:53
quiero que se haga una primera vez sí o sí incondicional podría poner esto pero queda 00:30:02
más bonito y más compacto si lo pongo así. 00:30:10
Lo pongo de esta manera, estoy 00:30:14
haciendo exactamente lo mismo, pero queda 00:30:16
más bonito. En lugar de sacar esto fuera 00:30:18
una vez, que se 00:30:20
correspondería, en el ejemplo de nuestro programa, 00:30:22
a la primera lectura, hacerla fuera una primera 00:30:24
vez, pues en lugar 00:30:26
de sacar esto fuera para que se haga una 00:30:28
primera vez sí o sí, 00:30:30
pues lo cambio a un do-while y ya está. 00:30:32
Y tengo exactamente lo mismo. Son dos códigos 00:30:34
idénticos. 00:30:36
¿Vale? 00:30:38
Entonces, esto era esto, sí, pues el código este, este programa nuestro, si lo hacemos con do while, se transformaría y se convertiría en algo así, haríamos do, lo primero, la primera lectura del número sí o sí, la primera la hacemos sí o sí. 00:30:42
Ahora, esto de aquí 00:31:19
Contarlo 00:31:24
Si es negativo, como siempre 00:31:26
Y ahora 00:31:28
Mientras que 00:31:29
Mientras número 00:31:32
Sea diferente 00:31:34
De cero 00:31:39
¿Vale? 00:31:40
Pues entonces, este programa 00:31:44
¿Qué es lo que hace? 00:31:48
Lee el primero, sí o sí 00:31:50
Si es negativo 00:31:52
Lo cuento 00:31:54
Es cero 00:31:55
no, no es cero, pues arriba 00:31:58
vale, pues que gano 00:32:00
de hacer este código respecto a hacer el de arriba 00:32:04
voy a comentar este 00:32:08
para quitar este como si no existiera 00:32:09
lo que gano 00:32:12
es que ahora no necesito hacer la trampa 00:32:13
de inicializar esta variable 00:32:16
ya no lo necesito 00:32:17
yo la dejo ahí sin inicializar 00:32:19
¿por qué? 00:32:21
porque hay una primera vez en la que ya entro 00:32:23
sí o sí 00:32:25
y en esta primera vez en la que entro sí o sí 00:32:26
número ya coge su primer valor 00:32:29
ya coge aquí su primer valor 00:32:32
luego 00:32:35
en este ejemplo que estaba viendo 00:32:37
que gano, repito 00:32:39
respecto a la versión anterior, que gano 00:32:41
pues no tener que hacer esta inicialización 00:32:43
¿vale? no tener que hacerla 00:32:46
y que el programa 00:32:48
a la vista, a los ojos 00:32:49
representa más 00:32:51
lo que está haciendo, que es yo rápidamente 00:32:53
al ver un do while rápidamente veo 00:32:55
que hay una vez que se va a hacer sí o sí. 00:32:57
Entonces entiendo mejor lo que está pasando, ¿vale? 00:33:01
Bueno, pues entonces ya tenemos dos sintaxis para un bucle, 00:33:15
while y do while, ¿vale? 00:33:19
Ya tenemos dos. 00:33:22
¿Y cuál elegimos? 00:33:25
Pues la que mejor se adapte a la situación. 00:33:27
Criterio de elección, ya sabemos, 00:33:29
si lo que se repite al menos la primera vez 00:33:32
tiene que hacerse sí o sí incondicionalmente 00:33:36
porque identifico que esa es la situación 00:33:38
se tiene que hacer sí o sí una primera vez 00:33:40
pues hago esto 00:33:42
¿vale? hago esto 00:33:44
y me ahorro hacer un while 00:33:45
en el cual tengo que sacar la primera lectura 00:33:48
afuera o hacer la trampa 00:33:50
de inicializarlo a un valor para que 00:33:52
esta condición sea cierta la primera 00:33:54
vez sí o sí 00:33:56
me ahorro trabajo y dejo el programa más en consonancia 00:33:57
con lo que tiene que hacer 00:34:00
con lo que hace 00:34:01
¿está claro? 00:34:03
Bueno, vale, pues entonces, a partir de este, ahora ya empiezan ejercicios, unos cuantos ejercicios distintos, con otra idea. 00:34:06
De aquí hacia arriba, aparte de la sintaxis de bucle y lo que hace, pues nos ha permitido ver claro lo que es un contador y en qué contexto lo usamos y por qué y de qué manera. 00:34:23
Bueno, aquí ya no me están hablando de contar, me están hablando de otras situaciones normalmente asociadas a bucles. 00:34:35
por ejemplo me están hablando de sumar 00:34:41
no de contar 00:34:44
vale, en estos primeros 00:34:45
me están hablando de sumar, de hacer medias 00:34:47
etcétera, vale 00:34:50
hasta aquí 00:34:51
aquí ya me empiezan a hablar de otra cosa 00:34:52
bueno, pues vamos a parar aquí 00:34:55
un momento 00:34:57
y ahora ya vemos como haríamos eso 00:34:58
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado básico
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
3
Fecha:
25 de octubre de 2026 - 19:14
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 02″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
137.74 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid