Saltar navegación

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

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

9 visualizaciones

Más información Transcripción

Descargar la transcripción

A ver, seguimos. 00:00:00
Bueno, pues este programa de aquí está bien hecho, hemos comprobado que funciona. 00:00:08
A ver, no hemos hecho mil pruebas, pero bueno, con lo que hace, 00:00:13
con una prueba ya nos ha bastado para ver que funciona. 00:00:17
Venga, seguimos. 00:00:21
Bueno, vale, ya está, y así se podía quedar. 00:00:24
Vale, pues, este es un ejemplo de programa, de bucle. 00:00:28
Venga, hacedme caso. 00:00:38
Bueno, este es un ejemplo de bucle, 00:00:50
en el cual, ya de partida, 00:00:53
según hemos introducido los datos de entrada ya en el inicio, 00:00:57
ya sabemos la cantidad de veces que se va a ejecutar. 00:01:01
Ya lo sabemos, sabemos que se va a ejecutar n mayúsculas veces, ya lo sabemos. 00:01:05
Hay otros programas que hemos hecho, otros ejemplos de bucle que no lo sabíamos. 00:01:09
Como por ejemplo, este no, pero este sí. 00:01:13
Por ejemplo, este bucle, no sabemos las veces que se va a ejecutar. 00:01:19
Si el tío se está metiendo sí 27 veces, o 27 veces. 00:01:24
Si el tío metenó a la primera. 00:01:29
Es decir, antes de entrar en él, es imposible prever cuántas veces se va a ejecutar. 00:01:32
Antes de entrar en él es imposible, porque se va decidiendo en cada ejecución, 00:01:37
si hay una más, y si hay otra, y si hay otra. 00:01:41
Se va decidiendo en cada ejecución. 00:01:44
Luego, antes de entrar en él, en este punto, es imposible saber las veces que se va a ejecutar. 00:01:46
No se puede, en el momento de entrar en él no se puede. 00:01:51
Sin embargo, este otro, antes de entrar en él, ya sabemos las veces que se va a ejecutar seguro. 00:01:55
Porque depende de un dato que ya me ha dado, que es el número n. 00:02:02
Entonces sé que ese bucle se va a ejecutar n mayúsculas veces. 00:02:07
Y para eso hemos puesto un contador que empieza variando 1, se va incrementando, 00:02:12
y cuando llega a n, luego efectivamente se ejecuta n mayúsculas veces. 00:02:15
Luego hay situaciones en las cuales hay un bucle que en el momento de entrar en él 00:02:20
ya sabemos las veces que se va a ejecutar. 00:02:25
7, 15, n mayúsculas más 3, las que sean. 00:02:28
En este caso lo sabíamos, sabemos que se va a ejecutar n mayúsculas veces. 00:02:32
Bueno, pues cuando en un bucle sabemos, en el momento de entrar en él, 00:02:37
ya las veces que se va a ejecutar, porque ya tenemos todos los datos para saberlo, 00:02:41
podemos hacer una sintaxis que, aparte de dejarlo más claro, 00:02:46
nos facilita algunas cosas, que es la sintaxis for. 00:02:51
Vamos a hacerlo aquí, por ejemplo. 00:02:58
Vamos a hacer este mismo bucle de aquí, este mismo bucle que me mostraba el triangulito. 00:03:03
Ese mismo bucle lo vamos a hacer, pero con otra sintaxis de bucle. 00:03:09
Pues lo mismo de arriba lo vamos a hacer con otra sintaxis de bucles. 00:03:20
Que es el bucle for. 00:03:33
Vale, pues vamos a ver. 00:03:38
¿Cómo es la sintaxis del bucle for? 00:03:42
La sintaxis del bucle for es, primero la palabra for, como era fácil de... 00:03:45
Aquí unos paréntesis que ahora completamos, y aquí lo que se va a repetir, 00:03:53
lo que se va a repetir, como en todos los bucles. 00:04:03
Sentencias que se van a repetir. 00:04:10
Vale, pues ¿qué ponemos aquí dentro del for? 00:04:18
Cuando era un while poníamos la condición que si se cumple entramos dentro. 00:04:21
En el for no se pone eso, en el for se ponen tres cosas. 00:04:26
Tres cosas separadas por punto y coma. 00:04:29
Tres cosas distintas se ponen. 00:04:33
Tres cosas. 00:04:36
A ver, alguna de ellas se puede quedar vacía si no la necesito, 00:04:39
pero que tienen que estar los puntos y comas separando las tres zonas, eso es inamovible. 00:04:44
¿Vale? 00:04:51
La sintaxis del for tiene aquí tres espacios para tres cosas separadas por punto y coma. 00:04:52
Que algún espacio lo dejo sin rellenar porque no necesito esa parte, lo dejo sin rellenar. 00:04:59
Pero tiene que estar ahí. 00:05:03
Vale, ahora la pregunta es, ¿qué ponemos en este espacio? 00:05:05
¿Qué ponemos en los espacios? 00:05:09
Bueno, el espacio de dentro es el más fácil de entender. 00:05:11
En el espacio de dentro ponemos una condición, 00:05:15
que es la condición que si se cumple yo vuelvo a entrar en el bucle. 00:05:18
Es lo que ponemos ahí. 00:05:23
¿Vale? 00:05:25
Aquí pondríamos la condición que si se cumple volveríamos a entrar. 00:05:26
La condición que iría en el while. 00:05:31
Esta condición. 00:05:34
La condición que iría en el while. 00:05:36
Entonces, si yo dejo un bucle for así, es lo mismo que hacer esto. 00:05:38
Es exactamente lo mismo. 00:05:44
Es decir, si esto lo dejo en blanco y esto lo dejo en blanco, 00:05:50
no uso esos espacios, no los uso. 00:05:53
Esto y esto son lo mismo. 00:05:56
Son lo mismo. 00:05:59
Entonces yo no uso un bucle for si quiero ignorar esto. 00:06:00
Porque para eso uso un while que me queda más bonito. 00:06:04
¿Vale? 00:06:07
Uso un bucle for si además quiero usar estas prestaciones adicionales que tiene el bucle for. 00:06:08
¿Vale? 00:06:13
Porque el bucle for es un while con... 00:06:14
Tranquilo, lo vamos a aplicar ahora. 00:06:17
El bucle for es un bucle while con prestaciones adicionales. 00:06:19
Y esas prestaciones se ponen aquí. 00:06:23
¿Vale? 00:06:25
Si no las pones, repito, es igual que esto. 00:06:27
Pero hombre, ya que haces un for es para usar esas prestaciones. 00:06:29
¿Vale? 00:06:32
Pues esas prestaciones, ¿qué son? 00:06:33
¿Qué son esas prestaciones? 00:06:35
Vale, lo que va en el primer espacio. 00:06:37
Ahí va una o más sentencias que tú quieres que se hagan 00:06:39
la primera vez que entras. 00:06:44
Y solo la primera vez. 00:06:46
Es lo que se llama... 00:06:48
No, un do, todo lo debe... 00:06:50
Una sentencia... 00:06:53
Una que se haga sí o sí. 00:06:54
Sí, pero no están dentro del bucle. 00:06:56
Se hacen solo la primera vez. 00:06:57
Nunca se vuelven a hacer jamás. 00:06:58
Son lo que se llaman sentencias de inicialización del bucle. 00:07:00
Es decir, sería el equivalente al... 00:07:04
Imagínate que tú tienes un while 00:07:06
y tú pones aquí esta sentencia. 00:07:08
In n igual a cero. 00:07:10
Imagínate que quieras hacer esto. 00:07:14
Bueno, pues el bucle for te permite 00:07:16
esa sentencia que tú quieres que se haga justo antes de entrar 00:07:19
que tú quieres que se haga justo antes 00:07:22
te permite ponerla aquí dentro. 00:07:24
Ya está, simplemente. 00:07:26
Entonces queda en línea, queda más bonito. 00:07:28
Te permite ponerla ahí si tú quieres. 00:07:30
Entonces, lo que tú pones aquí 00:07:32
entonces es... 00:07:34
Normalmente una sentencia... 00:07:36
Podrían ser varias, separadas por comas. 00:07:37
Podrían ser varias, separadas por comas. 00:07:39
Pero lo que tú pones ahí, normalmente, 00:07:41
el uso habitual es una sentencia 00:07:43
que se hace al entrar en el bucle 00:07:45
y solo esa vez. 00:07:47
Solo esa. 00:07:49
¿Vale? Solo esa. 00:07:50
Esta sentencia se ejecuta 00:07:53
justo antes de 00:07:55
entrar en el bucle. 00:07:59
Es que ni siquiera necesita entrar. 00:08:02
Se ejecuta justo antes de entrar. 00:08:04
No es como lo del do while, 00:08:06
que lo que hay dentro se ejecuta al entrar. 00:08:07
Se ejecuta antes de entrar. 00:08:09
Y solo se ejecuta una vez. 00:08:12
Ya está, solo una vez. 00:08:14
¿Vale? 00:08:16
Entonces, 00:08:17
Y solo se ejecuta una vez. 00:08:19
Ya está, solo una vez. 00:08:21
Es este efecto. 00:08:23
Es este efecto. 00:08:24
Es este mismo efecto. 00:08:25
Esto se ejecuta 00:08:26
justo antes de entrar 00:08:28
y solo una vez porque está fuera del bucle. 00:08:30
Pues es lo mismo. 00:08:32
Pero el for me permite ponerlo aquí. 00:08:34
¿Vale? 00:08:37
Entonces, en este caso, en el bucle while, 00:08:39
pues mira, es justo lo que yo tenía. 00:08:41
Quiero que esta sentencia se ejecute 00:08:43
justo antes de entrar 00:08:45
pero solo una vez, aquí dentro ya no. 00:08:47
Aquí dentro no. 00:08:49
Justo antes de entrar y solo una vez. 00:08:51
Ah, vale, pues venga. 00:08:53
Si estamos haciendo esto de arriba con un for, 00:08:55
pondría yo aquí 00:08:57
int count 00:08:59
igual a cero. 00:09:01
¿Vale? 00:09:05
Aquí es lo que hemos dicho que ponemos. 00:09:07
Ponemos la condición 00:09:09
que mientras se cumpla, entro. 00:09:11
Si queremos hacer lo mismo que arriba, 00:09:13
pues, por ejemplo, podría poner esto. 00:09:15
¿Vale? 00:09:19
Se me pone en rojo porque es que ya tengo 00:09:21
count declarado. 00:09:23
Entonces lo voy a comentar para que no se me vuelva loco. 00:09:25
Así, vale. 00:09:31
Y ahora, ¿este espacio 00:09:33
para qué sirve? 00:09:35
Si uno lo quiere usar, repito, si uno lo quiere usar. 00:09:37
Si no, no. 00:09:39
Si no lo dejas en blanco. 00:09:41
Lo que uno ponga ahí, 00:09:43
que puede ser una o muchas sentencias 00:09:45
separadas por comas, 00:09:47
no por punto y coma esta vez, 00:09:49
porque el punto y coma es para separar las tres zonas. 00:09:51
Para separar las tres zonas. 00:09:53
Pues lo que pongamos ahí es una o más sentencias 00:09:55
que se van a ejecutar 00:09:57
en cada iteración 00:09:59
y justo al final de las que hay dentro. 00:10:01
¿Vale? 00:10:03
Lo que uno ponga ahí se ejecuta 00:10:05
en cada iteración y justo al final de lo que hay dentro. 00:10:07
Imaginaos que yo metiera ahí, 00:10:09
por ejemplo, esto. 00:10:11
Porque la quiero inicializar 00:10:17
a cero o a... 00:10:19
a la que lo quiero inicializar, me da igual, a uno en este caso. 00:10:21
Esto, vale. 00:10:23
A lo que importa 00:10:25
es que esa sentencia se hace 00:10:27
antes de entrar, justo antes, 00:10:29
y solo esa vez, nunca más se vuelve a hacer. 00:10:31
¿Vale? 00:10:35
Imaginaos que yo aquí pongo 00:10:37
esto, por ejemplo. 00:10:39
Bueno, pues es una sentencia 00:10:41
perfectamente válida que puedo poner ahí. 00:10:43
Esa sentencia 00:10:45
se va a ejecutar 00:10:47
en cada iteración, no es como esta. 00:10:49
Que esta no, esta se ejecuta 00:10:51
solo una vez y al entrar. 00:10:53
Pues esta se va a ejecutar en cada iteración 00:10:55
y después de que se hayan hecho las anteriores. 00:10:57
Después de que se hayan hecho las anteriores. 00:10:59
Entonces esto que yo he puesto aquí 00:11:01
sería como 00:11:03
si yo dejara esto en blanco 00:11:05
y lo pusiera aquí, 00:11:07
por ejemplo. Bueno, esto precisamente no. 00:11:09
¿Vale? 00:11:11
Tendría el mismo 00:11:13
efecto. 00:11:15
¿Vale? 00:11:17
Lo que pasa es que aquí, si lo pongo aquí, 00:11:19
pues me evito ponerlo aquí. 00:11:21
Bueno, pues en este ejemplo que yo estoy haciendo arriba, 00:11:23
en este ejemplo del 00:11:25
bucle, esta sentencia 00:11:27
cont++ 00:11:29
se está haciendo 00:11:31
todo el rato 00:11:33
después de todo lo que hay dentro. 00:11:35
Todo el rato al final. 00:11:37
Pues podría meterlo aquí. 00:11:39
Podría meterlo aquí. 00:11:43
¿Vale? Podría meterlo ahí. 00:11:47
Y ahora ya, ¿qué me 00:11:49
queda por meter dentro del bucle? Pues 00:11:51
todo lo demás, esto. 00:11:53
¿Vale? 00:11:55
Bueno, pues por eso 00:12:01
normalmente uno 00:12:03
cuando ve 00:12:05
la sintaxis del for, la suele ver así. 00:12:07
No porque sea obligatorio poner esto, 00:12:09
sino porque es el uso habitual. 00:12:11
¿Vale? Pero a ver, vamos a recopilar. 00:12:13
El bucle for es un bucle 00:12:15
que igual que cualquier otro bucle 00:12:17
repite 00:12:19
un montón de veces lo que hay aquí dentro. 00:12:21
Eso está claro. Como cualquier otro 00:12:23
bucle, el bucle for lo que hace es 00:12:25
hacer muchas veces esto. 00:12:27
¿Cuál es la condición 00:12:29
que hace que yo vuelva a entrar 00:12:31
y vuelva a entrar y vuelva a entrar? 00:12:33
La condición es la que está ahí en medio. 00:12:35
Esa. Como si fuera 00:12:37
el while. Esa es la condición que hace que yo vuelva a entrar 00:12:39
y yo vuelva a entrar. Ya está. 00:12:41
No hay ninguna diferencia con el while. 00:12:43
Pero el for además me permite meter 00:12:45
una cosa aquí y otra aquí si es que 00:12:47
me interesa y me viene bien. 00:12:49
¿Qué tiene ese significado? 00:12:51
Lo que yo meto aquí es una sentencia 00:12:53
que quiero que se haga justo antes 00:12:55
y solo se va a hacer una vez. 00:12:57
Entonces suele ser cuando 00:12:59
un bucle necesita ser inicializado 00:13:01
con algunas variables, pues la sentencia de inicialización 00:13:03
pues me viene bien meterlas ahí. 00:13:05
Y las tengo ahí ya compactadas. 00:13:07
Y ya ve muy claro el que lo vea que eso va asociado al bucle. 00:13:09
Y luego si en ese bucle 00:13:11
veo que hay una sentencia 00:13:13
que se hace siempre 00:13:15
al final de la iteración, 00:13:17
siempre al final, 00:13:19
pues en lugar de ponerla aquí, la meto ahí. 00:13:21
Porque la sentencia 00:13:23
que yo meta ahí 00:13:25
se va a hacer siempre 00:13:27
en cada iteración 00:13:29
y cuando termine lo que hay aquí 00:13:31
al final 00:13:33
no entre medias, al final. 00:13:35
Entonces para este programa en particular 00:13:39
el for me queda más bonito y más compacto. 00:13:41
Porque yo ahí en la primera línea 00:13:43
ya empiezo a ver 00:13:45
desde que cont sea igual a 1 00:13:47
mientras sea menor o igual que n 00:13:49
e incrementándolo una vez cada vez, hace esto. 00:13:51
Entonces como que 00:13:53
esa sintaxis parece que queda más 00:13:55
clara. 00:13:57
Y me ha evitado la línea de arriba 00:13:59
y la línea de cont más más de abajo. 00:14:01
Entonces el for, aunque suele ser 00:14:11
es el aspecto que suele tener 00:14:13
que suele usarse para 00:14:15
aquí inicializar una variable, 00:14:17
aquí mientras la variable no llegue a una condición 00:14:19
y aquí incrementando la variable, aunque suele ser 00:14:21
el uso, el for se le puede meter ahí 00:14:23
lo que a uno le dé la gana. 00:14:25
Aquí se puede poner cualquier cosa que sea 00:14:27
una condición, cualquiera. 00:14:29
Aquí se puede poner cualquier conjunto 00:14:31
de sentencias, cualquiera, separadas por comas. 00:14:33
Y aquí también 00:14:35
se pueden poner muchas sentencias separadas por comas. 00:14:37
Pero claro, para qué quiero yo un for 00:14:39
así, una línea de for de arriba 00:14:41
enorme, para no entender el programa? 00:14:43
Pues no. 00:14:45
De hecho es que todo esto, si yo lo escribo 00:14:47
seguidito, lo podría meter ahí dentro. 00:14:49
Porque todo esto 00:14:51
se hace una vez por iteración 00:14:53
y al final de la nada. 00:14:55
Pues lo puedo todo ahí metido 00:14:57
seguido. 00:14:59
Pues vale, sí, pero vaya 00:15:01
programa asfaltan horrible. 00:15:03
La idea cuando uno hace un código es que quede claro 00:15:05
y se vea bien. 00:15:07
Bueno pues entonces 00:15:09
estas prestaciones del for que como digo 00:15:11
se pueden generalizar y poner uno 00:15:13
aquí lo que le dé la gana siempre y cuando sean sentencias 00:15:15
de Java, aquí lo que le dé la gana siempre 00:15:17
y cuando sea una condición y aquí lo que le dé 00:15:19
la gana siempre y cuando sean sentencias de Java 00:15:21
el for, el uso 00:15:23
que se le suele dar es un uso 00:15:25
concreto porque para ese 00:15:27
uso es muy práctico. 00:15:29
Y es cuando uno de partida 00:15:31
sabe que hay algo que se va a ejecutar 00:15:33
un número concreto de veces. 00:15:35
Por ejemplo 00:15:37
vamos a hacer aquí 00:15:39
una clase 00:15:41
que sea ejemplo form 00:15:43
para que sea específico 00:15:45
del form. 00:15:47
Pues venga, imaginaos 00:15:57
que aquí hacemos 00:15:59
un código que sea 00:16:01
programa 00:16:03
que dado un número 00:16:09
N mayúscula 00:16:11
solicite 00:16:17
tantas cadenas 00:16:19
como número 00:16:23
se haya introducido 00:16:25
para cada 00:16:29
cadena 00:16:31
para recordar el charlat ese que mencionamos 00:16:33
y para cada 00:16:39
cadena 00:16:41
muestre 00:16:43
la inicial 00:16:45
en mayúscula 00:16:47
por ejemplo, yo que se 00:16:49
por hacer algo que no sea demasiado tonto. 00:16:51
¿Vale? 00:16:53
Entonces lo primero que hace el programa es pedir un número 00:16:55
Pues entonces cuando va a pedir un número vamos a ponerle 00:16:59
un escáner. 00:17:01
Venga, introduce 00:17:05
un número entero, esta parte ya está hecha. 00:17:07
Y ahora ya es cuando 00:17:09
decimos, vale, ahora 00:17:11
tiene que hacer N mayúscula 00:17:13
a veces, solicitar 00:17:15
nombre, 00:17:17
poner inicial en mayúscula, mostrar inicial en mayúscula 00:17:19
entonces ya es un bucle 00:17:21
que de partida 00:17:23
antes de arrancar sabemos las veces que se va a hacer 00:17:25
que es N mayúscula a veces 00:17:27
ya lo sabemos de partida. 00:17:29
Pues cuando estamos en esa situación 00:17:31
que ya sabemos que hay un bucle que de partida 00:17:33
se va a hacer N mayúscula a veces 00:17:35
el bucle for nos viene 00:17:37
estupendamente porque podemos hacer 00:17:39
esta sintaxis que es la habitual, la que lo vais 00:17:41
a encontrar en todas partes 00:17:43
que es esta. 00:17:45
Primero me declaro una variable i 00:17:47
que se la suele llamar i 00:17:49
por lo de índex o índice 00:17:51
se le llama el índice del bucle. 00:17:53
Mientras esa variable i sea 00:17:55
menor que N mayúscula 00:17:57
e incrementando N 00:17:59
después de cada iteración, bla bla bla 00:18:01
N mayúscula no, no. 00:18:05
Esta es la sintaxis 00:18:09
que vais a ver en todas partes del bucle for 00:18:11
porque tiene que ser así, obligatoria, no 00:18:13
uno pone aquí lo que le dé 00:18:15
la gana, pero claro 00:18:17
lo que le dé la gana, que haga lo que él quiere 00:18:19
y esto es muy práctico 00:18:21
porque esto recoge la situación de 00:18:23
un bucle for 00:18:25
que se ejecuta cuantas veces 00:18:27
N mayúscula 00:18:29
porque para la primera i es 0 00:18:31
para la segunda es 1 porque se va incrementando 00:18:33
para la siguiente es 2, para la siguiente es 3 00:18:35
cuando ya 00:18:37
sea N ya no va a entrar 00:18:39
entra para la 0, para la 1, para la 2 00:18:41
entonces este bucle 00:18:43
me declara una variable, empieza abriendo 0 00:18:45
la incrementa una vez 00:18:47
en cada iteración 00:18:49
y mientras no sea N 00:18:51
no termina 00:18:53
luego este es un bucle que lo que yo 00:18:55
meta aquí se va a hacer 00:18:57
exactamente N veces 00:18:59
bueno, pues para la situación 00:19:01
esa, situación en la cual 00:19:03
sabemos que lo que queremos repetir 00:19:05
sabemos ya de partida las veces 00:19:07
que se va a hacer, pues cascamos 00:19:09
esto y ya está 00:19:11
me olvido de condiciones de while y de todo 00:19:13
me olvido de todo 00:19:15
porque esto es un bucle que se va a hacer 00:19:17
exactamente N veces 00:19:19
por el uso que he hecho de la i 00:19:21
por el uso que he hecho de la i 00:19:23
y el bucle for se suele usar sobre todo para eso 00:19:25
se usa para esto, por eso que siempre lo veis así 00:19:27
pero claro, uno lo puede 00:19:29
usar para lo que le dé la gana 00:19:31
cambiando estas cosas, para lo que le dé la gana 00:19:33
pero sobre todo se usa 00:19:35
para plantarlo 00:19:37
cuando queremos que algo se haga un número 00:19:39
de veces que ya conozco de partida 00:19:41
que ya conozco de partida 00:19:43
y que no depende de lo que luego el usuario vaya metiendo 00:19:45
por dentro 00:19:47
vale, y la variable i 00:19:49
es la que se la suele llamar el índice del bucle 00:19:51
porque es una variable que la primera vez vale 0 00:19:53
la siguiente vale 1 00:19:55
la siguiente vale 2, claro que se va incrementando 00:19:57
vale, entonces puedo usar 00:19:59
esa variable i si quiero 00:20:01
por ejemplo, vamos a irla mostrando aquí 00:20:03
índice del bucle 00:20:05
índice del bucle 00:20:07
índice del bucle 00:20:09
para ir viendo por qué valores va pasando 00:20:11
la podemos ir mostrando aquí 00:20:17
esa variable la puedo usar yo aquí dentro 00:20:19
la puedo usar yo aquí dentro para hacer lo que me dé la gana 00:20:21
esta variable i empieza haciendo 0 y se va incrementando 00:20:23
la puedo usar para lo que quiera 00:20:25
vale 00:20:27
pues bueno, ¿qué queríamos hacer dentro de este bucle? 00:20:29
¿qué queríamos hacer num veces? 00:20:31
pues lo que queríamos hacer num veces 00:20:33
era solicitar un nombre 00:20:35
introduzca nombre 00:20:45
cadena, nombre, lo que queráis 00:20:49
lo leemos 00:20:51
como es un stream 00:20:53
vale 00:21:03
entonces vamos a recordar esto 00:21:05
para usar esto 00:21:07
vamos a utilizarlo para recordar 00:21:11
lo poquito que hemos mencionado 00:21:13
de las variables stream 00:21:15
que es que al ser variables objetos son diferentes 00:21:17
a las numéricas 00:21:19
y pueden hacer cosas 00:21:21
como por ejemplo 00:21:23
por ejemplo 00:21:25
si yo llamo 00:21:27
a esto charAt y le doy una posición 00:21:29
me devuelve el carácter 00:21:31
en esta posición 00:21:33
entonces si yo 00:21:35
muestro esto 00:21:37
claro, como tengo error de compilación 00:21:55
ya no me coge 00:21:57
el este 00:21:59
vamos a quitarlo 00:22:01
bueno, pues nada 00:22:05
ya está tonto 00:22:07
vale, pues de una variable stream 00:22:29
si llamábamos a esto 00:22:31
me devolvía el carácter 00:22:33
en la posición que yo le dejara aquí 00:22:35
asumiendo que la primera 00:22:37
es la cero 00:22:39
entonces 00:22:41
devuelvo carácter 00:22:53
en posición 00:22:55
cero 00:22:57
pero me han dicho que el carácter en posición 00:22:59
cero directamente no 00:23:01
sino la mayúscula, pero bueno 00:23:03
en el código ASCII hay una diferencia relativa 00:23:05
entre las mayúsculas y las mayúsculas, se lo sumo y ya está 00:23:07
a ver 00:23:09
la tabla ASCII 00:23:13
en el código 00:23:19
ASCII este 00:23:21
aquí por ejemplo 00:23:27
si la minúscula 00:23:29
A es 97 00:23:31
y la mayúscula 00:23:33
está antes, hay que restar 00:23:35
pues de 65 a 97 00:23:39
van 32 00:23:41
entonces tendríamos que restarle 32 00:23:43
si es que he calculado mal 00:23:45
porque si le restamos 32 a 98 00:23:47
me sale 66 que es la B 00:23:49
etc 00:23:51
vale, pues entonces 00:23:53
unidad 00:23:55
menos 32 00:23:57
hemos dicho 00:23:59
y para asegurarnos 00:24:03
porque esto al hacer un menos 00:24:05
con un numerito 00:24:07
va a interpretarlo como que ya es 00:24:09
número entero, entonces para que haga el casting a char 00:24:11
yo creo que va a haber que hacer el casting a char 00:24:13
vamos a probarlo así y ya está 00:24:15
a ver, pero volvemos a lo que nos importa 00:24:19
lo que nos importa es 00:24:21
que estamos en un bucle 00:24:23
que ya sabemos de partida las veces que se va a ejecutar 00:24:25
se va a ejecutar estas veces 00:24:27
lo sé de partida antes de empezar 00:24:29
pues si lo sé de partida antes de empezar las veces que se va a ejecutar 00:24:31
puedo cascar esto directamente 00:24:33
entendiendo lo que estoy 00:24:35
haciendo obviamente 00:24:37
y luego además esta variable i 00:24:41
si quiero utilizarla dentro para hacer cosas 00:24:43
pues la utilizo, si la quiero utilizar 00:24:45
sé que es una variable que empieza variando 0 00:24:47
y luego ya es 1 00:24:49
cuando pasa la primera iteración 00:24:51
si la quiero usar, la uso 00:24:53
en el ejercicio de aquí 00:24:55
por ejemplo 00:24:57
si yo hago esto con un for 00:24:59
si yo hago esto con un for 00:25:01
este cont 00:25:03
que hace el papel de la i, lo estoy usando aquí dentro 00:25:05
no pasa nada, lo uso aquí 00:25:07
he hecho esto mismo con un for 00:25:09
lo que pasa es que en lugar de i 00:25:11
lo he llamado cont 00:25:13
pero es lo mismo 00:25:15
vale, entonces 00:25:17
vamos a ejecutar esto para ver si hay que 00:25:19
hacer el casting a char, pero yo creo que sí 00:25:21
vamos a decirle que lo ejecute 00:25:25
3 veces para que no sea muy largo 00:25:27
venga, número entero 00:25:29
3 veces 00:25:31
ya hemos liado 00:25:33
vale 00:25:35
vale 00:25:39
me he salido del string 00:25:43
porque no me ha pedido 00:25:45
el error de que después de un next int 00:25:47
me hace un next line 00:25:49
y no lo he limpiado, verdad 00:25:51
después del next int, del numerito 00:25:53
me viene un next line 00:25:55
entonces se queda con el salto de línea 00:25:57
como si fuera el nombre, cuando se queda con el carácter de posición 0 00:25:59
no hay posición 0 00:26:01
porque se ha quedado con el salto de línea 00:26:03
entonces 00:26:05
tengo que limpiar 00:26:11
esto 00:26:13
agrandar un poco 00:26:17
sí 00:26:19
vale 00:26:23
vale, o sea, leo el numerito 00:26:25
limpio el salto de línea 00:26:27
porque es que luego voy a acelerar una línea 00:26:29
entonces cuidado porque si no 00:26:31
esta se va a quedar con el salto de línea 00:26:33
y ahora ya, bucle que se ejecuta 00:26:35
none veces exactamente 00:26:37
vale, porque para eso 00:26:41
he definido el for de esta manera, una variable que empieza 00:26:43
valiendo 0 00:26:45
la voy a ir incrementando en cada iteración 00:26:47
y mientras no llegue a none 00:26:49
entro, luego este bucle 00:26:51
se va a ejecutar none veces, que es lo que quería 00:26:53
es este bucle, primero va a mostrar el índice 00:26:55
luego me va a pedir el nombre 00:26:57
y luego ya 00:26:59
se va a quedar con el carácter 00:27:01
en posición 0 y le va a restar 32 00:27:03
vamos a ver ahora que nos hace 00:27:05
venga 00:27:09
introduzca número entero, 3 00:27:11
vale 00:27:13
índice del bucle, esa es la primera iteración 00:27:15
índice del bucle 0 00:27:17
estamos en la primera iteración y es igual a 0 00:27:19
nombre 00:27:21
pepe, vale, me ha mostrado 00:27:23
80, que es el número 00:27:25
entero que codifica la P mayúscula 00:27:27
entonces le tengo que hacer el casting a chat 00:27:29
y a pañao 00:27:31
vamos a volver a ejecutarlo 00:27:43
venga, dos veces 00:27:49
índice del bucle 0, primera vez que entramos 00:27:51
nombre, vale 00:27:53
muy bien, siguiente vez 00:27:55
que entramos, índice del bucle 1 00:27:57
ahora ahí se ha incrementado 00:27:59
y se ha incrementado, entonces ahora estamos 00:28:01
índice del bucle 1, introduzca nombre 00:28:03
vale 00:28:05
y ya está, se acabó, porque le he dicho 00:28:07
dos veces 00:28:09
vale 00:28:11
vale, pues este 00:28:17
es el uso habitual del bucle 00:28:19
for, el uso habitual, pero 00:28:21
quedaos con que aquí 00:28:23
podemos poner lo que queramos y hay veces 00:28:25
que es muy práctico y muy útil 00:28:27
usar el bucle for poniendo aquí 00:28:29
más condiciones, aquí más sentencias 00:28:31
otra condición más compleja 00:28:33
lo que sea, pero bueno, este es un uso muy 00:28:35
habitual, para forzar 00:28:37
que un bucle se ejecute exactamente 00:28:39
el número de veces que yo le ponga 00:28:41
aquí 00:28:43
vale 00:28:47
y aprovechad también 00:28:49
este ejercicio para recordar 00:28:51
que de una cadena se puede sacar el carácter 00:28:53
en cualquier posición, lo puedo sacar 00:28:55
si lo necesito 00:28:57
a través de esto 00:28:59
vale 00:29:05
pues con el ejercicio que estábamos antes entonces 00:29:07
efectivamente que yo había hecho con un while 00:29:09
es un bucle que sé 00:29:11
que se va a ejecutar en la mayúscula veces 00:29:13
pues tengo 00:29:15
esta sintaxis 00:29:17
me da igual 00:29:19
que lo llaméis in, que conto 00:29:21
vale 00:29:37
bueno, los ejercicios 00:29:43
que vienen ahora no son fáciles 00:29:45
no son fáciles 00:29:47
pero 00:29:49
arrancada 00:29:55
a intentarlos 00:29:57
tenemos 00:29:59
todo lo que necesitamos, todos los recursos que necesitamos 00:30:01
para poder hacerlos, los tenemos todos 00:30:03
ahora se trata de 00:30:05
de componerlo 00:30:07
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
31 de octubre de 2023 - 13:44
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
30′ 12″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
576.33 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid