Saltar navegación

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

Clase 11-12-23 - 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 18 de diciembre de 2023 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues venga, vamos entonces a resolver ese primer ejercicio con ese esquema que hemos planteado ahí, vamos a empezar ahora ya a programar ese esquema, que ya son partes pequeñitas que sabemos hacer, pero insisto, importante que tengamos ya un primer diseño montado en la cabeza o en un papel o donde sea, 00:00:02
sobre todo es un ejercicio más largo 00:00:21
es un ejercicio corto, a lo mejor uno esto lo hace 00:00:23
de tirón y ya está, vale, lo hace de tirón 00:00:25
pero en cuanto sea un poquito 00:00:28
más complejo, pues tiene 00:00:29
mucho peligro hacerlo de un tirón 00:00:31
examen 4 de diciembre 00:00:33
vale, pues venga, vamos a empezar 00:00:37
a hacerlo siguiendo ese 00:00:59
esquema que he puesto hoy ahí, luego ya 00:01:01
otra cosa es que uno cuando vea ya una 00:01:03
versión ahí, diga, hombre, pues esto a lo mejor 00:01:04
la puedo dejar más bonito si hago una función 00:01:07
aparte, o si cambio la 00:01:08
sentencia y en lugar de esta pongo esta otra, ¿vale? Pero eso ya son refinamientos, digamos, 00:01:11
posteriores. Bueno, aquí ya tenemos ya bastante hecho. Por supuesto, ya sabemos que tenemos 00:01:17
que leer del teclado, con lo cual esto no nos queda más remedio que ponerlo, porque 00:01:21
vamos a leer del teclado el numerito. ¿Qué más cosas hemos dicho? Que vamos a leer un 00:01:29
único número, no un montón de ellos, ni de cadenas, ni de nada, un único número. 00:01:38
pues ya está, una variable para él 00:01:43
bueno, llamémosle n 00:01:45
ya que en el enunciado lo llama n mayúscula 00:01:47
pues llamémosle así 00:01:50
ahí va a ir ese numerito 00:01:51
vale, entonces ahora 00:01:53
haríamos esa primera parte 00:01:55
leer número 00:01:58
esa primera parte que hemos dicho que es 00:01:59
no me basta 00:02:02
hacer esto sin más 00:02:03
no me basta hacer esto sin más 00:02:04
insisto, no basta porque el ejercicio 00:02:22
dice que para empezar 00:02:25
a operar aquí 00:02:26
hay que asegurarse de que es positivo 00:02:27
entonces yo no puedo leerlo sin más 00:02:30
el ejercicio dice no 00:02:32
verifica que el número es positivo 00:02:33
solo hay una posibilidad que es obligarle 00:02:35
obligarle al que se sienta ahí 00:02:38
obligarle a que lo introduzca una y otra vez 00:02:40
una y otra vez, una y otra vez 00:02:42
hasta que sea positivo 00:02:43
y eso es un bucle, claro 00:02:44
vale, pues entonces no me queda más remedio 00:02:46
que meter esto en un bucle 00:02:49
y así todo el rato 00:02:51
se tiene que meter en el bucle 00:02:59
siempre y cuando el número 00:03:01
siga siendo negativo 00:03:04
¿verdad? 00:03:05
mientras el número 00:03:08
siga siendo negativo 00:03:09
una y otra vez pide número, léelo 00:03:11
que sigue siendo negativo 00:03:13
pide número y léelo 00:03:15
que sigue siendo negativo, pide número y léelo 00:03:16
vale 00:03:19
eso está claro 00:03:20
y ahora ya estas cosas ya las sabemos 00:03:22
como yo he puesto un while 00:03:24
no he puesto un do while 00:03:26
que podría haber puesto un do while, pero he puesto un while 00:03:28
pues la primera vez 00:03:30
que entra por aquí el programa 00:03:33
me dice, oye, ¿qué hago la primera vez? 00:03:35
¿Entro o no entro? 00:03:37
La primera vez queremos que entre sí o sí 00:03:38
porque la primera lectura tiene que hacerla 00:03:40
al menos una tiene que hacerla 00:03:42
la primera vez queremos que entre sí o sí 00:03:43
Bueno, pues vamos a inicializar n 00:03:45
a un valor 00:03:47
que nos aseguremos 00:03:49
de que va a entrar una primera vez 00:03:51
¿Vale? 00:03:53
¿Vale? Pues nada 00:03:57
Entra la primera vez 00:03:58
introduce número, lo leo, que es menor que cero, introduce número, lo leo, que es menor que cero, 00:04:00
cuando salgo de este bucle es porque esta lectura n ha sido mayor o igual, 00:04:09
entonces al ser mayor o igual, cuando vamos aquí, este dice no, ya no más, y llegamos a este punto, 00:04:14
¿Vale? La historia de siempre. La historia de siempre. Ahora, que esto uno lo hace con un do while o lee el primer numerito fuera y luego hace un while para la siguiente si es que es negativo, eso ya son cosas menores, entre comillas. 00:04:20
¿vale? lo que importa es el diseño del ejercicio 00:04:37
el diseño es este 00:04:40
un único dato de entrada, pues una variable 00:04:40
ya está, un único dato de entrada 00:04:44
lo leo, lo leo y me vale cualquiera 00:04:45
no me vale cualquiera 00:04:48
necesito que sea positivo antes de continuar 00:04:49
pues entonces tengo que 00:04:52
forzar ahí una y otra vez 00:04:54
forzar ahí una y otra vez hasta que se cumpla 00:04:56
esa condición, bueno 00:04:58
vale, pues ahora 00:04:59
ya tenemos la seguridad 00:05:03
en este punto, ya tenemos aquí 00:05:05
la seguridad de que n va a ser mayor o igual que 0 00:05:07
si el enunciado me dice estrictamente positivo 00:05:11
que en principio positivo 00:05:14
a ver, matemáticamente el 0 no se considera positivo 00:05:16
entonces bueno, podríamos hacer esto 00:05:20
y así no tendríamos en cuenta el 0 00:05:23
obligaríamos a que fuera estrictamente positivo 00:05:28
esto ya es, ante la duda 00:05:31
pues uno pregunta al que ha puesto denuncia y dice, a ver, ¿el cero te vale o el cero tampoco? 00:05:38
Ante la duda, en esos casos extremos, se pregunta, ¿te vale el cero o el cero no te vale? 00:05:45
Tiene que ser mayor que cero. 00:05:50
Y ya te dirán, no, no, no, cuando yo digo positivo digo mayor que cero, no mayor o igual. 00:05:53
Y ya entonces se aclara ese detalle, ¿vale? 00:05:57
Vale, pues entonces en ese punto ya sabemos que no es mayor que cero. 00:06:02
Y ahora lo siguiente que hay que hacer, pues ya lo hemos visto, ahora ya estamos ahí, ya estamos en este punto. 00:06:05
Ahora, ¿qué tenemos que hacer? Pues en un cialice depende, si es mayor que 100, me haces una media, y si es menor que 100, me haces otra. 00:06:12
Bueno, pues entonces ahí ya decimos, vale, pues ahí abro ya las dos ramas. 00:06:21
vale, aquí ya me dice 00:06:24
si es menor que 100 00:06:32
tienes que hacer la media de todos los impares 00:06:34
entre n 00:06:37
que es menor que 100 y 100 00:06:38
y si es mayor que 100, otra cosa 00:06:40
bueno, pues nada, entonces no nos queda más remedio 00:06:41
que hacer un if ahí 00:06:44
vale, pues venga 00:06:45
100 es mayor que 100 00:06:47
ahora ya tenemos que hacer 00:06:52
la media 00:06:54
de todos los números comprendidos 00:06:56
entre 100 y n, luego esto ahora ya es la suma acumulativa de toda la vida, una variable 00:06:58
que empiece valiendo n, se va incrementando de 1 en 1, y voy a una variable suma que empieza 00:07:04
valiendo 0, le voy acumulando todos esos valores, todos esos valores que voy generando, primero 00:07:12
es el n, luego el n más 1, luego el n más 2, vale, la suma acumulativa como he hecho 00:07:19
siempre, entonces esta suma acumulativa 00:07:24
pues uno 00:07:26
si la cascamos 00:07:28
tal cual, pues sería una variable 00:07:30
que empieza valiendo 0 00:07:32
vale, una variable que empieza valiendo 0 00:07:33
y ahora, un bucle 00:07:36
un bucle 00:07:37
que va generando todos los 00:07:39
valores entre n y 100 00:07:42
entre n y 100, todos los valores 00:07:44
100 es mejor que n, entre 100 y n 00:07:46
entre 100 y n 00:07:48
una variable que va generando todos los valores 00:07:49
entre 100 y n 00:07:52
y los voy sumando a esa variable suma 00:07:53
hombre aquí lo más sencillo es usar un for 00:07:56
porque el for ya me da esa variable 00:07:59
a través del índice 00:08:01
ya me la da 00:08:02
pues desde i igual a 100 00:08:03
que es el primero 00:08:06
mientras i sea menor o igual que n 00:08:06
perdón, menor o igual que n 00:08:11
incrementando i 00:08:15
pues el for me viene aquí estupendo 00:08:17
porque el for recordad 00:08:20
que cuando lo usamos con esta sintaxis 00:08:22
me da ya directamente una variable 00:08:25
que empieza valiendo el valor que yo le diga 00:08:27
se va incrementando aquí en cada iteración 00:08:30
y acaba cuando llega al valor que yo le diga 00:08:33
entonces pues perfecto, tengo ahí mi variable i 00:08:37
que son precisamente todos los sumandos 00:08:39
todos esos sumandos que yo quiero meter a la suma 00:08:41
son esos, la variable i, ya está 00:08:43
pues entonces la suma acumulativa en este caso 00:08:46
sería suma más igual i, ¿vale? 00:08:49
Pero ojo, el enunciado no dice sumar todos los números entre i y n mayúscula, 00:08:57
no dice sumarlos todos, dice suma sólo los que sean, 00:09:03
si es menor que 100, suma los que sean impares, suma sólo los que sean impares, 00:09:07
entonces tengo que sumar solo los i's 00:09:16
que sean impares, solo 00:09:19
ah, perdón, estoy entre 100 y n 00:09:21
si n es mayor que 100, estoy en el caso de abajo 00:09:27
si el número es mayor que 100, vale, los pares 00:09:29
vale, pues no tengo que hacer 00:09:33
no tengo que sumarlos todos, no tienen que ir a suma todos 00:09:35
solo tienen que ir los que sean pares, hemos dicho 00:09:39
vale, pues ya está, eso lo arreglamos así 00:09:42
Si el número i es par, es decir, el resto de dividirlo entre dos, resulta que este resto me da cero, pues entonces sí lo sumo, esta llave la puedo quitar si quiero, porque lo único que tiene el for dentro es esta sentencia i, ¿vale? 00:09:45
vale, pues entonces, 100 es mayor que 100 00:10:03
con esto me echo la suma acumulativa 00:10:07
de todos los pares 00:10:10
vale, pero me está diciendo 00:10:11
que no quiere la suma, sino quiere la media 00:10:13
la media es 00:10:16
esa suma dividida entre el total 00:10:18
de números que yo he sumado 00:10:20
entre el total de números que yo he sumado 00:10:21
vale, entonces, ¿qué nos falta incorporar aquí? 00:10:24
por ejemplo 00:10:30
tenemos que contar 00:10:31
todos los pares 00:10:33
comprendidos entre 00:10:35
n y 100 o entre 100 y n 00:10:37
todos los pares y ahora ya 00:10:39
que son los que hemos sumado, hemos sumado los pares 00:10:41
y ahora ya 00:10:43
pues la media será esa suma entre todos los pares 00:10:45
entonces lo más seguro 00:10:48
es que incorporemos un contador 00:10:50
que cuente, pero también 00:10:52
hombre, los pares comprendidos entre 00:10:53
100 y n, bueno entre n y 100 00:10:55
será la mitad de los números 00:10:58
entre n y 100 00:11:00
n-100 son los números que hay entre n y 100 00:11:00
pues la mitad de ellos eran los pares 00:11:03
pero vamos 00:11:04
que para hacerlo seguro 00:11:07
pues podríamos decir 00:11:09
ah vale, me falta un contador 00:11:11
pues ya está, contamos aquí 00:11:12
todos los numeritos pares que empiezan a 0 00:11:14
y ahora 00:11:16
si el número es par 00:11:18
incremento el contador 00:11:22
ya tengo un par más 00:11:26
y además lo sumo 00:11:31
Bueno, pues cuando ese fuera terminado tenemos aquí todos los números pares sumados que van entre 100 y n. 00:11:36
Y además nos dice cuántos hay, cuántos he sumado. 00:11:44
Ha sumado 7 números, ¿vale? 00:11:47
Si n es 105, pues habrá sumado el 100, el 102 y el 104. 00:11:50
Esos son los que habrá sumado el 100, el 102 y el 104. 00:11:59
y contador será 3 00:12:03
habrá habido 3 números 00:12:06
el 100, el 102 y el 104 00:12:09
contador será 3 00:12:11
y la suma será 100 más 102 más 104 00:12:12
lo que sea 00:12:16
bueno pues cuando haya acabado el for 00:12:17
ya podemos mostrar la media 00:12:19
que aquí la media será pues esto 00:12:21
la suma entre esto de aquí 00:12:30
bueno pues 100 es mayor que 100 00:12:37
ya lo tenemos 00:12:46
100 es mayor que 100 00:12:46
hay que hacer esta suma acumulativa de todos los números comprendidos entre 100 y n 00:12:47
pero como es media, pues además vamos a contarlos 00:12:51
y solo de los pares, 100 es menor que 100 00:12:55
entonces aquí vamos a ser estrictos porque 100 es igual a 100 00:13:01
pues se quedaba medio abierto, entonces si n es menor que 100 00:13:05
pues en realidad es lo mismo que de arriba 00:13:10
prácticamente, puedo copiar y pegar, lo único que tengo que cambiar son los extremos 00:13:17
de aquí, los extremos 00:13:21
y esto poner distinto 00:13:22
en vez de igual 00:13:25
pero puedo copiar y pegar este código 00:13:25
puedo copiar y pegarlo 00:13:28
y adaptarlo 00:13:38
contador de impares 00:13:39
ahora, el número es menor que 100 00:13:41
luego 00:13:48
el extremo inferior 00:13:49
del que yo parto es n 00:13:51
y el extremo superior es 100 00:13:53
y esto es distinto 00:13:56
y lo demás se queda todo intacto 00:14:03
vale 00:14:05
He hecho lo mismo, pero ahora ya, si el número es menor que 100, mediante este bucle for voy generando todos los números, empezando desde el n y acabando en el 100, los voy generando todos, con cada uno de ellos, si es impar, lo cuento, tengo uno más en la cuenta y lo sumo, en esa suma que empezó siendo 0, claro, cuando el for ha terminado, la media es, ahí tengo que cambiar la variable y ya está. 00:14:06
Ahora la pregunta natural es 00:14:42
Uy, 100 es igual a 100 00:14:46
¿Qué hago con él? 00:14:48
Porque los casos extremos siempre se quedan 00:14:49
Como abiertos en un enunciado 00:14:51
A veces se quedan abiertos 00:14:53
Es difícil especificar exactamente 00:14:56
En cada caso extremo que hacer 00:14:58
Entonces a la pregunta, ¿y con 100 qué hago? 00:14:59
Bueno, pues yo lo que os digo cuando preguntáis 00:15:02
Es, me da igual, que lo metáis en los extremos 00:15:04
Que lo hagáis aparte 00:15:06
Da lo mismo 00:15:08
Por ejemplo, en este caso 00:15:09
Si el número es 100 00:15:11
pues, si lo consideramos 00:15:13
como 00:15:16
en la parte de que fuera 00:15:16
menor, 100 menor que 100 00:15:20
sumo los pares, como es par 00:15:21
me quedaría 100, si lo consideramos 00:15:23
en la otra me quedaría 0, os dije, da igual 00:15:25
lo que os dé la gana 00:15:27
pues mira, vamos a poner aquí, ya está 00:15:28
el número es 100, el que me has dado 00:15:31
da igual, lo que sea, me da lo mismo 00:15:39
bueno, pues esta es 00:15:41
la resolución del ejercicio 00:15:48
teniendo en cuenta 00:15:52
esta escenita de aquí 00:15:55
nosotros nos hemos hecho este mapa 00:15:57
y hemos dicho, vale, ahora hay otra cosa 00:15:59
es que uno pueda retocar esto 00:16:01
para que le quede más corto, más bonito 00:16:03
para hacerlo con una función aparte 00:16:05
al que tú le pasas 00:16:08
pues el numerito n 00:16:09
y él ya esa función 00:16:11
ya detecta si es mayor o menor 00:16:14
que 100 y te hace la suma que sea 00:16:15
esto ya se puede retocar de muchas maneras 00:16:17
o por ejemplo, pues pensar 00:16:19
hombre, para qué arrastrar este if todo el rato, porque si yo aquí voy incrementando en lugar de uno en uno, incremento de dos en dos, 00:16:21
pues ya sé que todos los que se generen no son todos pares o son todos impares, a partir de aquí ya se pueden hacer un montón de modificaciones del código 00:16:35
para que haga lo mismo, pero que quede más cortito y más claro, ¿vale? Pero da igual, en realidad en el fondo da igual, 00:16:42
La máquina virtual va a hacer el mismo número de ejecuciones 00:16:50
Es solamente que el código 00:16:52
Pueda ser más claro, a lo mejor, o más bonito 00:16:54
Para quien lo vea 00:16:56
Pero a ver, lo importante es entender qué se hace de fondo 00:16:57
Y lo que se hace de fondo son estos bloques 00:17:03
Leo la entrada 00:17:05
Decido qué estructura de datos quiero para ella 00:17:06
La decido, fundamental 00:17:09
En este caso la decisión era muy clara 00:17:10
Un único número, una única variable 00:17:13
Vale, ¿cómo voy a tener que leer esa entrada? 00:17:15
Pues la tienes que leer verificándola 00:17:18
Pues ya sé 00:17:19
Y ahora ya, pues opero 00:17:20
opero y a partir de ahí decido 00:17:21
que tengo que hacer, pues es una suma, tengo que contar 00:17:24
tengo que hacer un máximo, tengo que 00:17:26
hacer lo que sea con esos datos 00:17:28
a ver, alguna pregunta o duda 00:17:29
o cosa rara, bueno 00:17:34
pues vamos con el siguiente 00:17:42
vale, pues este de aquí 00:17:43
ya tiene alguna cosa un poquito 00:18:14
es más sencillo y más corto de hacer 00:18:16
pero tiene una cosa un poquito más rara 00:18:18
porque ya implica tomar ciertas 00:18:20
decisiones de diseño, o sea 00:18:23
este no te dice, tienes que usar estas variables 00:18:24
No, tienes que decidir qué variables necesitas para que esto funcione. 00:18:26
Entonces, es un menú, después de leer uno esto varias veces, pues ya nos ronde que es un menú y cada opción hace cosas distintas. 00:18:32
Bueno, pues al menos la primera estructura la tenemos, porque sabemos hacer un menú, pues que es siempre lo mismo. 00:18:40
Un do while, do, muestra menú, lee opción y switch case en función de la opción y así todo el rato. 00:18:48
muestra menú, lee opción y switch case 00:18:55
en función de la opción, así todo el rato 00:18:57
o sea, la primera estructura la tenemos 00:18:59
ahora ya hay que ver 00:19:00
en cada opción que hay que hacer 00:19:02
entonces 00:19:05
uno se tiene que hacer 00:19:07
más o menos una visión así un poquito global 00:19:09
este menú lo que tiene 00:19:11
de raro es 00:19:13
que esta opción 00:19:15
solo se muestra 00:19:17
si se ha hecho 00:19:19
login antes 00:19:21
entonces 00:19:22
aquí ya pensamos 00:19:26
vamos a ver, yo tengo que detectar 00:19:28
de alguna manera 00:19:30
si el usuario 00:19:31
ha hecho login 00:19:35
previamente o no lo ha hecho 00:19:36
tengo que detectar si algo ha pasado 00:19:38
o no ha pasado 00:19:40
pues ahí automáticamente ya 00:19:41
se nos viene a la cabeza 00:19:44
uy en mi aplicación va a tener que haber un boolean 00:19:45
que me permita a mi 00:19:48
distinguir si hay 00:19:50
login hecho o si no lo hay 00:19:52
Porque en función de ese boolean, en función de si hay login hecho o no lo hay, esto se va a mostrar o no. 00:19:54
Entonces, primer elemento de diseño que era el más importante de esta aplicación, 00:20:03
el darnos cuenta de que para mostrar el menú necesitamos saber si algo pasa o no pasa. 00:20:07
Es decir, si se ha hecho login o no se ha hecho. 00:20:15
Porque este system out de aquí, ahora lo escribiremos, este system out, va a tener que ir en un if. 00:20:17
Es decir, oye, si se ha hecho login muestra esto y si no, no. Entonces, para saber si algo pasa o no pasa, para que eso quede registrado en mi programa y yo pueda trabajar con esa condición, tiene que haber un boolean. 00:20:22
pues un boolean tiene que haber 00:20:36
un boolean que sea usuario logado 00:20:38
por ejemplo, usuario logado 00:20:40
y ese boolean tendrá que estar 00:20:42
a true o a false, inicialmente 00:20:45
cuando la aplicación arranca 00:20:47
ese boolean estará a false 00:20:49
porque nadie se ha hecho login 00:20:50
claro, y cuando se va a poner a true 00:20:52
pues se va a poner a true 00:20:55
en el case de aquí 00:20:57
entonces ese boolean 00:20:59
ese boolean será un boolean que está ahí 00:21:02
que empieza siendo false 00:21:05
y que cuando se pone a true 00:21:06
cuando se dé esta opción 00:21:08
luego esta opción de aquí de hacer login 00:21:10
está sencilla como, bueno, primero pedir la contraseña 00:21:12
claro, y luego poner el boolean a true 00:21:15
y ahora ya 00:21:16
la siguiente vez que se muestre el menú 00:21:18
ya sí que saldrá esto 00:21:20
porque esta depende de ese boolean 00:21:22
entonces era una de las dos cosas 00:21:24
críticas del ejercicio 00:21:26
el identificar 00:21:28
que necesitamos un boolean para distinguir 00:21:30
dos situaciones, usuario logado 00:21:32
el identificar que tendríamos un Boolean 00:21:35
para distinguir dos situaciones 00:21:38
y luego ya la otra cosa crítica 00:21:40
pues hacer el tema de trabajar aquí 00:21:43
con los caracteres para validar la contraseña 00:21:45
eso ya era trabajar con la tabla ASCII 00:21:47
lo que se harán las dos partes del ejercicio 00:21:50
las dos en las que había dificultad 00:21:52
bueno, pues vamos a plantear entonces este 00:21:55
este menú 00:21:59
Si nosotros primero planteamos la primera arquitectura del ejercicio 00:22:02
Que es el do while de toda la vida 00:22:07
Con menú, leer opción y switch case 00:22:08
Primero planteamos eso 00:22:10
Ya nos vamos a ver 00:22:12
Que tenemos que hacer en cada case 00:22:13
Que variables vamos a necesitar, etc 00:22:15
Vale, pues venga 00:22:17
Hemos dicho que aquí va a haber un menú 00:22:25
A ver, las opciones serán 00:22:27
Establecer 00:22:33
O modificar, depende 00:22:37
Contraseña, voy a poner password por la ñ 00:22:40
Vale, está la opción 1, por ejemplo 00:22:44
La opción 2 00:22:50
Login, vale 00:22:57
La opción 3, logout, es la que vamos a tener que meter en un if 00:23:04
Y la opción 4 ya era salir, ¿verdad? 00:23:08
Login, logout y salir 00:23:18
Vale 00:23:20
Vale, leemos opción 00:23:22
Entonces, para leer opción, el escáner de siempre 00:23:34
Pues venga, el escáner 00:23:36
¿Vale? La opción, pues por ejemplo, va a ir a esta variable 00:23:38
Pues aquí leemos la opción 00:23:50
Ahora, esto ya me permite completar el while 00:23:54
Y digo, a ver, muestra menú, lee opción 00:24:09
Mientras que, mientras la opción sea diferente 00:24:13
¿De cuál? De 4, que es la de salir 00:24:16
vale, esta es la estructura de siempre 00:24:20
muestra menú, lee opción 00:24:24
el switch case que nos falta 00:24:26
por poner ahora y todo esto 00:24:28
mientras la opción leída sea 00:24:30
diferente a la de salir, así todo el rato 00:24:31
vale, pues aquí nuestro 00:24:33
switch case 00:24:36
va a depender de esa 00:24:37
variable opción 00:24:40
y ahora ya sabemos que esto 00:24:40
será en el caso 00:24:44
de que sea 1 00:24:45
pues habrá que ver que 00:24:49
hacemos, y break, y así con el resto de opciones, caso 2, caso 3, caso 4, el caso 4 es el más 00:24:51
fácil, el caso 4, cuando se dé la opción de salir, no hay nada que hacer, bueno, podemos 00:25:13
incluirle, para que quede un poco más bonito, esto y ya está, en el caso 4, hay poco que 00:25:18
hacer, vale, pues a ver, en el caso de que se dé la opción login, bueno, vamos a hacer 00:25:28
el primero de contraseña, vale, pues a ver, vamos a lo primero que hemos dicho, hemos 00:25:42
dicho, cuidado, vamos a empezar a retocar esto, esto de aquí ya hay que retocarlo, 00:25:48
eso no se tiene que mostrar siempre, el programa dice que eso se va a mostrar solo si estamos 00:25:53
en la situación de haber hecho login, solo en esa situación, entonces ese es el primer 00:26:00
sitio donde hay que atacar, de esta estructura general que hemos hecho, el primer sitio donde 00:26:06
hay que atacar para modificarlo es aquí, porque esto no se va a mostrar siempre, esto 00:26:10
se va a mostrar solo si ha habido un usuario que ha hecho login antes, solo, pues entonces 00:26:17
yo ahí tengo que poner un if para que eso se muestre solo si una situación se ha dado, 00:26:25
Vale, pues aquí es donde nos viene 00:26:29
La solución de antes 00:26:31
Ah, vale, como yo tengo que distinguir 00:26:33
Entre si hay usuario logado o no hay usuario logado 00:26:35
Como tengo que distinguir 00:26:37
Necesito un boolean 00:26:38
Para distinguir esas dos situaciones, la necesito 00:26:40
Pues nada, necesito un boolean para eso 00:26:43
Pues aquí viene mi boolean 00:26:46
Que uno lo llama como quiera 00:26:47
El nombre más explicativo posible 00:26:50
Como ese boolean significa 00:26:55
Que hay un usuario que ha hecho login antes 00:26:57
pues lo llamo usuario logado, vale, entonces ahora ya este if sería, si hay un usuario logado muestra la opción de logout, si no lo hay no, si no lo hay no, vale, como era previsible, claro eso me lo pone en rojo el compilador porque me dice, oye, yo llego aquí la primera vez de todas, llego aquí la primera vez y usuario logado está sin definir, está sin inicializar, 00:26:59
no puedo evaluar si eso es true o false 00:27:28
es imposible 00:27:30
bueno, pues entonces pensamos 00:27:32
ah, ¿cómo lo inicializo? 00:27:34
vale, ¿qué quiero yo que pase la primera vez? 00:27:36
la primera vez el usuario no está logado 00:27:38
es imposible, es la primera vez que muestro el menú 00:27:40
es la primera vez que lo muestro 00:27:42
la primera vez que lo muestro 00:27:43
es que no hay login 00:27:45
vale, pues entonces 00:27:46
esto inicialmente 00:27:49
false 00:27:51
bueno, pues entonces ahora ya 00:27:52
la primera vez que se arranca el programa 00:27:56
la primera vez la opción de logout 00:27:59
no se mostrará, claro, no se mostrará 00:28:01
es lo que queremos, que no se muestre 00:28:03
bueno 00:28:05
pues entonces 00:28:10
vamos con el resto de opciones 00:28:11
vamos una por una 00:28:14
caso 1 00:28:15
nos dice establecer 00:28:20
modificar contraseña 00:28:22
y aquí ya empieza diciéndome 00:28:24
de nuevo tienes dos situaciones posibles 00:28:26
a la hora de hacer esta opción 00:28:28
que ya tengas una contraseña 00:28:31
establecida de antes 00:28:33
o no 00:28:34
porque es la primera vez que se da la opción 00:28:35
porque es la primera vez que el usuario 00:28:38
da al 1, si es la primera vez que el usuario 00:28:39
da al 1 00:28:42
no hay una contraseña establecida 00:28:42
entonces aquí de nuevo 00:28:44
te dice, oye tienes dos ramas 00:28:46
aquí dentro de este case tienes dos posibilidades 00:28:49
que la contraseña 00:28:51
no esté porque es la primera vez 00:28:53
que le das a esa opción de establecer 00:28:55
o que la contraseña esté 00:28:57
si está, lo único que tienes que hacer 00:28:58
es pedir una nueva, validarla 00:29:01
y guardarla, si no está 00:29:03
tendrás también que pedir una nueva y validarla 00:29:05
pero antes 00:29:07
tendrás que pedir la antigua 00:29:08
y que te meta la antigua 00:29:10
y tú compruebes que la que te mete es igual 00:29:13
que la que tenías, entonces 00:29:15
lo primero para un organizarse es, oye 00:29:16
cuidado, que en ese case 1 tengo dos 00:29:19
posibilidades, que haya 00:29:21
contraseña establecida o que no lo haya, cuidado 00:29:23
tengo que trabajar de forma distinta 00:29:25
eso es lo primero, vale 00:29:26
bueno, pues esa condición 00:29:28
en que se basa 00:29:30
Lo que acabo de decir, que la contraseña de esa aplicación esté ya establecida o no. 00:29:32
Bueno, pues entonces es que, claro, necesito una variable que guarde la contraseña. 00:29:38
Necesito una variable para guardar la contraseña. 00:29:42
Y si esa variable tiene un valor o si no lo tiene, 00:29:44
no va a permitir a mí decidir si es la primera vez que he entrado o que no. 00:29:47
Pero una variable para guardar la contraseña la necesito. 00:29:52
Bueno, pues entonces, ¿la contraseña de qué tipo va a ser? 00:29:55
Pues de tipo string, ¿verdad? 00:29:59
vale, pues por ejemplo 00:30:00
esa puede ser 00:30:08
mi variable 00:30:09
para la contraseña, mi variable string 00:30:13
y ahora 00:30:15
en el caso 1 00:30:18
yo ahora aquí tengo que decidir 00:30:19
si esta variable contraseña 00:30:21
tiene ya algún valor 00:30:23
o no tiene ninguno 00:30:26
porque en función de si tiene algún valor o no tiene ninguno 00:30:27
estoy en el caso de establecer 00:30:30
o modificar 00:30:32
vale, tenemos que distinguir entonces si tiene algún valor o no tiene ninguno 00:30:33
Entonces, aquí uno puede operar de muchas maneras 00:30:36
Una, acordarse de lo que hemos dicho otras veces 00:30:39
Que las variables string son objetos en realidad 00:30:43
Y cuando no les doy ningún valor 00:30:48
Lo que tienen es null 00:30:50
Entonces, en el caso 1 00:30:51
Yo podría distinguir que la contraseña 00:30:54
Todavía no tiene ningún valor 00:30:57
Haciendo esto 00:30:58
Si password es igual a null 00:31:00
¿Vale? 00:31:04
y entonces, si password es igual a nulo 00:31:06
haz alguna cosa 00:31:11
y si no 00:31:12
hago otra 00:31:14
¿vale? 00:31:17
sí, sí, sí, podrías, lo que pasa es que el boolean 00:31:21
ese sería igual que poner password igual a nulo 00:31:23
entonces te ahorras ese boolean 00:31:26
si pones directamente la condición, pero podrías 00:31:27
hacer un boolean que fuera 00:31:29
¿existe contraseña o no existe? 00:31:31
el primero es por la función y el segundo es la contraseña 00:31:33
efectivamente 00:31:35
y entonces tiras de ese boolean 00:31:37
En lugar de tirar de la condición directamente 00:31:39
Lo que pasa es que aquí no te hace falta el boolean 00:31:41
Porque tienes esto para compararlo 00:31:44
En el otro caso 00:31:46
Tienes que tener el boolean 00:31:46
Porque es que no hay otra forma 00:31:48
De saber si el usuario está logado o no 00:31:49
Aquí tienes una forma de saberlo 00:31:51
Aparte del boolean 00:31:52
¿Vale? 00:31:53
Entonces 00:31:54
Que lo del null todavía son a chino 00:31:55
Porque no nos hemos metido en objetos ni nada 00:31:59
Pues uno tranquilamente podría decir 00:32:00
Oye 00:32:03
Mi password 00:32:04
la inicializo a esto 00:32:06
cuando mi aplicación arranca 00:32:09
cuando la aplicación arranca 00:32:11
mi password no tiene nada 00:32:13
está así, mi password no tiene nada 00:32:14
y entonces ahora yo digo 00:32:16
oye 00:32:19
si password 00:32:19
es igual 00:32:22
a esto 00:32:24
recordad que para comparar un string con otro 00:32:26
siempre se hace aquí 00:32:29
no con el doble igual 00:32:30
que me habéis comparado muchísimo 00:32:32
en los exámenes, un string con otro string con doble o igual, nunca se comparan con doble o igual, dos strings, se comparan así, entonces esta condición sería, si mi contraseña es igual al vacío, pues si mi contraseña es igual al vacío, entonces es la primera vez que entro en la aplicación, no la he establecido, porque si la hubiera establecido, la aplicación se habría encargado de constatar de que tiene al menos un carácter, al menos una minúscula, 00:32:34
Con lo cual, esa condición significa que es la primera vez que entro 00:33:01
No hay contraseña, es la primera vez que entro, no hay contraseña 00:33:06
Vale, pues ya tengo los dos casos distinguidos 00:33:09
Si es la primera vez que entro, tengo que hacer una cosa, que es esto 00:33:12
Y si es la segunda, tengo que hacer otra cosa, que es esto 00:33:15
¿Vale? Inicialmente no la tengo 00:33:18
Inicialmente, usuario logado, falso 00:33:20
E inicialmente la contraseña es vacía 00:33:23
Vale, pues ahora entro en la opción 1, establecer contraseña 00:33:26
Pues venga, ¿qué es la primera vez que entro? Porque no existe, ¿qué hay que hacer? Pues introduzca la nueva contraseña, la leemos y ahora ya meternos en ese bucle que la va validando mientras no cumple la condición de tener un carácter mayúsculo o no minúsculo y uno no sé qué. 00:33:31
Entonces, aquí le diríamos introduzca contraseña, entonces aquí la contraseña, uno pues la leería como leemos los string del teclado, que los leemos con next line, ¿vale? 00:33:52
y ahora de nuevo viene lo mismo 00:34:19
pasa lo de siempre, ya está 00:34:21
la leo y se acabó y ya paso 00:34:23
al siguiente case 00:34:25
no vale cualquier contraseña 00:34:28
no vale, vamos a tener 00:34:32
que meter esto en un bucle de verificación 00:34:34
otra vez lo mismo, esto en un while 00:34:35
para estarle pidiendo la 00:34:37
password una y otra vez, una y otra vez 00:34:39
mientras no cumpla que sea 00:34:41
válida, vale 00:34:43
pero al menos ya tenemos hecho bastante 00:34:45
O sea, ya el ejercicio está ya bastante orientado, ya he distinguido en este caso, ¿qué es la primera vez? Lo que tienes que hacer es pedir una nueva, ¿vale? Pides una nueva y la estableces, pero ojo, no vale cualquiera, si valiera cualquiera ya estaría esta parte, no vale cualquiera, pues de nuevo hay que meter esto en un bucle de verificación. 00:34:47
aquí el tema es que el bucle de verificación 00:35:07
no es tan sencillo como el anterior 00:35:10
mientras n sea menor que 0 00:35:11
no, aquí sería 00:35:13
mientras la password no cumpla 00:35:15
tener un icono mayúsculo, una minúscula y un no 00:35:17
o sea, eso no es tan fácil 00:35:20
expresar esa condición no es tan sencilla 00:35:21
pero en cualquier caso 00:35:23
habrá que meter esto en ese bucle 00:35:26
habrá que meter esto en un bucle 00:35:28
de tal manera 00:35:30
que nos aseguremos 00:35:39
de que se está en ese bucle 00:35:41
una y otra vez, una y otra vez, una y otra vez, mientras la password no cumpla la condición que uno quiere. 00:35:43
Cuando ya salga de ese bucle, la password cumple la condición que uno quiere. 00:35:51
Y aquí venía la mayor dificultad de este ejercicio, que es, ostras, ¿cómo expreso yo ahí la condición 00:35:56
de que la password tenga al menos una mayúscula, al menos una minúscula y al menos un número? 00:36:04
pues hombre, es una condición compleja 00:36:09
de evaluar, no es tan fácil 00:36:12
imaginaos que la condición fuera 00:36:14
nos hubieran dicho, oye 00:36:15
la password válida tiene que tener 00:36:18
exactamente 8 caracteres 00:36:20
por ejemplo, pues lo habrían puesto facilísimo 00:36:22
ponemos ahí 00:36:24
la condición password.length 00:36:26
igual a 8, ya está, ya tendríamos 00:36:28
la condición de validación 00:36:30
se quedaría un bucle de validación facilísimo 00:36:31
se está ahí todo el rato 00:36:34
mientras no llegue una password 00:36:36
cuya length, cuyo punto length 00:36:38
sea diferente de 8 00:36:40
ahí se está todo el rato 00:36:41
tendría una condición muy sencilla, ¿no? 00:36:43
pero claro, no me han dicho una condición tan sencilla como esa 00:36:45
me han dicho una cosa muy complicada 00:36:48
entonces, esa cosa tan complicada 00:36:49
no la puedo plantar aquí 00:36:52
no puedo plantar ahí en una única expresión 00:36:53
lo de tener al menos un mayúscula 00:36:55
tener al menos una minúscula y tener al menos un número 00:36:58
eso no lo puedo expresar en una condición 00:37:00
única, no puedo 00:37:02
tengo que averiguarlo mediante un for 00:37:03
ir contando caracteres, no puedo 00:37:05
¿vale? pues entonces 00:37:07
¿cómo lo hacemos? pues efectivamente 00:37:09
vamos a necesitar un boolean 00:37:11
para ver si la contraseña 00:37:12
es válida o no 00:37:15
que inicialmente sea falso 00:37:16
¿vale? 00:37:19
y ahora, entra la primera vez 00:37:26
¿no? inicialmente la contraseña 00:37:28
no es válida, es falso 00:37:31
con lo cual entra aquí, mientras 00:37:33
no sea válida, o sea 00:37:34
entra, y ahora yo aquí 00:37:35
ya evalúo, le doy 00:37:38
valor al válida en función del 00:37:40
password, me pongo a 00:37:42
contar mayúsculas, minúsculas 00:37:44
en función de eso, decido si válida 00:37:46
es true o false y la siguiente 00:37:48
vez que entre, si sigue 00:37:50
siendo válida igual a false 00:37:52
pues volverá a pedirla 00:37:54
si válida es igual a true, ya no la 00:37:56
pedirá, entonces ¿qué nos falta 00:37:58
aquí? pues hacer todas las 00:38:00
operaciones que haya que hacer 00:38:02
para ver si válida la puedo pasar a true 00:38:03
o no, o la tengo que dejar a false, a ver si la 00:38:06
puedo pasar a true o no 00:38:08
y aquí entonces que tenemos que hacer 00:38:09
pues recorrer password uno tras otro 00:38:12
los caracteres y se puede hacer 00:38:14
de muchas maneras, pues vamos a contar 00:38:16
las mayúsculas, las minúsculas 00:38:18
y los números y si todos 00:38:20
son mayores o iguales que uno 00:38:22
pues valida igual a true 00:38:24
podría ser la forma de hacerlo 00:38:25
por ejemplo vamos a hacer eso 00:38:28
vamos a contar 00:38:30
mayúsculas 00:38:32
minúsculas 00:38:35
y números 00:38:39
cifras 00:38:46
vamos a contarlos 00:38:48
y ahora 00:38:50
si una vez contados 00:38:51
ahora aquí habrá que contar 00:38:53
si una vez contados resulta 00:38:54
vamos a suponer que 00:38:56
los vamos a llamar así 00:38:57
habrá que ver cómo contamos 00:38:59
con mayús 00:39:02
inicialmente igual a cero 00:39:05
porque es un contador 00:39:08
con de minus inicialmente igual a cero 00:39:09
porque es un contador 00:39:13
y con de cifras 00:39:14
tendremos que contarnos 00:39:16
y una vez contado la condición de válida 00:39:20
pues será 00:39:23
era tener al menos 00:39:25
uno de cada 00:39:28
¿no? 00:39:29
pues la condición de válida será 00:39:30
con mayús mayor o igual que uno 00:39:32
Y con minus menor o igual que 1, mayor o igual que 1, con minus, y con cifras, con cifras mayor o igual que 1. 00:39:38
vale, pues una vez 00:40:15
una vez que tengamos esto contado 00:40:18
que nos falta contarlo, claro, nos falta aquí contarlo 00:40:21
una vez que tengamos contado 00:40:23
la condición de ser válida es esta 00:40:25
que se cumpla simultáneamente 00:40:27
que esto es mayor o igual que 1 00:40:29
y que esto es mayor o igual que 1 00:40:31
y que esto es mayor o igual que 1 00:40:33
si se cumplen las tres simultáneamente 00:40:35
las tres 00:40:37
entonces válida será true 00:40:38
cuando el bucle vuelva arriba 00:40:41
como resulta que ya es válida 00:40:43
esto es true, no true es false 00:40:46
pues ya no entra más 00:40:48
bueno pues esa es 00:40:49
mi bucle de validación de la contraseña 00:40:51
¿no? 00:40:54
recordar desde el principio como lo hemos montado 00:40:57
esta es la lectura de la contraseña 00:40:59
no me vale cualquier lectura 00:41:00
con lo cual tengo que meterla en un bucle 00:41:03
que se asegure de que 00:41:05
cumple una condición 00:41:07
esa condición es muy compleja 00:41:08
no puedo plantarla ahí, no es la condición 00:41:11
n mayor que 0, no, es una condición muy compleja 00:41:13
pues a través de un boolean, inicialmente no la cumple 00:41:17
y así entramos, y ahora aquí hacemos lo que haya que hacer 00:41:20
para ver si esa nueva contraseña 00:41:23
hace que este boolean pase a true 00:41:26
si hace que este boolean pase a true, ya está, ya lo tenemos 00:41:28
si no hace que pase a true, pues otra vez habrá que leerla 00:41:32
otra vez habrá que contar, etc. 00:41:35
¿Vale? Entonces, ¿qué nos faltará después? Pues hacer esta cuenta 00:41:40
es una cuenta rápida de hacer 00:41:43
hacerla y ya está 00:41:45
y luego en el ELSE será eso mismo 00:41:46
pero previamente haber pedido la antigua 00:41:49
etcétera 00:41:51
bueno vamos a parar aquí entonces 00:41:52
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
18 de diciembre de 2023 - 13:42
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
799.12 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid