Saltar navegación

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

Clase 04-03-24 - 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 6 de marzo de 2024 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, a ver, recordad 00:00:00
la mini aplicación en la que estábamos 00:00:03
para repasar esto de listas 00:00:05
para revisar esto de listas 00:00:06
recordad que en esta 00:00:08
aplicación que estábamos 00:00:11
estábamos trabajando 00:00:12
con silencio 00:00:14
¿por qué estáis hablando todos 00:00:17
entre vosotros? 00:00:18
Andoni 00:00:21
¿cómo que no? 00:00:22
¿estarás cantando? ¿movíais la boca? 00:00:25
silencio 00:00:27
el ruido de fondo me distrae 00:00:32
vale, pues entonces 00:00:35
esta aplicación nuestra trabajaba 00:00:38
con un conjunto de alumnos 00:00:40
¿vale? 00:00:42
recordad siempre, cuando uno 00:00:45
hace una aplicación, aunque esa parte 00:00:46
la obviemos 00:00:48
yo insisto en ello continuamente porque es 00:00:49
la parte más importante del desarrollo 00:00:52
la parte más importante del desarrollo 00:00:54
Claudia, también está previo a reírse 00:00:56
silencio 00:00:58
la parte más importante del desarrollo 00:01:01
en realidad no es la que estamos haciendo 00:01:04
aquí nosotros 00:01:06
porque esa casi que 00:01:07
si tú tienes claro lo que quieres hacer casi que te la hace 00:01:09
echar GPT, esa no es la más importante 00:01:12
la importante y en la que echar 00:01:14
GPT no te sustituye 00:01:16
es en entender exactamente 00:01:17
lo que el cliente quiere 00:01:20
esa es la parte más importante 00:01:22
en entender exactamente 00:01:24
cuál es su material de trabajo 00:01:26
qué necesita gestionar, qué requisitos son los que necesita satisfacer para cubrir sus necesidades. 00:01:27
Esa es la parte más importante del desarrollo. 00:01:35
Entonces, siempre hay que contextualizar el problema ahí, 00:01:39
decir, pero vamos a ver qué estoy gestionando yo, qué necesito hacer. 00:01:43
Y para todo eso se dedicará el tiempo que haga falta. 00:01:46
Se describirá, se tomarán notas, se tratará de entender el problema en profundidad, 00:01:49
se pondrá en 00:01:54
se hablará 00:01:56
con el cliente todas las veces que haga falta hasta tenerlo 00:01:58
claro, se le harán 00:02:00
prototipos, interfaces gráficas 00:02:02
este es el tipo de aplicación que tú quieres ver, etc 00:02:04
vale, bueno pues en nuestro 00:02:06
caso se trataba de 00:02:08
una secretaría que quería gestionar 00:02:10
alumnos, entonces 00:02:12
nuestro volumen de datos 00:02:14
era un conjunto de alumnos 00:02:15
lo normal entonces es diseñar 00:02:17
unas tablas en una base de datos 00:02:20
alumnos, asignaturas 00:02:22
relaciones entre alumnos, asignaturas 00:02:24
de las que está, vale, eso que estáis 00:02:26
tratando en base de datos 00:02:28
¿vale? base de datos relacionales 00:02:30
que son las que se siguen utilizando 00:02:32
bueno, en nuestro caso 00:02:33
la parte de poner en contacto la base 00:02:35
de datos con la aplicación no la sabemos 00:02:38
hacer todavía, esa ya la haremos el año 00:02:40
que viene, con lo cual nuestros 00:02:42
datos ya van a estar directamente en 00:02:44
la aplicación, ¿y cuáles 00:02:46
iban a ser nuestros datos? un montón de 00:02:48
alumnos. Un montón de alumnos, pues 00:02:50
ala, aquí están, un montón de alumnos. 00:02:52
Un montón de alumnos aquí. Ahora ya 00:02:55
no nos hace falta un array porque 00:02:58
es engorroso, es lo más 00:02:59
eficiente del mundo y lo mejor, por supuesto, 00:03:02
computacionalmente sí, 00:03:04
pero es engorroso 00:03:06
para programar con él. 00:03:07
Engorroso para programar. Pues entonces 00:03:10
una lista, ¿vale? 00:03:12
¿Qué implementación? Venga, una lista enlazada 00:03:14
que es muy buena y muy estupenda 00:03:16
para meter y sacar. 00:03:17
¿vale? Para consultar un ArrayList, 00:03:21
pero para meterse acá un LinkedList. Pues este 00:03:23
es nuestro volumen 00:03:25
de datos, los alumnos. 00:03:27
Ahora, ¿y esos alumnos, qué 00:03:29
nos interesa de ellos? Pues 00:03:31
después de hablar con el cliente, que en este caso 00:03:33
es el secretario de la secretaría, mil veces 00:03:35
nos ha dicho, lo único que yo quiero 00:03:37
de los alumnos, la única información que yo 00:03:38
necesito, es su número de matrícula, 00:03:41
su nombre, su edad y las denuncias de las que está matriculado. 00:03:43
Pues de ahí viene este diseño 00:03:46
de clase, que hemos tenido la 00:03:47
suerte de que no depende de otras 00:03:49
clases, podría depender de 00:03:51
otras, porque la asignatura 00:03:53
a lo mejor me dice el secretario, oye de cada asignatura 00:03:55
no me basta el nombre 00:03:57
de una asignatura, además 00:03:59
del nombre, necesito saber 00:04:01
los créditos que tiene 00:04:03
lo que cuesta su 00:04:04
matrícula, lo que sea, pues 00:04:07
entonces tendríamos que hacer otra 00:04:09
clase, asignatura 00:04:11
con sus propiedades, nombre 00:04:13
número de créditos, etcétera 00:04:15
este list sería de asignatura 00:04:17
entonces ya tendríamos un modelo de clases 00:04:19
con dos clases, alumno y asignatura 00:04:22
¿vale? y ya estaríamos en el diseño 00:04:24
en nuestro caso lo hemos simplificado porque lo único 00:04:26
que queríamos es usar esta 00:04:28
aplicación pequeñita para 00:04:30
poner ejemplos de los métodos de las listas 00:04:32
solamente para eso, pues en este 00:04:34
caso alumno no depende de ninguna otra clase 00:04:36
solamente de string, pero string ya está hecha 00:04:38
no tenemos que hacerla, ¿vale? como asignaturas 00:04:40
pueden ser muchas, pues de nuevo una lista 00:04:42
una array, bueno una array está 00:04:44
muy bien, de nuevo 00:04:46
pero engorroso para programar 00:04:47
maravilloso para ejecutar 00:04:50
lo mejor del mundo 00:04:52
si lo hiciéramos todo con Array 00:04:53
los programas serían muchísimo mejores 00:04:54
pero engorrosos en el momento 00:04:56
de estar sentado que quedan 00:04:59
y como ahora los ordenadores 00:05:00
son muy rápidos 00:05:02
pues pesa más la vaguería 00:05:04
y decir mira 00:05:07
voy a lo fácil que es trabajar 00:05:08
con estas clases 00:05:10
voy a lo fácil a la hora de programar 00:05:12
aunque computacionalmente sea peor que un Array 00:05:14
Porque total 00:05:17
Si el ordenador va a ser muy rápido y lo va a ejecutar bien 00:05:18
Bueno, pues entonces 00:05:21
Una lista de asignaturas 00:05:24
Los get y los set y ya está 00:05:25
Y luego ya los requisitos 00:05:27
Que nos había dicho 00:05:30
El secretario que quería hacer 00:05:32
Pues en principio eran los que habíamos 00:05:33
Escrito por aquí 00:05:35
En su momento, esto de aquí 00:05:38
Y eso estábamos haciendo el otro día, ¿verdad? 00:05:39
Bueno, pues entonces 00:05:42
Vámonos al método 00:05:43
¿Qué métodos habíamos hecho? 00:05:45
mostrar datos de un alumno dado su matrícula. 00:05:48
Pues nada, habíamos recorrido la colección, 00:05:51
la habíamos recorrido y una vez que habíamos encontrado uno 00:05:53
con esa matrícula, mostrábamos los datos. 00:05:55
Vale, bueno, los devolvíamos. 00:05:58
Habíamos usado este método, mostrar datos, 00:06:01
para ver diferentes formas de recorrer una colección, 00:06:03
una lista. 00:06:08
El for de índice, a través de este método get, 00:06:09
me da todos los alumnos de la lista. 00:06:12
el for each 00:06:15
el for each 00:06:17
de esta manera 00:06:19
¿vale? en el cual a 00:06:20
en cada iteración 00:06:23
va siendo una copia de cada uno 00:06:24
de los elementos de esta lista 00:06:27
¿vale? 00:06:29
menos eficiente 00:06:31
que el for the índice 00:06:32
porque aquí trabajo directamente 00:06:34
con una 00:06:37
con la referencia 00:06:38
al objeto de la lista 00:06:41
que es esta 00:06:43
aquí trabajo con una copia 00:06:44
de la referencia, apunto al mismo sitio 00:06:47
pero apunto a través de una copia 00:06:49
¿vale? ya lo vimos con los arrays 00:06:51
pero es cómodo, es cómodo de escribir 00:06:53
y ya está 00:06:55
y el literador, que es la opción 00:06:56
más segura para recorrer 00:06:59
una lista 00:07:01
o una colección en general 00:07:02
cuando estamos trabajando 00:07:05
con la programación multilo, etc. 00:07:06
entonces el literador 00:07:10
otra forma de recorrerla 00:07:12
ya vimos también cómo funcionaba 00:07:13
genero el objeto iterador 00:07:14
que es una especie de puntero 00:07:16
que va avanzando mediante este método 00:07:18
va avanzando 00:07:20
y en cada avance 00:07:21
me devuelve un alumno 00:07:23
de esa colección 00:07:26
y como este método me dice 00:07:27
si tengo otro más o no 00:07:29
pues lo usamos como condición del while 00:07:31
bueno pues 00:07:33
eso en cuanto al método 00:07:35
mostrar datos 00:07:37
que lo usamos 00:07:38
para ver tres diferentes maneras 00:07:41
De recorrer la lista 00:07:43
Vale, bueno, insertar alumno 00:07:44
Que lo único que hacía era añadir el alumno a la lista 00:07:47
Y ya está 00:07:49
Matricular alumno 00:07:50
Pues recorríamos 00:07:53
Hasta que encontrábamos un alumno 00:07:54
Con esa matrícula y cuando lo encontrábamos 00:07:58
Le añadíamos su asignatura a la lista de asignaturas 00:08:00
Luego matricular alumno 00:08:02
Era sencillo 00:08:04
Vale 00:08:06
Entonces este método 00:08:07
Este método 00:08:11
es sencillo, ahora que ya 00:08:14
estáis muy familiarizados con todo 00:08:17
y ya tenéis mucha soltura 00:08:19
uno ve este método así de golpe y porrazo 00:08:22
matricular alumno 00:08:25
con este número de matrícula 00:08:26
de la asignatura que yo doy aquí 00:08:29
entonces soy los 00:08:31
jefes y dicen, ah ya tengo el método 00:08:33
te lo enseño, así, ala 00:08:35
y ya tengo el método hecho 00:08:37
¿le haríais algún comentario? 00:08:39
este código como tal 00:08:50
bueno, hace lo que tiene que hacer, recorre esta lista 00:08:51
posición por posición, cuando encuentra un alumno 00:08:56
cuyo número de matrícula es igual al que me han dado, pues coge las asignaturas 00:09:01
de ese alumno y le añade la nueva 00:09:05
pero ¿le haríais algún comentario al que hizo este método? 00:09:07
exacto, yo si le haría un comentario le diría, oye cuidado, este método 00:09:16
que peligroso es, porque siempre 00:09:19
que hay un objeto que llama 00:09:24
algo, si ese objeto 00:09:25
existe la posibilidad de que sea null 00:09:28
ya sabéis que sale un null 00:09:30
pointer exception y eso que hace 00:09:32
para la aplicación, no es que te dé 00:09:33
un error y no te lo 00:09:36
haga y la aplicación siga ofreciéndote 00:09:38
el menú, no, es que la aplicación se ha 00:09:40
roto, se ha parado, se ha roto 00:09:42
y encima te muestra 00:09:43
unas líneas rojas y se ha roto 00:09:45
entonces eso es lo último que queremos cuando 00:09:47
entregamos una aplicación, que pase algo 00:09:49
que la pare 00:09:51
y que no puedas trabajar 00:09:52
y que tengas que llamar al servicio 00:09:55
técnico y decir, oye, lánzame la aplicación otra vez 00:09:58
porque es que esto no funciona, no queremos eso 00:10:00
entonces, hombre, si es un comentario 00:10:01
pues que estaría bien hacerle, decirle, oye 00:10:03
cuidado con el posible null 00:10:05
pointer exception 00:10:07
si la lista de alumnos 00:10:08
no existe 00:10:12
todavía, si es null 00:10:14
cuidado 00:10:15
¿vale? 00:10:16
entonces, bueno, esto para que nos vayamos acostumbrando 00:10:20
a ver estas cosas 00:10:22
por ejemplo uno podría hacer esto 00:10:23
si alumnos 00:10:25
es igual a null 00:10:28
porque vamos a ver 00:10:29
este método puede estar 00:10:32
dentro de una aplicación donde 00:10:34
alumnos siempre se inicializa 00:10:36
y todo eso, pero eso 00:10:38
este método no lo sabe 00:10:40
este es un método que le llamará a quien quiera 00:10:41
y él no tiene ni idea de quien le va a llamar 00:10:44
le va a llamar una clase que ha hecho 00:10:46
esa otra persona 00:10:48
y este no tiene por qué saber 00:10:49
que el que le llame 00:10:51
seguro que ha inicializado a alumnos 00:10:53
no tiene por qué saberlo 00:10:55
entonces tiene que protegerse de eso 00:10:56
un método cuanto más protegido esté 00:10:58
de excepciones mejor 00:11:00
entonces aquí 00:11:01
pues por ejemplo 00:11:03
no estaría mal hacer algo así 00:11:05
que alumnos resulta que no se ha inicializado 00:11:06
porque no 00:11:12
bueno porque la aplicación 00:11:13
que está usando este método 00:11:15
no lo inicializa 00:11:16
hasta que no insertas un alumno al principio 00:11:18
lo que sea 00:11:21
pues entonces en este caso 00:11:21
1 es igual a null 00:11:23
aquí y ya está 00:11:24
y aquí que pondríamos 00:11:37
y aquí que palabrita 00:11:39
mágica pondríais 00:11:43
return 00:11:45
esa es la palabra magia que pondríais ahí 00:11:48
return 00:11:51
se acabó el método 00:11:53
return fuera 00:11:54
si llegamos aquí 00:11:55
es porque efectivamente alumnos no es null 00:11:58
con lo cual null pointer 00:12:01
exception ya no vas a tener 00:12:03
puede ser que encuentres al alumno o que no lo encuentres 00:12:04
pero al menos null pointer exception 00:12:07
no vas a tener 00:12:09
¿vale? 00:12:10
esto que yo he puesto 00:12:16
aquí, en realidad es un poco 00:12:17
feo, porque yo estoy confiando 00:12:19
en que el que ejecuta la aplicación 00:12:21
tenga una consola 00:12:23
para ver los mensajitos 00:12:24
pero es que, con lo que 00:12:26
sabemos nosotros ahora, no tengo otra forma 00:12:29
de comunicarme con él, no tengo otra manera 00:12:31
lo normal es que 00:12:32
esto se enviara a un fichero de log 00:12:35
pero nosotros no sabemos manejar los ficheros de log 00:12:37
todavía y nada de eso 00:12:39
pero si sabéis lo que es un fichero 00:12:40
de log en general 00:12:43
cuando una aplicación se está ejecutando 00:12:44
esa aplicación se está ejecutando 00:12:47
le pueden pasar cosas 00:12:49
pues de repente se ha conectado un usuario 00:12:51
ahora ha hecho un acceso 00:12:53
ha hecho un acceso inválido a la base de datos 00:12:54
entonces la aplicación a la vez que va 00:12:57
ejecutando cosas va enviando 00:12:59
a un fichero un registro 00:13:01
de lo que va haciendo, un ficherito 00:13:03
es transparente para el que está usando la aplicación 00:13:04
el que está usando la aplicación no sabe 00:13:07
pero la aplicación 00:13:09
va mandando mensajitos a un fichero 00:13:10
que se quedan ahí guardaditos 00:13:13
entonces, ¿qué ocurre si de repente 00:13:15
te llama a ti alguien y dice 00:13:17
oye, que la aplicación ha fallado, a las 11 y 25 00:13:18
me ha fallado 00:13:21
pues tú te vas a ese ficherito 00:13:21
donde se ha quedado un registro de todo lo que ha pasado 00:13:24
y a lo mejor ves 00:13:26
11 y 25, acceso inválido 00:13:28
de usuario y contraseña, yo que sé 00:13:31
lo que sea, y le dices, ah pues es que 00:13:33
a las 11.25 pasó esto 00:13:35
entonces es la manera normal 00:13:36
de llevar un registro 00:13:39
de cuando las cosas no han ido bien 00:13:41
lo que pasa es que nosotros no sabemos crear ficheros de logs 00:13:42
todavía desde una aplicación 00:13:45
luego la información de que no hay 00:13:46
alumnos creados, la mando por 00:13:49
consola ya 00:13:51
pero vamos, a mi lo que me importa ahora 00:13:51
es que vayáis viendo situaciones 00:13:57
peligrosas, según veáis el código 00:13:59
y esta es una situación peligrosa 00:14:01
este método está asumiendo 00:14:03
que alumnos es diferente de null, pues es mucho asumir 00:14:05
a lo mejor no es diferente de null 00:14:07
entonces hay que identificar situaciones peligrosas 00:14:08
y este método también se va quedando un poco cojo 00:14:10
porque si 00:14:13
el alumno 00:14:14
está encontrado 00:14:18
le añade la asignatura, pero si el alumno no existe 00:14:21
no hace nada 00:14:23
entonces también se queda un poco cojo el método 00:14:24
porque la aplicación cuando lo llama 00:14:27
no sabe 00:14:29
no sabe si 00:14:31
realmente se insertó 00:14:33
o no se insertó alumno 00:14:35
no lo sabe, perdón, no sabe 00:14:36
si se encontró alumno para 00:14:39
matricularse en Natura o no, no lo sabe 00:14:41
puede haberse encontrado 00:14:43
y haberse añadido o pueden haberse encontrado 00:14:45
porque no existe 00:14:47
entonces a ver, funciona, funciona 00:14:48
pero es un método poco amigable 00:14:50
poco amigable, también sería bonito 00:14:52
incorporar una realimentación 00:14:54
que te diga, encontré alumno o no encontré 00:14:57
alumno, ¿verdad? 00:14:59
bien por consola o bien porque lo lleva a un registro de log 00:15:00
¿se insertó asignatura? 00:15:03
no se insertó pero no encontró alumno 00:15:05
está bien que tenga una realimentación 00:15:06
¿vale? ¿qué haríamos ahí 00:15:08
para poner una realimentación? 00:15:10
claro, el famoso boolean que te detecte 00:15:17
si has entrado aquí alguna vez o no 00:15:19
el famoso boolean que te diga si algo ha pasado o no 00:15:20
entonces, hombre, esto estaría 00:15:23
más bonito, por ejemplo 00:15:25
si hacemos esto 00:15:29
asumimos de partida 00:15:30
que no existe alumno 00:15:34
y ahora 00:15:35
cuando hemos encontrado el alumno 00:15:37
cuando hemos encontrado el alumno 00:15:42
pues avisamos 00:15:44
y decimos, ala 00:15:47
encontré 00:15:49
he encontrado alumno 00:15:50
¿vale? 00:15:53
y ahora ya 00:15:54
con este mecanismo de control 00:15:55
de partida no tengo, pero si resulta 00:15:57
que lo he encontrado, lo cambio 00:16:00
pues con este mecanismo de control 00:16:01
el mecanismo de control que ya vimos en la primera evaluación 00:16:03
de toda la vida, cuando ya el for ha terminado 00:16:06
ya sabemos si encontró alumno o no 00:16:09
entonces si lo encontró 00:16:15
pues decimos, se matriculó al alumno 00:16:17
de la asignatura, por ejemplo 00:16:26
o le decimos, no se encontró alumno 00:16:32
por ejemplo, vale 00:16:44
y de paso podemos usar este boolean 00:16:50
para que este for no esté hasta el infinito 00:16:54
una vez que ha encontrado el alumno 00:16:56
que ya no siga 00:16:58
ya de paso que lo tenemos 00:17:00
porque si lo ha encontrado el primero 00:17:02
y tenemos mil alumnos 00:17:04
este for va a seguir 00:17:06
hombre, si ya lo has encontrado no sigas 00:17:07
entonces ya que tenemos ese boolean 00:17:10
aprovechemos y situemos el boolean 00:17:12
¿dónde? 00:17:14
para parar el bucle cuando 00:17:16
ya lo haya encontrado 00:17:18
¿dónde haríamos aquí la modificación? 00:17:19
¿en qué parte? 00:17:23
para que el bucle pare cuando ya ha encontrado el 1 00:17:23
claro, modificamos la condición 00:17:29
para que el bucle siga 00:17:33
tanto cuando no ha llegado al final 00:17:35
pero también cuando no lo ha encontrado todavía 00:17:38
es decir, mientras no hayas llegado al final 00:17:41
y no lo hayas encontrado 00:17:43
mientras se den simultáneamente 00:17:48
las dos cosas 00:17:52
que no hayas llegado al final y no lo hayas encontrado 00:17:52
cuando se den simultáneamente las dos, sigues 00:17:56
de tal manera que cuando ya lo hayas 00:17:58
encontrado, esto es true 00:18:02
con lo cual esto será false 00:18:04
porque es un no delante, será false 00:18:05
y el bucle ya se parará 00:18:08
¿vale? 00:18:09
es bueno, lo de siempre 00:18:12
bueno, pues incorporar estas cosas 00:18:14
hacen nuestros códigos 00:18:18
un poquito mejores 00:18:20
vale, pues esto en cuanto a 00:18:22
matricular alumno, lo podemos mejorar 00:18:26
un poquito de esta manera 00:18:27
ahora este 00:18:29
a donde queríamos ir a parar 00:18:33
vale 00:18:35
desmatricular alumno de una asignatura 00:18:36
número de matrícula, asignatura 00:18:40
lo mismo 00:18:44
recorremos esto, podríamos añadirle 00:18:45
el encontrado también 00:18:48
para que nos diga si lo ha encontrado o no 00:18:49
para desmatricularle y aparte que pare el bucle 00:18:51
vale, pues cuando ha encontrado 00:18:53
al alumno con ese número 00:18:56
de matrícula teníamos 00:19:00
el método remove 00:19:02
al que le pasas un elemento 00:19:03
de la lista 00:19:06
entonces 00:19:07
getAsignaturas es la lista 00:19:08
de string de asignaturas 00:19:12
le pasamos un objeto string 00:19:13
que es la asignatura borrar 00:19:15
y que hace el método remove 00:19:17
se va a esta lista y te elimina 00:19:19
la primera 00:19:22
de las apariciones de este objeto 00:19:23
en esta lista, la primera 00:19:25
entonces le pasamos lengua 00:19:27
en cuanto encuentre el string lengua 00:19:28
las asignaturas lo eliminen 00:19:31
¿que hay más string lengua? no, solo te borra el primero 00:19:32
entonces ¿qué queremos hacer? 00:19:36
si está matriculado de lengua 00:19:38
mates lengua 00:19:39
¿queremos que elimine solo la primera lengua o las dos? 00:19:40
pues depende, habría que hablar con el secretario 00:19:44
y decirle, oye, es probable 00:19:46
es probable que 00:19:47
un alumno pueda estar matriculado 00:19:49
en su lista varias veces de la misma 00:19:51
porque te hayas equivocado al meter los datos 00:19:53
puede ser que eso ocurra 00:19:55
Y en el caso de que ocurra, si yo desmatriculo de lengua, ¿quieres que desaparezcan todas o solo la primera? 00:19:57
Pues bueno, solo sería cuestión de hablarlo con él a ver exactamente cómo va a funcionar la aplicación. 00:20:04
Lo que nos importa a nosotros es entender que este método te borra la primera de las apariciones de este objeto en la lista. 00:20:09
Vale, entonces, y además te devuelve true o false si encontró o no encontró. 00:20:17
por eso si queríamos 00:20:22
si queremos que te las borre todas 00:20:24
las de este objeto 00:20:26
pues lo tenemos tan fácil como meterlo en un while 00:20:27
¿vale? 00:20:30
que es lo que hicimos el otro día 00:20:32
el while tiene esto como 00:20:33
condición, luego no tiene cuerpo, luego se acaba 00:20:36
en un punto y coma, no tiene cuerpo 00:20:38
entonces te hace el primer remove 00:20:40
si encontró te devuelve true 00:20:42
con lo cual entra de nuevo a buscar 00:20:44
el segundo remove, si sigue encontrando 00:20:46
te devuelve true 00:20:48
y entra de nuevo al siguiente 00:20:50
así hasta que ya no encuentre más 00:20:52
apariciones, para lo cual devolverá 00:20:53
falso y ya saldrá el while 00:20:55
vale, pues entonces 00:20:56
el otro método que tenemos 00:20:59
relacionado con remove 00:21:02
el remove all 00:21:04
vale 00:21:10
el remove all, hay que pasarle una colección 00:21:11
no solo un objeto como aquí 00:21:14
no solo un objeto 00:21:16
hay que pasarle una colección 00:21:17
de varias cosas, lengua, matemática 00:21:19
física, lo que sea, una colección de cosas 00:21:22
hay que pasarle una colección 00:21:24
¿Y qué hace? Pues todo lo que hay aquí, lengua, mates, física, todo lo que haya, te lo elimina de la colección, pero todas las apariciones, o sea, si hay dos lenguas, dos mates, tres físicas, te elimina las dos lenguas, las tres mates, las dos físicas, todas, ¿vale? Todas. 00:21:26
Para ello, pues te hace un iterador 00:21:44
para recorrer la colección, 00:21:46
hace un meollo dentro importante. 00:21:47
Te lo metéis dentro a verlo. 00:21:49
Entonces, para borrar todas las apariciones 00:21:51
de una sola asignatura, 00:21:53
esto que hemos hecho aquí arriba, 00:21:56
esto de aquí, 00:21:58
lo podríamos efectivamente, 00:21:59
que es lo que tú dijiste el otro día, 00:22:00
si lo podríamos hacer así, pues sí, 00:22:01
podríamos hacer una lista, 00:22:04
meter en esa lista ese único objeto, 00:22:06
una lista de un único objeto, de uno. 00:22:08
Y ahora al remufol pasarle eso. 00:22:11
y esto haría lo mismo que lo de arriba 00:22:12
pero hombre, es bastante más complicado 00:22:15
porque el remove all 00:22:17
luego te hace por dentro, no solo el while 00:22:19
sino es que te saca un iterador 00:22:21
entonces tú aparte se hace una variable 00:22:22
adicional, metiendo, pasando 00:22:25
pero efectivamente esto 00:22:27
te haría lo mismo que esto, aunque lo de arriba 00:22:29
es más sencillo 00:22:31
menos instrucciones, menos sentencias 00:22:33
remove all tiene 00:22:35
muchas más dentro, muchísimas más que remove 00:22:37
¿vale? 00:22:39
entonces remove all 00:22:45
El uso que se le suele dar es cuando queremos borrar 00:22:46
Varias diferentes de golpe 00:22:48
Si queremos borrar varias diferentes 00:22:50
Entonces sí, hay que hacerlo con el remove all sí o sí 00:22:52
Porque el remove a palo seco 00:22:55
Te borra una 00:22:57
Si yo quiero borrar varias lengua, mates, física 00:22:58
Pues lo tengo que hacer con este 00:23:01
Ahí sí que sí 00:23:03
¿Vale? 00:23:04
Vale, pues dejo esto comentado aquí 00:23:06
Y lo pongo así 00:23:09
Vale, ¿qué más métodos llegamos a hacer? 00:23:18
Aparte de desmatricular 00:23:34
bueno, hicimos eliminar 00:23:35
alumno de la colección 00:23:37
¿vale? para verlo 00:23:38
del equals, que esto fue ya lo último que hicimos 00:23:41
¿vale? 00:23:43
hicimos este método 00:23:45
para dejar claro que remove 00:23:46
por dentro, o sea que uno 00:23:49
cuando uno hace algo que lo haga llamando a un método 00:23:51
no significa que sea una única 00:23:53
sentencia, no, lo que está llamando es a un método 00:23:55
y este método dentro hace ahí 00:23:57
la leche 00:23:59
¿vale? hace ahí la leche 00:24:00
lo ideal sería que uno lo programara 00:24:02
él todo, todo, y no tuviera que utilizar 00:24:05
clases, ni colecciones, ni listas 00:24:07
ni nada, porque lo programara uno todo 00:24:09
con las estructuras básicas 00:24:11
con los for, los while, los if 00:24:13
y los arrays, porque eso es 00:24:15
lo único que hay 00:24:17
todo lo demás son clases con métodos 00:24:18
que usan todo eso 00:24:21
entonces nosotros delegamos 00:24:23
llamamos a métodos que usan eso para hacer las cosas 00:24:25
y confiamos en que lo hacen bien 00:24:27
pero a saber cómo están esos por dentro 00:24:28
lo ideal es que uno lo hiciera todo 00:24:31
pero claro, le quedarían programas 00:24:34
gigantes, larguísimos 00:24:36
poco manejables 00:24:39
por eso reutilizamos clases 00:24:40
que ya están hechas y vamos a sus métodos 00:24:42
pero por comodidad 00:24:44
ahora desarrollar código, no porque sea mejor 00:24:45
no porque sea mejor 00:24:48
pero es que llega un momento en que tienes que tirar 00:24:49
de código de otros, porque es que si no 00:24:53
tus programas, cada uno de ellos tendría 00:24:55
50.000 líneas 00:24:57
bueno, pues eliminar 00:24:59
alumno lo incorporamos 00:25:02
para revisarlo de 00:25:03
equals. ¿Qué hace 00:25:05
Remus? Pues ya lo hemos dicho. 00:25:07
Coge este objeto, 00:25:10
se pone a iterar en esta lista, 00:25:12
se pone a iterar, y en cuanto 00:25:14
encuentra uno igual 00:25:16
a él, lo elimina. 00:25:17
Y ya está. En cuanto 00:25:20
encuentra uno igual a él. 00:25:22
Por eso, importante 00:25:24
que si 00:25:25
la colección 00:25:27
es de la clase alumno, de la clase 00:25:28
Pepito, pues esa clase tenga el criterio 00:25:32
de igualdad implementado 00:25:34
porque si no remove va a usar el criterio de igualdad 00:25:35
de object, que es 00:25:38
el mismo objeto uno encima de otro 00:25:40
o sea, misma dirección de memoria 00:25:42
¿vale? entonces aquí 00:25:43
como alumno teníamos el criterio de 00:25:46
igualdad implementado 00:25:48
en la colección alumnos que es de alumno 00:25:49
teníamos el criterio de igualdad implementado 00:25:51
y alumno tenía como criterio 00:25:54
de igualdad 00:25:56
el número de matrícula, ese era el criterio 00:25:56
de igualdad, dos alumnos con mismo número de matrícula 00:25:59
para la secretaría son el mismo 00:26:02
si tú llegas 00:26:04
un día con tu número de matrícula 7 00:26:06
y llegas mañana 00:26:07
con otra cara 00:26:09
con el título de matrícula 7, eres el mismo 00:26:11
da igual que tengas el diseño del pelo 00:26:14
da lo mismo, ¿vale? 00:26:16
eso te lo tiene que aclarar la secretaría 00:26:17
si el pelo te cambia 00:26:19
o no, dice, no, no, a mí me da igual 00:26:22
que tenga el pelo, a mí lo que me importa es su número 00:26:24
de matrícula, pues entonces, eso 00:26:26
te lo tiene que aclarar, que identifica de forma 00:26:28
única a los elementos de la aplicación 00:26:29
pues en este caso nos ha aclarado 00:26:32
su número de matrícula, me da igual que venga 00:26:33
hombre, mujer, con el pelo rubio o con el pelo moreno 00:26:35
su número de matrícula, pues eso fija el criterio 00:26:37
de igualdad, pues como el criterio de 00:26:39
igualdad está ya aquí recogido 00:26:41
en alumno 00:26:44
este remove va a funcionar bien 00:26:44
porque yo 00:26:48
creo un objeto cuyo número de matrícula 00:26:50
es este que me han dado, un objeto 00:26:52
aus, se lo paso a remove 00:26:54
se pone a buscar en la colección 00:26:56
uno que sea igual a este 00:26:59
o lo que es lo mismo, se pone a buscar 00:27:00
un alumno cuyo número de matrícula 00:27:03
sea este, y en cuanto 00:27:05
encuentre un alumno con número de matrícula este 00:27:07
lo elimina, que es lo que 00:27:09
queremos, que es lo que queremos 00:27:11
¿vale? 00:27:13
a ver, más métodos 00:27:17
hacer 00:27:19
mostrar el nombre del alumno que está matriculado 00:27:20
en más asignaturas 00:27:27
este, lo metemos 00:27:28
aquí en operaciones 00:27:32
vale, mostrar el nombre 00:27:33
del alumno y vamos a hacerlo que lo devuelva 00:27:36
jugador de retorno, si va a devolver 00:27:38
jugador de retorno un nombre, este va a 00:27:49
devolver un string, jugador de retorno 00:27:51
alumno con más 00:27:53
asignaturas 00:27:56
vale 00:27:58
pregunta 00:28:01
¿qué parámetro necesita 00:28:04
ese método? 00:28:08
ninguno, porque 00:28:12
este método trabaja con los 00:28:14
datos, y los 00:28:16
datos son estos, que ya están aquí arriba, con alumnos. Solamente trabaja con la colección 00:28:18
de alumnos, la recorrerá para ver qué más asignaturas tiene. Recorrerá a los alumnos 00:28:25
para verlo. Pues venga, este es nuestro siguiente método objetivo. Pues hala, venga, hacedlo. 00:28:29
Arrancadlo a ver qué... 00:28:40
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
6 de marzo de 2024 - 11:47
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
28′ 43″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
123.57 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid