Saltar navegación

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

Clase 11-12-23 - 3 - 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 18 de diciembre de 2023 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues estábamos en el caso 1 del menú, 00:00:00
el caso 1 habíamos dicho, el caso 1 tiene dos posibilidades, 00:00:06
o ya existe una contraseña previa o no existe, 00:00:13
si existe hago una cosa, si no existe hago otra, 00:00:17
entonces aquí distinguir si existe o no existe, 00:00:20
es tan fácil como inicialmente la contraseña vacía 00:00:24
inicialmente vacía y ahora ya en mi caso 1 00:00:29
distingo en función de esa contraseña, que es vacía 00:00:34
hago una cosa, que no lo es hago otra, 00:00:38
vale, pues estábamos en el caso es vacía, 00:00:41
si es vacía que tengo que hacer, pedirla, 00:00:43
vale, si es vacía la pido, 00:00:46
pero como no me vale cualquiera, 00:00:48
estábamos en como no me vale cualquiera, 00:00:49
pues aquí un bucle del que no salgo 00:00:52
hasta que esta password no convierta este boolean en true, 00:00:55
hasta que este boolean no lo convierta en true, 00:01:02
de ahí no salgo, y para convertirlo en true 00:01:05
necesitamos contar mayúsculas, minúsculas y cifras 00:01:08
y luego ya este boolean de aquí será simultáneamente 00:01:12
este contado mayor o igual que 1 00:01:16
y además este mayor o igual que 1 00:01:18
y el otro mayor o igual que 1, esto de aquí, 00:01:20
bueno, pues lo que nos faltaba para este if del case 00:01:28
lo que nos faltaba era hacer esta cuenta, 00:01:33
esta cuenta, entonces tenemos que recorrer 00:01:36
todos y cada uno de los caracteres de password, 00:01:39
entonces recorrer los caracteres de un string, 00:01:42
lo que hacíamos con un for, 00:01:45
desde la posición 0 a la última 00:01:47
que la podíamos obtener con el método led 00:01:50
y ahora cada carácter charad, 00:01:52
y ahora para cada carácter que es mayúscula, 00:01:54
incremento contador de mayúscula, 00:01:56
que es minúscula, incremento contador de minúscula, 00:01:58
que es cifra, incremento contador de cifra, 00:02:01
pues eso, un bucle for que recorra 00:02:03
todos y cada uno de los caracteres del password, 00:02:06
o sea un string, ya hemos hecho en otros ejercicios, 00:02:10
si tenemos que recorrer sus caracteres, 00:02:13
que es un for que va carácter por carácter 00:02:17
haciendo con él lo que toque, 00:02:20
en este caso lo que toca es mirar a ver 00:02:21
si es mayúscula, minúscula o cifras y contar, 00:02:24
pues venga, vamos a recorrer 00:02:28
todos y cada uno de los caracteres de password, 00:02:30
pues venga, empezamos, 00:02:33
desde el carácter de posición 0, 00:02:36
mientras i sea menor que 00:02:39
password.length, 00:02:44
incrementando i, 00:02:50
estas son todas las posiciones, 00:02:53
password.length es la longitud de la cadena, 00:02:56
si la cadena tiene 4, 00:02:59
las posiciones son 0, 1, 2 y 3, 00:03:01
por eso aquí ponemos estrictamente menor, 00:03:05
si password.length es 5, 00:03:07
porque el string tiene 5, 00:03:09
las posiciones van de 0, 1, 2, 3 y 4, 00:03:11
luego este i va pasando por todas las posiciones 00:03:14
de los caracteres de este, 00:03:19
posición 0, posición 1, 00:03:22
ah, y ahora con cada posición ¿qué hacemos? 00:03:24
Bueno, pues el carácter del string 00:03:27
en la posición i es este, 00:03:30
este es el carácter del string en la posición i, 00:03:34
ese es el carácter, 00:03:37
pues ¿qué tenemos que hacer con este carácter? 00:03:39
Mirar a ver si es mayúscula, 00:03:41
si lo es, incrementamos contador de mayúscula, 00:03:43
mirar a ver si es minúscula, 00:03:46
si lo es, incrementamos contador de minúscula, 00:03:48
y mirar a ver si es cifra, 00:03:50
si lo es, incrementamos contador de cifra, 00:03:51
y ya está. 00:03:54
Y ahora viene, ¿cómo miramos a ver si es mayúscula? 00:03:56
Hombre, no tiene sentido que hagamos un or gigante, 00:03:59
si password.id es igual a o es igual a b o es igual a c 00:04:02
y así todo el alfabeto, 00:04:07
¿que tenemos ganas de escribir? 00:04:08
Pues sí, podríamos hacer 00:04:10
esto con todo el alfabeto, ¿no? 00:04:13
Si el carácter de la posición i es igual a 00:04:15
ah, ¿dónde tengo la esta? 00:04:19
Oh, solo voy a girar dos veces, no os asustéis. 00:04:21
Y si así me planto dentro del if, 00:04:36
me planto todo el alfabeto en mayúscula, 00:04:38
pues sí, es una condición válida. 00:04:41
Es la condición de ver si es letra mayúscula, 00:04:43
me planto todo el alfabeto en mayúscula. 00:04:46
Pues sí, vale, vale. 00:04:48
Pero hombre, menudo programa, ¿eh? 00:04:49
Con una condición aquí, gigante. 00:04:51
Afortunadamente tenemos la tabla ASCII 00:04:55
y nosotros sabemos que cada carácter 00:05:01
se corresponde con el número entero 00:05:03
en la posición correspondiente, 00:05:05
la tabla ASCII que estaba ahí. 00:05:07
Entonces, la tabla ASCII es esta de aquí. 00:05:08
Entonces, el carácter será letra mayúscula 00:05:17
si es mayor o igual que 65 00:05:19
y menor o igual que 90. 00:05:24
Si es mayor o igual que 65 00:05:27
y menor o igual que 90, es mayúscula. 00:05:29
Entonces es más fácil poner esa condición 00:05:32
que poner igual a A o igual a B 00:05:34
o igual a C o igual a D. 00:05:36
Mucho más fácil, ¿vale? 00:05:39
Y eso lo podíamos hacer así 00:05:41
gracias a que los char 00:05:43
son también números enteros 00:05:46
según la correspondencia de la tabla ASCII. 00:05:48
O sea, un char 00:05:50
lo puedo ver también como número entero, 00:05:52
según me interese, según me vaya dando la gana. 00:05:54
Si lo veo como char, será esto con comillas simples. 00:05:57
Si lo veo como número entero, será este número entero. 00:06:01
Bueno, pues entonces hemos dicho 00:06:05
que la mayúscula empieza en 65 y acaba en 90. 00:06:06
65 y 90. 00:06:10
Pues esta condición tan complicada 00:06:12
es mucho más fácil de ponerla así. 00:06:13
Si este carácter, 00:06:17
ahora lo voy a interpretar como entero, 00:06:18
que puedo sin problema, 00:06:20
es mayor o igual que 65 00:06:21
y además de ser mayor o igual que 65 00:06:24
es menor o igual que 90, hemos dicho, 00:06:29
pues así mucho más fácil esa condición. 00:06:34
¿Vale? 00:06:38
Si este carácter, 00:06:39
interpretado como entero, porque me da igual, 00:06:40
lo puedo interpretar como entero, como char, 00:06:42
me da lo mismo, 00:06:44
es mayor o igual que este 00:06:45
y menor o igual que este, 00:06:46
entonces es mayúscula. 00:06:47
Pues entonces incremento 00:06:48
el contador de mayúscula. 00:06:51
¡Hala! 00:06:54
Entonces, en cada iteración del bucle FOR 00:06:56
voy mirando cada uno. 00:06:58
El de posición 0, que es mayúscula, 00:06:59
una mayúscula más. 00:07:02
El de posición 1, que es mayúscula, 00:07:04
otra mayúscula más. 00:07:06
El de posición 2, que es mayúscula, 00:07:07
otra mayúscula más. 00:07:09
Y así cuento todas las mayúsculas 00:07:10
del password, todas las caras, ¿vale? 00:07:13
Y esto mismo lo puedo hacer con minúsculas 00:07:15
y con cifras. 00:07:17
Pues hala, me planto ahí un Elseif. 00:07:19
Y ahora, que no es mayúscula, 00:07:27
pues voy a ver si es minúscula. 00:07:30
Pues si es minúscula, 00:07:31
será una condición parecida, 00:07:32
pero en este caso las minúsculas 00:07:34
están entre 97 y 122. 00:07:35
Pues que esta no se da 00:07:40
porque no es mayúscula. 00:07:41
Vamos a ver si se da esta otra. 00:07:42
Vamos a ver si se da esta otra. 00:07:48
Mayor o igual que 97 00:07:50
y menor o igual que 122. 00:07:54
Pues si no se da la anterior, 00:07:58
pero se da esta otra, 00:08:00
pues entonces ya tengo una minúscula. 00:08:02
Hala, a sumar. 00:08:05
Que tampoco se da esta. 00:08:08
Y se da esta otra. 00:08:11
Y es que esté comprendido, 00:08:15
los números están, 00:08:17
¿dónde están los números? 00:08:18
Los he perdido aquí. 00:08:18
Entre 48 y 57. 00:08:20
Pues que está comprendido entre 48 y 57, 00:08:23
entonces es cifra. 00:08:26
Es cifra, ¿no? 00:08:28
Estas son las cifras decimales, 00:08:28
no hay más que esas. 00:08:30
No hay más cifras decimales que esas. 00:08:30
48 y 57. 00:08:34
Pues que es mayor o igual que 48 00:08:39
y simultáneamente menor o igual que 57. 00:08:43
Pues entonces es cifra. 00:08:48
Pues vamos a incrementar 00:08:52
el contador de cifras. 00:08:54
Y aquí en el ELSES 00:08:57
que no hace falta ni que lo ponga, 00:08:58
porque si no es ni mayúscula, 00:09:00
ni minúscula, ni cifras, 00:09:03
no hay nada que contar. 00:09:05
Es otro carácter. 00:09:06
Dólar, un lo que sea, es otro carácter. 00:09:08
No hay nada que contar. 00:09:10
Entonces no hace falta ni que ponga el ELSES, 00:09:11
el ELSES es opcional. 00:09:12
Vale, pues ya está. 00:09:14
Este bucle FOR me está contando 00:09:15
para todas y cada una de las posiciones 00:09:19
en esa password me está contando. 00:09:21
Si son mayúscula me la cuenta. 00:09:23
Si es minúscula me la cuenta. 00:09:25
Y si es cifra me la cuenta. 00:09:26
Y así con todas. 00:09:28
Entonces cuando este bucle FOR ha terminado, 00:09:29
tengo el número de mayúsculas de la password, 00:09:31
el número de minúsculas y el número de cifras. 00:09:33
Este bucle FOR solo tiene LIF. 00:09:36
Por eso he quitado la llave, 00:09:39
porque todo esto es una única sentencia. 00:09:40
Una única. 00:09:44
Entonces como solo hay una, 00:09:45
el FOR solo tiene una adentro, 00:09:46
puedo no poner las llaves. 00:09:48
Solo tiene una adentro. 00:09:49
Vale, pues cuando ese FOR ha terminado, 00:09:51
que es aquí en este punto, 00:09:54
cuando ese FOR ha terminado, 00:09:55
ya puedo decir la condición de válida. 00:09:57
Mayor o igual que uno y 00:10:01
mayor o igual que uno y 00:10:02
mayor o igual que uno. 00:10:04
Si los tres son mayores o iguales que uno, 00:10:05
cumple la condición de 00:10:08
al menos una mayúscula, 00:10:09
al menos una minúscula, 00:10:10
al menos una cifra. 00:10:11
Y entonces ahora ya, 00:10:14
cuando el bucle WHILE vuelva arriba, 00:10:15
que es válida, 00:10:18
esto será TRUE. 00:10:19
Al ser eso TRUE, 00:10:21
esto será FALSE, 00:10:22
porque es el negado, 00:10:24
eso será FALSE, 00:10:26
y ya no entrará más en el WHILE, 00:10:27
ya la contraseña será válida. 00:10:28
O sea, llegados aquí, 00:10:30
la contraseña es válida. 00:10:32
Vale, pues ya está, ya se... 00:10:33
La contraseña que hemos leído 00:10:35
es válida, ¿vale? 00:10:37
La que hemos leído, la hemos validado, 00:10:40
ya es válida, pues ahí se queda. 00:10:42
¿Vale? ¿Entendéis ese bucle? 00:10:45
Un bucle, mientras no sea válida, 00:10:48
la leo. 00:10:49
Y miro a ver. 00:10:51
Que no es válida, vuelvo a leerla. 00:10:53
Y miro a ver. 00:10:55
Que es válida, ya no vuelvo a leerla. 00:10:56
Ya Password se queda con el valor que he leído. 00:10:58
El último que he leído, y ahí se queda. 00:11:01
Y entonces ya Password 00:11:03
habrá dejado de valer esto, 00:11:05
que valía inicialmente, 00:11:09
cuando arrancamos el programa, 00:11:10
ya habrá dejado de valer eso, 00:11:12
y habrá pasado a valer 00:11:14
el valor que le hemos dado ahí. 00:11:16
El que le hemos dado ahí. 00:11:18
Que ha resultado ser válido el que hemos dado ahí. 00:11:19
Entonces, la siguiente vez que se le dé acción 1, 00:11:22
ya no va a entrar en ese if. 00:11:25
Pasa. 00:11:29
La siguiente vez que se le dé acción 1, 00:11:31
ya no entra aquí. 00:11:32
Porque ya existe contraseña, ya existe. 00:11:34
¿Vale? 00:11:38
Bueno, pues esta parte entendida. 00:11:41
Si la contraseña está vacía, 00:11:43
es la primera vez que entramos en la opción 00:11:45
de establecer modificar. 00:11:48
Pedimos contraseña nueva hasta que sea válida, ya está. 00:11:50
Y ahora, que hemos dado al case 1 este, 00:11:55
que al case 1 le hemos dado 00:11:59
con la contraseña ya establecida 00:12:02
porque es la segunda, tercera o cuarta vez 00:12:03
que damos al 1. 00:12:06
Pues si es la segunda, tercera o cuarta vez, 00:12:07
entonces estamos aquí, 00:12:10
en el else de este if. 00:12:11
Estamos en el else de este if. 00:12:13
Esta llave que cerraba, 00:12:15
porque tengo aquí llaves de sobra, ¿no? 00:12:16
Porque aquí mi forno tiene... 00:12:21
Esta llave me sobra entonces, ¿no? 00:12:29
Ah, claro, me estaba faltando una llave. 00:12:34
Vale, entonces esta es la del while. 00:12:36
Vale, esta es la del while. 00:12:41
Y esta es la del if. 00:12:42
Que tengo aquí mi else, vale. 00:12:50
Pues en este caso ya hay contraseña previa. 00:12:53
Si entramos por aquí es porque ya hay 00:12:55
contraseña establecida. 00:12:58
Entonces, aquí en cualquier caso 00:13:04
ya hay contraseña establecida. 00:13:06
En cualquier caso, esta opción es para poner una nueva. 00:13:08
Luego todo este rollo, todo esto, 00:13:11
le haré un copy-paste, 00:13:16
porque también es para hacer una nueva. 00:13:19
Pero antes de eso, 00:13:20
tengo que pedirle la contraseña al usuario. 00:13:23
Pues está quedando un código largo 00:13:25
porque no lo estoy sacando a funciones 00:13:27
para no irlo liando y nada. 00:13:28
Lo importante es que vayáis viendo 00:13:30
lo que vamos haciendo. 00:13:31
Queda un código largo, 00:13:32
queda mucho más fácil si yo saco 00:13:34
eso a una función donde le paso una contraseña, 00:13:36
o sea, si todo esto lo saco a una función, 00:13:39
todo este código de aquí, 00:13:43
lo saco a una función que me devuelva 00:13:46
ya el boolean directamente, true o false, 00:13:47
pues me va a quedar más claro el ejercicio. 00:13:50
Me va a quedar más claro. 00:13:52
Pero bueno, ahora mismo lo que importa 00:13:54
es que entendamos el código que estamos haciendo, 00:13:57
más que cómo lo estamos organizando. 00:14:01
Lo puedo organizar, repito, sacándolo fuera 00:14:03
y se queda el programa un poquito más bonito. 00:14:06
Pero en lo que importa es entendemos 00:14:08
lo que estamos haciendo. 00:14:09
Bueno, pues en este caso, en el ELSE, 00:14:10
ya hay contraseña establecida. 00:14:12
Entonces, antes de pasar a pedirle 00:14:13
la nueva contraseña y hacer lo mismo 00:14:17
que hemos hecho arriba, que es lo mismo, 00:14:19
idéntico, clavado, lo mismo, 00:14:20
hay que decirle, introduzca contraseña antigua. 00:14:23
¿Vale? 00:14:26
Y aquí no estaba muy claro el enunciado. 00:14:27
Entonces, podíais haber optado 00:14:31
por cualquiera de las dos cosas que es válida, 00:14:33
porque aquí dice, si ya se ha establecido 00:14:35
una contraseña, ah, vale, no, es verdad, 00:14:40
es que esto lo cambié porque no me gustaba, 00:14:43
vale, el programa pedirá de forma repetida, 00:14:45
repetidamente, la contraseña vieja. 00:14:50
Y ahí se va a quedar, ahí se va a quedar 00:14:53
hasta que el usuario no escriba la contraseña antigua. 00:14:56
Y cuando ya la ha escrito, ya sale de ese bucle 00:14:59
y ya hace todo lo anterior, de pedir la nueva, 00:15:01
validarla, etcétera. 00:15:04
¿Vale? 00:15:06
Pues entonces, en esta parte, tendremos que hacer, 00:15:07
repito, todo esto de aquí otra vez, 00:15:10
pero antes hay que decirle, 00:15:12
introduzca la contraseña anterior. 00:15:14
Porque ya hay contraseña establecida, 00:15:21
entonces para modificarla le tenemos que pedir la antigua. 00:15:22
Y solo le dejamos modificar si nos da la antigua, claro. 00:15:27
Entonces, esto lo podríamos guardar, por ejemplo, 00:15:31
en una variable string. 00:15:37
Vale, y ahora, esta es la password que él nos da, 00:15:50
y que tenemos que verificar nosotros 00:15:54
que es igual a la que ya hay establecida. 00:15:56
Y ahí tenemos que estar en un bucle, 00:15:59
ahí enganchados de forma repetida todo el rato, 00:16:00
mientras la password leída sea diferente 00:16:04
de la que ya está establecida. 00:16:07
Luego aquí nos quedamos enganchados en un bucle, 00:16:09
aquí nos quedamos metidos, 00:16:12
nos quedamos ahí todo el tiempo que haga falta, 00:16:18
mientras esta password sea distinta 00:16:22
de la que ya hay establecida de antes. 00:16:25
Esta, que ya la hemos establecido antes 00:16:28
porque si hemos entrado aquí es porque es distinta del vacío, 00:16:33
pero ya está de antes. 00:16:37
Entonces, aquí nos quedamos hasta los restos 00:16:39
mientras la password que él me ha dado 00:16:41
sea distinta de la password mía. 00:16:45
Y distinta significa así, ¿vale? 00:16:53
Ahora cambiamos el rojo. 00:16:58
Mientras la contraseña que yo he leído 00:17:00
no sea igual a la password que ya tengo, 00:17:03
ahí todo el rato, 00:17:07
pidiendo y pidiendo y pidiendo y pidiendo ahí todo el rato. 00:17:08
¿Vale? Esa es la idea. 00:17:11
Ahora arreglamos eso. 00:17:12
Y luego ya, cuando ya hemos salido de aquí, 00:17:14
cuando ya hemos salido de este while 00:17:17
es porque por fin metieron la buena, 00:17:18
porque por fin la metieron. 00:17:20
Pues entonces ahora es cuando ya puedo plantar 00:17:22
y pegar el código de arriba, 00:17:24
que es el que me pide una contraseña nueva, 00:17:26
la valida y cuando ya la tiene se da password. 00:17:28
¿Vale? 00:17:31
Vale. 00:17:35
Por eso aquí, claro, sería mucho más bonito 00:17:36
si sacamos todo eso a una función, 00:17:38
porque es que ahora voy a tener que copiar y pegar 00:17:40
eso abajo otra vez y va a quedar muy grande. 00:17:42
Pero bueno. 00:17:44
Vale, pero vamos a arreglar antes esto. 00:17:45
Este bucle que está aquí todo el rato, 00:17:46
todo el rato, claro, 00:17:49
es normal. 00:17:51
Yo digo, claro, ¿cómo no voy a poner esto en rojo? 00:17:52
¿Por qué me lo pone en rojo? 00:17:54
Claro, porque la contraseña 00:17:57
no la he declarado antes. 00:17:59
Esta variable no está declarada antes. 00:18:01
Antes de usar una variable, 00:18:02
antes de usarla, tiene que estar declarada. 00:18:03
Y aquí no, aquí la he declarado yo aquí debajo, 00:18:06
porque claro, yo he puesto la sentencia 00:18:08
y luego después he decidido que la he metido en un bucle 00:18:10
para que lo haga muchas veces. 00:18:13
Entonces, al decidir meterlo en un bucle, 00:18:14
en ese momento, he pasado a usarla antes. 00:18:16
Entonces, como he pasado a usarla antes, 00:18:21
yo digo, ah, claro, una variable 00:18:22
antes de usarla tiene que estar declarada. 00:18:24
Cosa impepinable. 00:18:28
Claro, pues no pasa nada, la declaramos fuera. 00:18:29
La declaramos fuera, 00:18:34
porque una variable antes de usarla 00:18:35
tiene que estar declarada. 00:18:37
Vale. 00:18:39
Entonces, ahora ya de aquí quitamos esto. 00:18:42
Aún así, ya sabíamos que aunque yo la declarara fuera, 00:18:46
se iba a seguir quejando el compilador, ¿no? 00:18:51
Por lo de siempre, se sigue quejando 00:18:55
porque la primera vez que llega al Guile 00:18:57
no tiene ningún valor todavía. 00:19:00
Entonces me dice, oye, yo todavía no puedo comprobar si es... 00:19:02
¿Vale? 00:19:07
¿Con qué valor lo inicializaríais para aseguraros 00:19:07
de que va a entrar una primera vez 00:19:10
a pedir la antigua y comparar? 00:19:13
¿Se supone que tiene valor null? 00:19:16
¿No puede comparar el null con...? 00:19:17
Se supone que lo tiene. 00:19:20
Y si tú haces un system out, te dará null. 00:19:21
Pero el compilador no cuenta con ello. 00:19:23
El compilador ya se te dice, oye, esto es inicializar. 00:19:25
Si hiciéramos un system out aquí, saldría null. 00:19:28
Pero el compilador sigue unas reglas muy estrictas 00:19:31
y no te deja. 00:19:34
Si no, está específicamente inicializado. 00:19:35
Aquí se trata de, o lo inicializo a null, 00:19:37
o inicializo al vacío. 00:19:40
Yo sé que es imposible que la contraseña sea vacía. 00:19:41
Es imposible, porque ya lo he establecido previamente. 00:19:43
Entonces, me da igual lo que os haga menos daño a la vista. 00:19:46
El null ahora mismo, como también hemos visto objetos, 00:19:50
aún no se le puede hacer raro. 00:19:53
Bueno, lo dejamos así. 00:19:55
¿Vale? 00:19:58
Si lo dejamos así, la inicializo al vacío. 00:19:59
Con lo cual, me aseguro que la primera vez entro sí o sí. 00:20:02
Porque esta contraseña es la que está establecida 00:20:06
y no va a ser vacía. 00:20:09
Es imposible, porque está establecida. 00:20:10
Entonces, entro una primera vez. 00:20:12
¿Cuándo la introdujo a contraseña? 00:20:14
La introduce. 00:20:16
¿Qué es diferente? 00:20:17
Vuelvela a pedir. 00:20:19
¿Qué sigue siendo diferente? 00:20:20
Vuelvela a pedir. 00:20:22
¿Qué sigue siendo diferente? 00:20:23
Vuelvela a pedir. 00:20:24
¿Y así podría estar? 00:20:25
Pues siglos y siglos y siglos y siglos. 00:20:26
El programa no terminaría jamás. 00:20:28
¿Vale? 00:20:30
¿Cuándo termina el programa? 00:20:31
Cuando la password leída sea igual 00:20:33
que la que se ha establecido de antes, 00:20:36
la que esté guardada ahí arriba, en la variable. 00:20:38
Bueno, pues en ese caso, 00:20:40
cuando se haya establecido la contraseña nueva, 00:20:42
ya salimos por aquí. 00:20:44
Podemos ponerle y todo para que el programa 00:20:46
quede más claro. 00:20:49
Correcta. 00:20:52
Vale. 00:20:53
¿Y ahora? 00:20:55
¿Ahora qué toca? 00:20:56
Pues repetir el código de arriba. 00:20:57
Repetir el código de arriba que pide una contraseña nueva 00:20:59
y se está en un bucle de validación, 00:21:01
ahí bla, bla, bla, bla, bla, bla, bla, 00:21:03
hasta que sea válida. 00:21:05
Aquí, claro, si lo saco una función, mejor. 00:21:07
Pero vamos a... 00:21:10
¿Vale? 00:21:13
Todo este código, tal cual, 00:21:14
lo puedo cascar enterito. 00:21:16
Este. 00:21:18
¿Vale? O sea, lo... 00:21:26
Si ya hay contraseña establecida, 00:21:28
es lo mismo que arriba, 00:21:31
pero tengo que antes hacer esto de aquí. 00:21:33
¿Vale? Pues el caso 1 de la contraseña ya está. 00:21:41
Claro, como lo vamos resolviendo, 00:21:46
pues según se nos van ocurriendo, 00:21:49
vamos viendo que es la manera en realidad de hacerlo 00:21:51
cuando uno no tiene todavía las ideas muy claras, 00:21:54
pues vamos resolviendo, vamos... 00:21:58
Pues nos ha quedado claro un código muy largo. 00:22:00
Luego esto lo ideal sería, oye, 00:22:02
estoy repitiendo lo mismo dos veces. 00:22:04
Voy a sacar una función 00:22:06
y llamo a la función 00:22:08
y no tengo que repetir el mismo código aquí 00:22:10
y el mismo código ahí. 00:22:12
¿Vale? Y eso ya luego son refinados 00:22:13
que podemos hacer después 00:22:16
para que quede un código más bonito, 00:22:17
cuando ya pues tenemos más control, 00:22:19
más dominio, lo que sea. 00:22:20
¿Vale? 00:22:22
Pero lo que hemos entendido, 00:22:24
¿está claro? 00:22:26
Repito, a la máquina virtual, a la CPU, 00:22:32
le da igual que esté en una función que esté ahí. 00:22:35
Si él va a ejecutar lo mismo, 00:22:37
va a ejecutar las mismas sentencias. 00:22:38
Es de cara a que el código esté organizado, 00:22:40
sea legible para los demás. 00:22:42
Bueno, pues el caso de la contraseña, 00:22:47
el caso 1, a falta, 00:22:49
y esta llave es del... 00:22:52
el ELSI este. 00:22:54
El caso 1, a falta de hacer pruebas, 00:22:58
porque se nos pueden haber escapado cosas raras, 00:23:00
alguna cosa que no hemos tenido en cuenta, 00:23:03
se nos ha traspapelado un... 00:23:06
un i, un mayor o igual, un menor, 00:23:08
a falta de hacer pruebas 00:23:10
para ver si hay un problema, 00:23:11
en principio parece que, bueno, 00:23:13
que este sería el caso 1, ¿no? 00:23:14
Completo. 00:23:15
¿Vale? 00:23:17
Entonces, repito, importante, 00:23:21
no olvidéis lo de que los caracteres 00:23:24
los puedo usar indistintamente, 00:23:26
como carácter, 00:23:29
y entonces se da el símbolo 00:23:30
entre comillado con comillas simples, 00:23:32
o como número, 00:23:33
y compararlo con números, 00:23:34
según la correspondiente tabla este, 00:23:36
y eso nos facilita las cosas. 00:23:37
Eso por un lado. 00:23:39
Y otra cosa interesante, 00:23:41
cosas que tenéis que ir registrando, 00:23:42
pues cuando uno hace un bucle 00:23:44
para validar algo, 00:23:45
la condición de arriba 00:23:47
puede ser muy fácil de poner, 00:23:48
o no puede ser inmediata. 00:23:50
Si no es inmediata, 00:23:52
tendremos que construirla aquí, 00:23:53
construirla, 00:23:55
guardarla en un Boolean, 00:23:57
y ya ponerla en el GUIDE. 00:23:59
¿Vale? 00:24:01
Porque no todas las condiciones 00:24:02
son inmediatas. 00:24:04
En M hay igual que cero, ¿no? 00:24:05
Hay veces que tenemos que 00:24:06
construirlas con contadores, 00:24:07
con cosas, 00:24:09
y cuando ya las tenemos, 00:24:10
pues ya se puede ir arriba. 00:24:11
¿Vale? 00:24:16
Este caso uno está... 00:24:18
Venga, pues a ver, 00:24:20
ya los otros dos son mucho más cortitos. 00:24:22
En el Login, 00:24:25
en Login, 00:24:27
de nuevo aquí ya podemos copiar y pegar. 00:24:29
Porque aquí es pedir la contraseña 00:24:32
y estar ahí enganchado 00:24:34
hasta el infinito, 00:24:36
hasta que nos dé la contraseña nueva. 00:24:38
¿Vale? 00:24:42
Ah, bueno, aquí es donde, 00:24:43
no, claro, 00:24:44
aquí es donde digo yo 00:24:45
que no estaba muy claro 00:24:46
que podías haber optado por dos cosas. 00:24:47
El tenerte ahí hasta el infinito, 00:24:49
hasta que introduzca la contraseña nueva, 00:24:52
o si no le pones la contraseña, 00:24:55
la nueva no, 00:24:57
la contraseña del programa, 00:24:58
o simplemente pedirla una vez 00:24:59
y no se la pones decir, 00:25:00
no puede acceder, 00:25:01
y ya está. 00:25:02
No sé por qué camino habéis optado, 00:25:03
habéis optado por diferentes caminos, 00:25:05
da igual, 00:25:07
da lo mismo. 00:25:08
¿Vale? 00:25:09
Me explico lo que estoy diciendo, ¿no? 00:25:10
Que a lo mejor algunos habéis interpretado, 00:25:12
en el Login, 00:25:13
pides la contraseña, 00:25:14
si no te da la buena, 00:25:16
te dice directamente, 00:25:17
no puedes entrar, 00:25:19
y se acabó. 00:25:20
O pides la contraseña 00:25:21
y te estás ahí en un bucle 00:25:22
todo el rato 00:25:23
hasta que pidas la buena. 00:25:24
No sé cuál os resulta más natural. 00:25:26
En un caso real, 00:25:29
lo normal no es que se esté ahí 00:25:30
hasta el infinito, ¿no? 00:25:31
Si tú le pones la contraseña 00:25:32
y no te dice, 00:25:33
no puedes, 00:25:34
se acabó, ¿no? 00:25:35
Y tienes que volver a hacer 00:25:36
Login otra vez. 00:25:37
Bueno, pues a ver, 00:25:40
hacer Login entonces. 00:25:41
El caso 2, 00:25:44
si o si hay que pedir la contraseña, 00:25:45
otra vez, 00:25:47
si o si hay que pedir la contraseña, 00:25:48
es decir, 00:25:50
esto, 00:25:51
si o si hay que pedirla, 00:25:55
introduzca la password 00:25:57
para hacer Login. 00:26:01
Vale. 00:26:03
¿Vale? 00:26:05
Password leída. 00:26:06
Aquí es que no la tengo declarada, 00:26:12
entonces por eso tengo que declararla. 00:26:14
Password leída, 00:26:15
esta. 00:26:16
Y aquí de nuevo, 00:26:18
repito, 00:26:20
podemos plantearnos, 00:26:21
¿no estaba claro en el enunciado? 00:26:22
Directamente, 00:26:24
que es buena, 00:26:26
le digo Login, 00:26:28
entras, 00:26:29
que es mala, 00:26:30
no entras, 00:26:31
y se acabó, 00:26:32
y nos complicamos la vida. 00:26:33
O lo podemos meter en un bucle, 00:26:34
que ya está en infinito, 00:26:35
lo que hayáis optado, 00:26:36
¿vale? 00:26:37
Vamos a simplemente hacer esto, 00:26:39
que es lo más natural en los programas, 00:26:42
¿no? 00:26:44
Si la contraseña 00:26:46
resulta que no es igual, 00:26:50
que no lo es, 00:26:53
que no delante, 00:26:55
que no se me olvide, 00:26:56
no es igual a esta, 00:26:57
entonces le decimos, 00:26:58
no puede entrar, 00:27:00
y se acabó. 00:27:01
Y ya está, 00:27:06
ya se ha acabado, 00:27:07
no hay más que hacer, 00:27:08
no puede entrar. 00:27:09
Y volverá a salir el menú, 00:27:10
y se acabó. 00:27:11
Y si el tío quiere hacer Login de nuevo, 00:27:12
pues que otra vez le dé a Login, 00:27:13
y otra vez a meter contraseña, 00:27:14
no puede entrar, 00:27:16
se acabó. 00:27:17
Que es igual, 00:27:18
que es igual, 00:27:22
que puede entrar, 00:27:24
y se ponía el mensajito, 00:27:25
¿verdad? 00:27:26
Pero, 00:27:27
¿qué más hay que hacer? 00:27:28
Que esa era la clave de todo esto, 00:27:30
¿qué más hay que hacer? 00:27:32
Claro, justo, 00:27:34
ya está, 00:27:35
poner el usuario logado a True, 00:27:36
¿vale? 00:27:47
Y al poner usuario logado a True, 00:27:48
esto ahora ya hace 00:27:50
que el funcionamiento del menú 00:27:51
me permita que el logout aparezca, 00:27:53
gracias a esta variable. 00:27:57
Entonces, 00:27:58
esa variable va cambiando 00:27:59
según se va dando a Login. 00:28:01
Bueno, 00:28:04
pues la opción de Login ya está. 00:28:05
Repito, 00:28:06
salvo la variante, 00:28:07
si uno la ha hecho, 00:28:08
de meter esto ahí en un bucle, 00:28:10
en lugar de leerla solo una vez y comparar, 00:28:12
meter esto en un bucle, 00:28:15
que se esté ahí todo el rato, 00:28:16
hasta que introduja la correcta. 00:28:18
Pero vamos, 00:28:20
sería lo mismo que aquí, 00:28:21
meterla aquí en un bucle como este, 00:28:22
lo mismo. 00:28:24
Bueno, 00:28:27
¿y la opción de Logout? 00:28:28
En la opción de Logout hemos dicho que 00:28:29
tendrá que decir, 00:28:31
ala, 00:28:32
has salido del programa, 00:28:35
¿y qué faltará aquí? 00:28:39
Usuario logado a False, 00:28:43
¿vale? 00:28:45
Para que otra vez ya 00:28:46
no vuelva a salir Logout. 00:28:47
Y ya están todas las opciones hechas. 00:28:54
Vale, 00:28:58
luego este ejercicio tenía 00:28:59
las dos cosas 00:29:00
que evaluaba, 00:29:01
de alguna manera, 00:29:02
una es 00:29:03
la de identificar 00:29:04
que en función de si 00:29:07
el usuario está logado o no, 00:29:08
hay que hacer, 00:29:11
el menú funciona de una manera u otra, 00:29:12
porque muestra o no muestra, 00:29:14
con lo cual necesito una boolea, 00:29:15
necesito una boolea, 00:29:17
obligatoriamente, 00:29:18
para ponerla aquí. 00:29:21
Necesito una boolea para ponerla ahí, 00:29:24
porque el menú 00:29:26
hace aparecer esa opción, 00:29:28
o no, 00:29:29
en función de la variable, 00:29:30
la necesito. 00:29:31
Entonces esa es la clave, 00:29:32
pues, 00:29:33
ah, vale, 00:29:34
necesito una variable boolea 00:29:35
para que esto aparezca o desaparezca, 00:29:36
pues variable boolea al canto. 00:29:37
Y ahora ya decidir esa variable, 00:29:39
como se inicializa, 00:29:41
que en este caso será False, 00:29:43
para que de partida esto no salga, 00:29:44
y en qué puntos de la aplicación se cambia, 00:29:46
en qué puntos se cambia, 00:29:48
pues en este caso, 00:29:50
esta variable se va a cambiar, 00:29:51
en este punto, 00:29:54
cuando se hace Login, 00:29:55
que se cambia a True, 00:29:56
y en este otro, 00:29:57
cuando se vuelve a hacer Logout, 00:29:58
que se cambia a False, 00:29:59
y ya está, 00:30:00
y ese boolea ya no tiene más que pintar, 00:30:01
ni más historia, 00:30:02
se acabó. 00:30:03
Y luego ya la otra parte, 00:30:05
¿cuál era? 00:30:06
Pues la de la contraseña, 00:30:07
distinguir la situación, 00:30:09
¿hay contraseña o no la hay? 00:30:10
Si no la hay, 00:30:12
la pido de nuevas validándola, 00:30:14
y si la hay, 00:30:16
pido la vieja, 00:30:18
ahí me quedo atascado pidiendo la vieja, 00:30:19
y luego otra vez pido la nueva y validándola. 00:30:21
Y ya, 00:30:24
creo que está todo lo que pide, 00:30:25
el ejercicio. 00:30:27
¿Vale? 00:30:33
Bueno, aquí repito, 00:30:35
natural sería sacar este código, 00:30:36
que hemos repetido dos veces, 00:30:38
y que es tan largo, 00:30:39
sacarlo a una función. 00:30:40
Vamos a probarlo, 00:30:42
porque cuando uno ya hace un código largo, 00:30:43
es muy fácil que se le hayan escapado mil cosas, 00:30:45
y esto de repente no funcione. 00:30:47
Aparte de que tenemos el problema 00:30:50
de que estamos leyendo números, 00:30:51
y luego después estamos leyendo también líneas. 00:30:54
Y eso da un error, 00:30:58
¿os acordáis? 00:30:59
Si hacemos un NextInt, 00:31:00
y luego hacemos un Slime, 00:31:02
el NextLine coge el salto de línea del NextInt, 00:31:03
y no se nos queda ahí esperando el carácter. 00:31:06
Entonces, 00:31:10
¿esa en qué situaciones ocurre? 00:31:12
Pues aquí, 00:31:14
después de hacer el NextInt, 00:31:15
¿vale? 00:31:19
Luego va a venir el NextLine de aquí, 00:31:20
el NextLine de aquí, 00:31:22
entonces yo creo que 00:31:23
puede que ya, 00:31:25
poniéndolo aquí, 00:31:26
ya lo arreglemos de partida, 00:31:27
y no tengamos ni que andar. 00:31:28
¿Vale? 00:31:33
Y al poder olvidarnos de este problema, 00:31:34
del NextLine que nos atasca tanto, 00:31:36
ya enseguida, 00:31:38
en cuanto ya veamos un poco más de los objetos, 00:31:39
nos vamos a hacer una clase aparte, 00:31:41
con una utilidad para leer por teclado, 00:31:43
que ya haga todos los limpiados, 00:31:46
y lo haga todo, 00:31:48
y así este problema ya 00:31:49
no vamos a tener que resolverlo a mano, 00:31:51
como lo estamos haciendo. 00:31:53
¿Vale? 00:31:54
Pero lo importante es que identifiquemos 00:31:55
lo que nos está pasando, 00:31:57
que cuando leemos un numerito, 00:31:58
con el escáner, 00:32:00
sea NextInt, 00:32:01
NextDab, 00:32:02
y después hacemos un NextLine, 00:32:03
este NextLine no se queda parado 00:32:05
esperando la cadena, 00:32:07
sino que coge el salto de línea, 00:32:08
con lo cual no funciona mal. 00:32:10
Venga, vamos a hacer la prueba, 00:32:13
a ver si hemos conseguido 00:32:14
que esto funcione a la primera. 00:32:15
A ver. 00:32:19
Que esto siempre es lo más divertido. 00:32:22
Bueno, 00:32:26
la primera parte está bien, 00:32:27
el logout no sale, 00:32:28
pero algo es algo. 00:32:30
Hombre, 00:32:33
ya sería rizarle el rizo un montón, 00:32:34
claro, 00:32:36
es que esto queda muy feo, 00:32:37
¿no? 00:32:38
Lo ideal sería 00:32:39
que cuando no sale el logout 00:32:40
de esto estuviera un 3, 00:32:41
y cuando sí sale esto 00:32:42
estuviera un 4. 00:32:43
Sería lo ideal, 00:32:44
pero bueno, 00:32:45
esto es meter el salir 00:32:46
dentro del if, 00:32:47
y ya está, 00:32:49
pero bueno, 00:32:50
que eso es una pijería. 00:32:51
¿Vale? 00:32:52
Bueno, 00:32:53
pues ya está, 00:32:54
¿qué opción quiero? 00:32:55
Vamos a ponerle 00:32:56
la de establecer, 00:32:57
modificar password. 00:32:58
Introduzca password. 00:32:59
Vamos a ponerle una no válida. 00:33:00
Esta es no válida. 00:33:02
Me sigue pidiendo. 00:33:03
Esta también es no válida. 00:33:04
Le vamos a poner ahora una válida. 00:33:06
KH6. 00:33:08
Vale. 00:33:10
En principio 00:33:11
le ha debido parecer válida 00:33:12
porque me ha vuelto 00:33:13
a ponerle pedir el menú. 00:33:14
Vale, 00:33:16
pero me sigue sin salir el logout, 00:33:17
claro, 00:33:18
porque no hemos hecho login. 00:33:19
Vamos a modificarla. 00:33:21
La contraseña, 00:33:23
antes de hacer login 00:33:24
vamos a modificarla. 00:33:25
Le vuelvo a dar a 1. 00:33:26
Introduzca password anterior. 00:33:27
Vamos a ponerle una que no es. 00:33:29
Me la sigue pidiendo. 00:33:32
Le vamos a poner ahora la buena. 00:33:34
La buena que era esta. 00:33:36
Esta. 00:33:43
Correcta. 00:33:44
Vale. 00:33:45
Ahora, 00:33:46
introduzca password nueva. 00:33:47
Introduzca password nueva. 00:33:48
Pues de nuevo, 00:33:49
si le pido una que no es válida, 00:33:50
ahí se me queda 00:33:52
hasta que le introduzca una válida. 00:33:53
Vamos a ponerle una válida. 00:33:55
JJJJ88. 00:33:56
Vale. 00:34:00
Esa parece ser 00:34:01
que es nuestra nueva contraseña 00:34:02
que le acabamos de modificar. 00:34:04
Vamos a hacer login 00:34:06
a ver si es verdad 00:34:07
que es esa contraseña. 00:34:08
2. Login. 00:34:10
Me pide la contraseña. 00:34:11
Le pongo una que no es. 00:34:12
No puede entrar. 00:34:14
Y ya está, 00:34:15
no puede entrar y sale. 00:34:16
Vale, 00:34:17
pues ha hecho lo que tiene que hacer. 00:34:18
Vamos a volver a hacer login otra vez. 00:34:19
Vamos a volver a hacer login. 00:34:21
Ahora poniéndole la buena. 00:34:22
La nueva que era 00:34:24
JJJJ88. 00:34:26
Puede entrar. 00:34:30
Vale. 00:34:31
Y efectivamente, 00:34:32
ahora sí que me sale el logout. 00:34:33
A ver si me sale. 00:34:34
Bueno. 00:34:35
Vamos a hacer logout. 00:34:36
Hago logout. 00:34:37
Ha salido y ya no me sale. 00:34:39
Bueno, 00:34:42
pues parece que hemos acertado la primera. 00:34:43
Todo no funciona. 00:34:45
A lo margen de que el código 00:34:46
sea más largo, más corto, 00:34:47
lo que sea. 00:34:48
Bueno, pues ya está. 00:34:52
Salimos. 00:34:53
Y listo. 00:34:55
Bueno, 00:34:59
más o menos visto. 00:35:00
¿Sí? 00:35:04
Venga, 00:35:11
pues hacemos el 3. 00:35:12
¿Qué no entiendes? 00:35:23
No. 00:35:26
A ver el 3. 00:35:28
Añadir números positivos 00:35:33
en un array. 00:35:36
Vale. 00:35:37
Finalizando el programa 00:35:40
cuando se introduzca un 0. 00:35:41
Una vez introducidos 00:35:44
el número que más veces aparece. 00:35:46
Bueno, 00:35:48
tampoco es tan fácil. 00:35:49
Puedes hacer un máximo, 00:35:50
pero un máximo 00:35:52
no de los valores del array, 00:35:53
sino del número de apariciones 00:35:55
de cada número. 00:35:57
Es un poquito más complicado. 00:35:59
Bueno, 00:36:02
entonces empezamos a pensar 00:36:03
y a decidir, 00:36:04
vale, 00:36:05
mis datos de entrada, 00:36:06
¿qué son? 00:36:07
Son muchos números. 00:36:08
Muchos. 00:36:09
Pues aunque no me lo dijeran ahí 00:36:10
que me lo dicen, 00:36:11
automáticamente 00:36:12
ya tengo que decidir 00:36:13
que para guardar muchos números 00:36:14
un array. 00:36:15
Un array. 00:36:16
Vale. 00:36:17
Entonces ya hemos decidido, 00:36:18
aparte es que nos lo han dicho, 00:36:19
que necesitamos un array. 00:36:20
Cuando uno decide 00:36:22
que necesita un array, 00:36:23
la siguiente pregunta automática 00:36:24
que le surge es, 00:36:26
¿y de qué tamaño? 00:36:27
Cuando uno declara un array 00:36:28
tiene que tener un tamaño, 00:36:29
tiene que decir ya, 00:36:30
de 20, 00:36:31
de 30, 00:36:32
de 40, 00:36:33
¿de qué tamaño? 00:36:34
Vale, 00:36:35
pues sabéis que tenemos 00:36:36
dos posibilidades. 00:36:37
Inicialmente, 00:36:38
que ese array 00:36:39
no tenga ningún tamaño, 00:36:40
o sea, 00:36:42
sea un array 00:36:43
sin posiciones 00:36:44
y según quiero yo 00:36:45
irle metiendo, 00:36:46
pues hago uno nuevo 00:36:48
con una posición 00:36:49
más, 00:36:50
copio el viejo 00:36:51
en el nuevo 00:36:52
y añado 00:36:53
el nuevo valor 00:36:54
en la nueva posición. 00:36:55
O eso, 00:36:56
que sirve haciendo crecer, 00:36:57
o otra opción 00:36:59
más sencilla. 00:37:00
Dejo un array muy grandote 00:37:02
y cruzo los dedos 00:37:04
para que el que lo está usando 00:37:05
no se pase 00:37:06
de tamaño 00:37:08
y no me meta 00:37:09
más números 00:37:10
que lo que yo he declarado. 00:37:11
Dos caminos. 00:37:12
Cualquiera de los dos 00:37:13
que hubierais hecho, 00:37:14
nos valía. 00:37:15
El óptimo, 00:37:16
obviamente, 00:37:17
el declarar un array 00:37:19
sin posiciones 00:37:21
todavía 00:37:22
y cada vez que me llega 00:37:23
un nuevo valor, 00:37:24
hago un nuevo. 00:37:25
Vamos a hacer de las dos maneras. 00:37:27
Bueno, 00:37:33
no se utiliza 00:37:34
porque ya lo hace 00:37:35
el array list. 00:37:36
A ver, 00:37:37
no hay otra manera 00:37:38
de hacerlo. 00:37:39
Me refiero, 00:37:40
la única estructura 00:37:41
de datos 00:37:42
que puede guardar 00:37:43
muchos tipos, 00:37:44
muchos datos 00:37:45
de un mismo tipo 00:37:46
pero claro, 00:37:48
el array es complejo 00:37:49
de manejar, 00:37:50
entre otras cosas, 00:37:51
por esto que decimos. 00:37:52
Entonces, 00:37:53
lo que hay es 00:37:54
programas ya hechos 00:37:56
que hacen esto 00:37:58
que estamos diciendo 00:37:59
pero hacen esto 00:38:00
y entonces, 00:38:01
¿qué es lo que hace uno? 00:38:02
Usa eso, 00:38:03
que es el array list. 00:38:04
El array list 00:38:05
es esto que estamos haciendo. 00:38:06
Bueno, 00:38:10
a ver, 00:38:11
me refiero a clases. 00:38:12
Como ya vamos 00:38:13
a empezar 00:38:14
la producción 00:38:15
pues ya lo que 00:38:16
vamos a empezar 00:38:17
a ver claro 00:38:18
es que una aplicación 00:38:19
de Java 00:38:20
son muchas clases 00:38:21
y cada clase 00:38:22
tiene trocitos 00:38:23
de código. 00:38:24
Alguna de esas clases 00:38:25
las hace uno 00:38:26
y otras clases 00:38:28
las coge 00:38:29
porque ya están 00:38:30
hechas en librerías. 00:38:31
Bueno, 00:38:32
pues una de las clases 00:38:33
de las miles 00:38:34
que ya están hechas 00:38:35
en librerías 00:38:36
es esta que digo yo, 00:38:37
ArrayList 00:38:38
y esa clase 00:38:39
que hace, 00:38:40
que tiene, 00:38:41
tiene un código 00:38:42
que hace esto mismo. 00:38:43
Entonces, 00:38:44
el código, 00:38:45
él, 00:38:46
usa el que está 00:38:47
en la clase ArrayList 00:38:48
pero lo que tiene 00:38:49
dentro de esa clase 00:38:50
es esto mismo. 00:38:51
Entonces, 00:38:52
claro, 00:38:53
aquí sobre todo 00:38:54
de lo que se trata 00:38:55
realmente uno 00:38:56
no va a extender 00:38:57
el array a mano, 00:38:58
va a usar esa clase. 00:38:59
Lo que se trata 00:39:00
es de que desarrollemos 00:39:01
de alguna manera 00:39:02
pues habilidades 00:39:03
y destrezas 00:39:04
de programación 00:39:05
y de saber 00:39:06
cómo están hechas 00:39:07
las cosas, 00:39:08
claro. 00:39:09
Vale, 00:39:10
pues entonces, 00:39:11
vamos a hacer 00:39:12
ejercicio 3, 00:39:13
vale. 00:39:14
Pues si tenemos 00:39:15
muchos datos 00:39:16
de un mismo tipo 00:39:17
que tenemos 00:39:18
que conservar, 00:39:19
tenemos el array, 00:39:20
ala. 00:39:21
Y aquí es donde 00:39:22
nos ha venido 00:39:23
esta gran pregunta, 00:39:24
esta gran pregunta 00:39:25
¿qué es un array? 00:39:26
¿qué es un array? 00:39:27
Bueno, 00:39:28
si tenemos 00:39:29
muchos datos 00:39:30
de un mismo tipo 00:39:31
que tenemos 00:39:32
que conservar, 00:39:33
tenemos el array, 00:39:34
ala. 00:39:35
Y aquí es donde 00:39:36
nos ha venido 00:39:37
esta gran pregunta, 00:39:38
esta gran pregunta, 00:39:39
esta gran pregunta, 00:39:40
¿de qué tamaño? 00:39:41
¿de qué tamaño? 00:39:42
Pues inicialmente 00:39:43
de ningún tamaño 00:39:44
ni una posición 00:39:45
y lo vamos ampliando 00:39:46
o inicialmente 00:39:47
de 10.000, 00:39:48
por ejemplo 00:39:49
y cruzamos los dedos 00:39:50
porque el usuario 00:39:51
no meta más 00:39:52
de 10.000 números, 00:39:53
vale. 00:39:54
Vamos, 00:39:55
cualquiera 00:39:56
de los dos 00:39:57
que hubierais usado 00:39:58
nos vale. 00:39:59
Vamos a empezar 00:40:00
por la clave 00:40:01
¿qué es un array? 00:40:02
¿qué es un array? 00:40:03
Bueno, 00:40:04
vamos a empezar 00:40:05
por la clave 00:40:06
¿qué es un array? 00:40:07
Bueno, 00:40:08
nos vale. 00:40:09
Vamos a empezar 00:40:10
por la complicada. 00:40:11
Inicialmente 00:40:12
un array 00:40:13
ala, 00:40:14
de ninguna posición. 00:40:15
Esto es como 00:40:16
ponerle un null 00:40:17
en realidad. 00:40:18
Pero bueno, 00:40:19
para que quede así 00:40:20
más claro, 00:40:21
que veamos claro 00:40:22
que no tiene 00:40:23
ninguna posición. 00:40:24
Bueno, 00:40:25
este es mi array 00:40:26
que iremos 00:40:27
extendiendo 00:40:28
según vayamos 00:40:29
necesitando, 00:40:30
según vayamos 00:40:31
necesitando. 00:40:32
Ese es mi array. 00:40:33
Vale, 00:40:34
¿qué tengo que hacer 00:40:35
con este array? 00:40:36
Llevar al array. 00:40:37
Leer número, 00:40:38
llevar al array. 00:40:39
Leer número, 00:40:40
llevar al array. 00:40:41
Y todo eso 00:40:42
mientras 00:40:43
el número leído 00:40:44
sea diferente 00:40:45
de cero. 00:40:46
Porque el cero 00:40:47
terminaba, 00:40:48
¿no? 00:40:49
Mientras el número 00:40:50
sea diferente de cero 00:40:51
leo número, 00:40:52
llevo al array. 00:40:53
Leo número, 00:40:54
llevo al array. 00:40:55
Pues venga, 00:40:56
ahora declaramos variables 00:40:57
que nos hacen falta. 00:40:58
El scanner. 00:40:59
Venga, 00:41:07
pues le decimos, 00:41:16
introduzca positivo. 00:41:22
Leemos el positivo. 00:41:23
Leemos el numerito. 00:41:33
Vale, 00:41:36
y ahora, 00:41:37
esta variable 00:41:38
tiene que estar declarada 00:41:39
antes, 00:41:40
claro. 00:41:41
Vale, 00:41:42
ya podemos ir haciendo 00:41:43
seguido 00:41:44
como queremos 00:41:45
que entre 00:41:46
la primera vez 00:41:47
sí o sí, 00:41:48
pues inicializo a uno, 00:41:49
así entre 00:41:50
la segunda vez 00:41:51
sí o sí, 00:41:52
pues inicializo 00:41:53
a uno, 00:41:54
así entre 00:41:55
la primera vez 00:41:56
sí o sí, 00:41:57
pues inicializo 00:41:58
a uno, 00:41:59
así entre 00:42:00
la primera vez 00:42:02
sí o sí, 00:42:03
introduzca positivo, 00:42:04
leo el numerito, 00:42:05
vale, 00:42:06
y ahora 00:42:07
vamos a guardar 00:42:08
en el array, 00:42:09
vale. 00:42:10
Entonces, 00:42:11
ahora si vamos a extender, 00:42:12
esta es la parte 00:42:13
más complicada, 00:42:14
si vamos a extender 00:42:15
tenemos que distinguir, 00:42:16
¿no? 00:42:17
A ver, 00:42:18
esto, 00:42:19
así es como 00:42:20
lo explicó Stefano, 00:42:21
vamos a ver, 00:42:22
vamos a ver, 00:42:23
vamos a ver, 00:42:24
vamos a ver, 00:42:25
vamos a ver, 00:42:26
vamos a ver, 00:42:27
vamos a ver, 00:42:28
vamos a ver, 00:42:29
vamos a ver, 00:42:30
creo que voy a poner 00:42:31
el mismo nombre 00:42:32
de variables 00:42:33
que usa él 00:42:34
para que no os hagáis 00:42:35
un lío, 00:42:36
esto que hacía, 00:42:37
hacía 00:42:38
array nuevo 00:42:40
o temporal 00:42:41
o aux 00:42:42
un array nuevo 00:42:43
que fuera igual, 00:42:44
es decir, 00:42:45
que fuera igual 00:42:46
array nuevo 00:42:49
que era 00:42:50
que era 00:42:51
que 00:42:54
fuese 00:42:55
igual 00:42:56
que tuviera como tamaño 00:43:00
el array 00:43:03
antiguo 00:43:04
más uno 00:43:05
¿vale? 00:43:08
es decir, 00:43:10
una posición más 00:43:11
hacemos un array nuevo 00:43:12
uno nuevo 00:43:14
que tenga 00:43:15
una posición más 00:43:16
que tenía el otro 00:43:17
el otro inicialmente 00:43:18
era cero 00:43:19
¿vale? 00:43:20
con lo cual la primera vez 00:43:21
tendrá una posición 00:43:22
que la siguiente vez 00:43:23
tendrá dos 00:43:24
y la siguiente tres 00:43:25
entonces hacemos uno nuevo 00:43:26
que tenga una posición más 00:43:27
que la anterior 00:43:28
¿ahora qué hacíamos? 00:43:29
copiábamos 00:43:30
cada posición 00:43:31
del viejo 00:43:32
en el nuevo 00:43:33
¿vale? 00:43:34
pues vamos a hacer eso 00:43:35
copiamos cada posición 00:43:36
del viejo 00:43:37
en el nuevo 00:43:38
pues venga 00:43:39
desde igual a cero 00:43:40
mientras i sea menor 00:43:41
que 00:43:42
números 00:43:43
perdón 00:43:44
que el viejo 00:43:45
se llama números 00:43:46
números.length 00:43:47
incrementando i 00:43:48
¿qué hacemos? 00:43:49
array 00:43:50
vamos a terminar esto 00:43:51
si queréis 00:43:52
luego paramos 00:43:53
array 00:43:55
nuevo 00:43:56
si queréis 00:43:57
luego paramos 00:43:58
unos minutos 00:43:59
números de i 00:44:00
vale 00:44:01
ya hemos copiado 00:44:02
todas las posiciones 00:44:03
del viejo 00:44:04
en el nuevo 00:44:05
pero la nueva 00:44:06
extra 00:44:07
en la nueva 00:44:08
extra 00:44:09
ya valen 00:44:10
¿eh? 00:44:11
¿vale? 00:44:12
y la extra 00:44:13
array 00:44:15
nuevo 00:44:16
de su última 00:44:17
posición 00:44:18
que es 00:44:19
su última 00:44:20
posición 00:44:21
¿cuál es? 00:44:22
array 00:44:23
nuevo 00:44:24
punto 00:44:25
menos uno 00:44:26
esta es su última 00:44:27
esta va en 00:44:28
vale 00:44:29
y ahora ya 00:44:30
¿qué nos faltaba? 00:44:31
vamos a pisar 00:44:32
el array 00:44:33
antiguo 00:44:34
con el nuevo 00:44:35
¿vale? 00:44:36
es que no se llama 00:44:38
array 00:44:39
se llama 00:44:40
números 00:44:41
¿vale? 00:44:42
¿vale? 00:44:43
¿vale? 00:44:44
¿vale? 00:44:45
¿vale? 00:44:46
¿vale? 00:44:47
¿vale? 00:44:48
¿vale? 00:44:49
¿vale? 00:44:50
¿vale? 00:44:51
¿vale? 00:44:52
¿vale? 00:44:53
¿vale? 00:44:54
bueno, da igual 00:44:56
a que igual eso lo decís 00:44:57
en otro orden 00:44:58
da lo mismo 00:44:59
da lo mismo 00:45:00
da igual 00:45:01
¿vale? 00:45:04
lo que importa es 00:45:05
lo que tenemos que hacer 00:45:06
¿qué es? 00:45:07
nos hacemos uno 00:45:08
de una posición más 00:45:09
copiamos 00:45:10
todas y cada una 00:45:11
de las posiciones 00:45:12
del viejo 00:45:13
en el nuevo 00:45:14
en la posición 00:45:15
adicional 00:45:16
que es esta 00:45:17
en la adicional 00:45:18
copiamos 00:45:19
el nuevo dato 00:45:20
y ahora ya 00:45:21
piso 00:45:22
mi array 00:45:23
el antiguo 00:45:24
lo piso con este 00:45:25
o lo puedo pisar antes 00:45:26
me da lo mismo 00:45:27
porque apuntan 00:45:28
al mismo sitio 00:45:29
yo es que así 00:45:30
lo veo más claro 00:45:31
porque si se pone antes 00:45:32
hay que tener muy claro 00:45:33
que eso son 00:45:34
direcciones de memoria 00:45:35
y que luego aquí 00:45:36
pero bueno 00:45:37
da igual 00:45:38
¿vale? 00:45:39
o sea, esta parte 00:45:40
cuando hacemos esto 00:45:41
tenéis claro 00:45:42
lo que hacemos 00:45:43
¿no? 00:45:44
lo tenéis claro 00:45:45
estamos metiendo 00:45:46
un dato nuevo 00:45:47
en el array 00:45:48
pues tengo que agrandarlo 00:45:49
le pongo una posición más 00:45:50
copio el viejo 00:45:51
en el nuevo 00:45:52
pongo la posición extra 00:45:54
y sustituyo una por otra 00:45:55
¿vale? 00:45:56
bueno 00:45:57
y ahora ya 00:45:58
pues ya está 00:45:59
a ver que repase 00:46:00
si he hecho algo mal 00:46:01
leemos el numerito 00:46:02
y se va 00:46:03
a la extra 00:46:04
de aquí 00:46:05
¿vale? 00:46:06
pues ya está 00:46:07
¿no? 00:46:08
a ver 00:46:09
que repase 00:46:10
si he hecho algo mal 00:46:11
leemos el numerito 00:46:12
y se va 00:46:13
a la extra 00:46:14
de aquí 00:46:15
¿vale? 00:46:16
pues ya está 00:46:17
¿no? 00:46:18
a ver 00:46:19
que repase 00:46:20
si he hecho algo mal 00:46:21
le pongo la extra 00:46:22
de aquí 00:46:23
¿vale? 00:46:24
aquí lo único 00:46:25
es que 00:46:26
si el numero es cero 00:46:27
también lo está guardando 00:46:28
en el array 00:46:29
¿verdad? 00:46:30
porque no se va 00:46:31
al while 00:46:32
a mirar si es diferente 00:46:33
de cero para salir 00:46:34
hasta después 00:46:35
de haberlo leído 00:46:36
y guardado 00:46:37
entonces 00:46:38
si yo no quiero 00:46:39
que el cero 00:46:40
vaya al array 00:46:41
esto de aquí 00:46:42
lo meto en un if 00:46:43
simplemente 00:46:44
¿entendéis? 00:46:45
¿no? 00:46:46
que este mete 00:46:47
todos los números 00:46:48
incluido el cero 00:46:49
y ya no va 00:46:50
a pedir más 00:46:51
porque como ya he metido 00:46:52
un cero 00:46:53
la siguiente vez 00:46:54
que el while 00:46:55
vaya arriba 00:46:56
va a salir 00:46:57
entonces 00:46:58
mete todos los números 00:46:59
más el cero final 00:47:00
bueno 00:47:01
eso ya es cuestión 00:47:02
de preguntarle 00:47:03
a quien lo haya puesto 00:47:04
¿el cero del final 00:47:05
quieres que también 00:47:06
vaya al array 00:47:07
o no quieres que vaya? 00:47:08
que no queremos que vaya 00:47:09
se puede meter 00:47:10
todo esto 00:47:11
en un if 00:47:12
if n 00:47:13
diferente de cero 00:47:14
entonces haz todo eso 00:47:15
simplemente 00:47:16
if n 00:47:17
diferente de eso 00:47:18
haz todo eso 00:47:19
bueno, ese while 00:47:20
está entendido 00:47:21
el bucle 00:47:22
que va rellenando 00:47:23
el array 00:47:24
¿vale? 00:47:25
venga 00:47:26
vamos a parar 00:47:27
dos minutos entonces 00:47:28
por si habéis desconectado 00:47:29
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
4
Fecha:
18 de diciembre de 2023 - 13:46
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
905.82 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid