Saltar navegación

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

Clase 01-03-24 - 2 - Contenido educativo

Ajuste de pantalla

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

Subido el 3 de marzo de 2024 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Tenemos que localizar en nuestra colección de aquí arriba, que es una lista, un objeto de todos los que tiene papa, papa, tiene este, tiene este, tiene este, tiene este, tenemos que localizar uno cuyo número de matrícula sea igual que este. 00:00:01
¿Vale? 00:00:19
Bueno, pues exactamente igual que hacíamos en un array. 00:00:20
Recorremos. 00:00:24
Me voy con este, ahora este, ahora este, ahora este y con cada uno de ellos. 00:00:26
su número de matrículas igual que este 00:00:29
su número de matrículas igual que este 00:00:31
en cuanto encuentre uno que lo es 00:00:33
ya tengo al alumno que busco 00:00:35
construyo el string con sus datos 00:00:36
y fuera 00:00:39
entonces tengo que recorrer 00:00:39
recorrer la colección 00:00:43
en este caso la lista 00:00:46
recorrerla 00:00:47
y cuando encuentre 00:00:48
una posición en la que hay un alumno 00:00:51
con ese número ya lo tengo 00:00:53
exactamente igual que hacíamos con los arrays 00:00:54
pero ahora no vamos a recorrer un array 00:00:57
vamos a recorrer una lista 00:00:58
bueno, pues recorrer una lista 00:00:59
ya lo vimos el otro día 00:01:02
yo tengo un montón de posiciones en la lista 00:01:04
pues vamos a recorrerlas 00:01:07
con el bucle de toda la vida 00:01:09
desde la posición 0 00:01:10
mientras si sea menor 00:01:14
que el total de posiciones de mi lista 00:01:17
que el total de posiciones de mi lista 00:01:19
¿cómo lo puedo obtener? 00:01:21
con el método size 00:01:23
que vimos el otro día 00:01:24
vale, pues este for 00:01:26
es el que va avanzando 00:01:29
posición 0, 1, 2 00:01:31
así hasta la última de la lista 00:01:32
vale 00:01:34
y una lista la recorremos así 00:01:35
porque tiene posiciones 00:01:38
un conjunto jamás lo recorreríamos así 00:01:40
no se puede, es imposible 00:01:43
recorrer un conjunto así, no se puede 00:01:44
porque los conjuntos 00:01:46
no tienen posiciones 00:01:49
pero las listas sí 00:01:50
entonces una lista se puede recorrer 00:01:52
posición 0, posición 1 00:01:54
posición 2, vale 00:01:56
pues cada posición de la lista 00:01:58
¿cómo se sacaba? cuando era una raíz 00:02:00
ya sabemos cómo la sacábamos 00:02:02
cuando era una raíz, sacábamos así 00:02:04
la posición de la raíz 00:02:06
así lo sacábamos, ¿no? 00:02:08
pero alumnos no es una raíz 00:02:10
alumnos es una lista 00:02:12
luego la posición y la sacamos así 00:02:13
con get y la posición 00:02:16
¿verdad? 00:02:18
esto es lo que vimos el otro día 00:02:20
entonces este es el alumno 00:02:22
que está en la posición 00:02:24
Y. Ese alumno es en la posición 00:02:25
Y. Vale, ¿y qué tengo que hacer con el 00:02:28
alumno que está en la posición Y? Ver 00:02:30
si es el que tiene este número de matrícula. 00:02:32
Porque 00:02:35
si es él, ya lo he encontrado. 00:02:36
Eso es lo que tenemos que hacer. 00:02:38
Pues si el alumno 00:02:40
que está en la posición Y, 00:02:42
su número de matrícula 00:02:44
resulta que 00:02:46
es igual 00:02:49
voy a bajar aquí abajo 00:02:50
resulta que es 00:02:53
igual al número 00:02:55
silencio 00:02:56
al número de matrícula 00:02:58
que me han pasado por parámetro 00:03:01
o sea, este es 00:03:02
el objeto alumno en la posición 00:03:05
y, pues si el objeto 00:03:07
alumno en la posición y 00:03:09
su número de matrícula, que lo saco con el 00:03:10
get de toda la vida, es igual 00:03:13
al número de matrícula que estoy 00:03:15
buscando, este es 00:03:17
el alumno que estoy buscando 00:03:19
ese 00:03:21
¿vale? bueno, pues ya he encontrado 00:03:21
el alumno que tiene esa matrícula. 00:03:25
¿Qué tengo que hacer con ese alumno? 00:03:27
Pues en este caso, coger sus datos y concatenarlos 00:03:29
en un stream, ya está, para devolverlo. 00:03:31
Bueno, pues esto ya, 00:03:35
pues vamos a 00:03:41
poner en result, vamos a poner 00:03:42
primero el nombre 00:03:46
del alumno. 00:03:48
Es que no tengo que implementar 00:03:55
alto stream. 00:03:56
Sí, pero es que entonces, ya, 00:03:58
Sí, pero es que entonces tengo que implementar 00:04:00
el toString 00:04:02
¿Cómo que no tengo los de matrícula? 00:04:04
Es el get de la propiedad 00:04:09
no matrícula. Los getter y setters los tengo 00:04:10
todos. 00:04:12
Lo que pasa es que el toString 00:04:14
se tendría que adaptar al formato 00:04:16
que el secretario quiere. 00:04:18
¿Vale? Al formato que el secretario quiere. 00:04:20
Entonces yo aquí voy a poner un 00:04:22
una especie de papelito 00:04:24
lo que sacaría el secretario. 00:04:26
¿Vale? 00:04:29
con su listado de asignaturas, etc. 00:04:30
Esperamos, si tengo un toString construido 00:04:34
que lo que me saca se adapta 00:04:37
a lo que el secretario quiere ver en sus papeles, 00:04:39
magnífico. 00:04:41
Pongo ahí efectivamente el toString y ya está. 00:04:42
Perfecto. 00:04:45
Vale. 00:04:47
Result nombre más, pues el nombre del alumno. 00:04:48
Alumnos.geti.getNombre. 00:04:52
vale, voy a ponerle también la edad 00:05:00
al informe 00:05:06
voy a hacer un salto de línea 00:05:07
para que me lo ponga una línea separada 00:05:09
entonces 00:05:11
que poner todo esto en el toestring es un poco 00:05:14
ni siquiera 00:05:16
seguramente tendría yo acceso a la clase 00:05:18
alumno, para poner en el toestring 00:05:20
exactamente lo que quiere el secretario 00:05:22
que salga en el papel 00:05:23
vale, entonces le vamos a poner ahora 00:05:24
la edad 00:05:28
el alumno tiene 00:05:32
¿cuántos años tiene? pues tiene 00:05:34
get 00:05:36
get edad, vale 00:05:50
lo concateno con un salto de línea para que no me quede 00:05:58
todo seguido ahí en el papelito 00:06:01
y ahora 00:06:03
tengo nombre, edad 00:06:06
y ahora tengo que concatenar todas las asignaturas 00:06:08
en ese string 00:06:11
vale 00:06:13
las asignaturas del alumno son a su vez 00:06:15
una lista 00:06:19
entonces tengo que recorrer la lista 00:06:20
de asignaturas 00:06:26
e irlas concatenando 00:06:27
al result, para que aparezcan 00:06:30
todas, otra vez 00:06:32
¿vale? 00:06:34
repito, el alumno 00:06:38
su nombre y su edad son propiedades simples 00:06:40
las he concatenado al result fácilmente 00:06:43
sin problemas 00:06:45
pero asignaturas 00:06:45
es un array 00:06:49
perdón, es una lista 00:06:50
entonces tengo que recorrer 00:06:52
la lista de asignaturas 00:06:55
tengo que recorrerla 00:06:57
y cada asignatura irla concatenando al result 00:06:58
vale, pues entonces 00:07:01
aquí podría hacer 00:07:05
menor que 00:07:06
alumno 00:07:14
punto get y 00:07:16
punto 00:07:21
get asignaturas 00:07:23
a ver si abro esto 00:07:25
veis, este for de aquí 00:07:37
es para recorrer 00:07:41
las asignaturas 00:07:43
del alumno de posición I 00:07:46
para recorrer 00:07:48
las asignaturas del alumno de posición I 00:07:50
y ahora, ¿qué hago con 00:07:51
cada asignatura? 00:07:54
la concateno 00:07:56
¿vale? 00:07:57
get asignaturas 00:08:05
de J 00:08:07
¿vale? o sea, todo 00:08:15
este for 00:08:25
es para concatenar 00:08:25
todas y cada una de las asignaturas 00:08:29
del alumno este 00:08:31
para concatenarlas 00:08:32
todas ellas 00:08:35
a mi result 00:08:36
para que se vea mejor el código 00:08:38
como no me cabe, con la letra tan grande no me cabe 00:08:40
voy a guardar al alumno osgesti 00:08:42
en una variable auxiliar para que quede más cortito y se vea mejor 00:08:44
entonces voy a guardar 00:08:47
en una variable alumno aquí 00:08:48
el alumno con el que 00:08:52
este, el alumno encontrado 00:08:56
¿Vale? Este alumno estoy dentro de este if 00:08:59
Este es el alumno 00:09:02
Cuyo número de matrícula coincide 00:09:03
Este, el get if 00:09:06
Entonces para no arrastrar todo el rato el get if 00:09:07
Voy a sustituirlo por a que se va a ver mejor 00:09:09
Esto es a 00:09:14
Y esto es a 00:09:17
Así se ve mejor 00:09:20
¿Vale? 00:09:21
Este es mi alumno a 00:09:24
Pongo su nombre 00:09:25
En el resultado 00:09:28
concateno su edad en el resultado 00:09:29
y ahora recorro sus asignaturas 00:09:32
las recorro 00:09:35
que son una lista 00:09:36
cada asignatura 00:09:37
la voy concatenando al resultado 00:09:39
aquí me va a quedar mejor con un salto de línea 00:09:42
para que no salgan todas seguidas 00:09:44
¿vale? y de hecho le voy a poner aquí 00:09:45
asignaturas 00:09:55
para que quede más bonito luego cuando lo veamos 00:09:56
igual 00:09:59
asignaturas 00:10:04
y le ponemos un salto de línea 00:10:13
ya está 00:10:16
vale, pues es el informe que va a sacar 00:10:17
nombre, edad y todas sus asignaturas 00:10:20
concatenadas una tras otra 00:10:23
y ahora ya este resultado 00:10:24
lo devuelve 00:10:29
vale, pues nada 00:10:29
hemos recorrido nuestro array alumnos 00:10:33
cuando hemos encontrado un alumno 00:10:36
cuya matrícula 00:10:38
coincide con la que 00:10:40
me han pasado 00:10:42
ese alumno construyó el string 00:10:43
con sus datos 00:10:46
y ya está, construyó el string con sus datos 00:10:47
y he tenido que entrar 00:10:50
a su vez en un list 00:10:52
que es el de sus asignaturas 00:10:54
¿vale? 00:10:55
¿este código que he escrito aquí está claro? 00:11:11
vale 00:11:16
pues vamos a aprovechar este método 00:11:16
para ver otras formas de recorrer una lista 00:11:19
para ver otras formas de recorrerla 00:11:21
esta siempre es una forma 00:11:23
de recorrer la lista 00:11:25
voy posición por posición desde la 0 00:11:26
mientras no haya llegado a la última 00:11:29
y cada posición la recupero con get i 00:11:31
Esta es una forma de recorrerla, pero hay otras formas alternativas para recorrer una lista. 00:11:35
Dentro de este mismo método, lo vamos a poner aquí abajo. 00:11:43
Otras formas de recorrer una lista, aparte del for este de índice que estamos poniendo aquí, otras formas de recorrerla. 00:12:00
Pues una muy cómoda, pues el for each, un array, a veces lo hemos recorrido con un for de índice, 00:12:08
for each y patatín y a veces con un for each 00:12:15
normal, pues una lista igual 00:12:19
una lista también podemos recorrerla 00:12:21
con un for each cuando estamos 00:12:23
vagos y queremos escribir rápido 00:12:25
por ejemplo así 00:12:26
para cada alumno 00:12:29
a, por ejemplo 00:12:31
¿en qué lista? 00:12:33
en la lista alumnos 00:12:35
este es el for each 00:12:37
pero ahora ha aplicado 00:12:42
una lista, entonces 00:12:47
este for each recorre la lista alumnos 00:12:48
en la primera iteración 00:12:51
A será el primero de la lista 00:12:53
en la siguiente iteración 00:12:55
A será el segundo de la lista 00:12:57
en la siguiente iteración 00:12:58
A será el tercero 00:13:00
es exactamente igual que en el array 00:13:02
exactamente igual 00:13:04
vale exactamente igual 00:13:05
entonces esta es cómoda por vaguería de escribir 00:13:08
pero 00:13:11
pasa lo mismo 00:13:13
y aplica lo mismo que decíamos 00:13:15
con el array 00:13:17
esto como funciona 00:13:18
es una copia 00:13:22
de lo que hay en la lista 00:13:24
la primera iteración es una copia 00:13:27
del primero, pero una copia 00:13:29
la segunda iteración es una copia del segundo 00:13:30
pero una copia 00:13:33
la tercera iteración es una copia del tercero 00:13:34
pero una copia, entonces para consultar 00:13:37
estupendo, me da igual consultar 00:13:39
el original que la copia, para consultar 00:13:41
pero si yo quiero 00:13:42
estoy cambiando el objeto 00:13:44
o estoy eliminando 00:13:46
o algo 00:13:49
esto no le debería usar nunca jamás 00:13:50
¿vale? 00:13:53
este cuando yo lo que 00:13:56
quiero hacer es consultar 00:13:57
y no voy a tocar la lista 00:13:59
pero si voy a hacer modificaciones en la lista 00:14:00
no, porque entonces estaré trabajando con copias 00:14:03
¿vale? y no solo eso 00:14:05
sino que hay problemas añadidos 00:14:09
que forzaremos para que no salgan 00:14:11
dentro de un tiempo 00:14:13
para que lo veáis 00:14:14
pero por ahora que sirva como principio 00:14:16
que como este for it 00:14:19
ya sabéis dentro como funciona 00:14:21
A es una copia 00:14:23
que va siendo primero el primer elemento 00:14:25
luego el segundo, luego el tercero 00:14:27
esencialmente es útil para consultas 00:14:28
no para toquetear la lista 00:14:31
estamos trabajando con copia 00:14:34
para consulta 00:14:36
aparte de que es menos eficiente 00:14:38
porque es que está todo el rato haciendo copias 00:14:40
esto sin embargo 00:14:42
no trabaja con copias 00:14:46
o sea get i 00:14:48
es directamente una referencia 00:14:49
a ese objeto 00:14:52
cuando recorremos esto 00:14:53
alumnos get i es una referencia 00:14:56
directa al objeto, no es una referencia 00:14:58
a copia, es una referencia 00:15:00
directa a esa 00:15:02
bueno pues el for it sería 00:15:03
otra forma alternativa y otra 00:15:06
la más mejor y la más 00:15:08
recomendable, otra forma 00:15:10
el iterador 00:15:13
que lo mencionamos ya 00:15:14
el martes 00:15:17
cuando vimos los métodos 00:15:19
que ofrecía List 00:15:20
el literador 00:15:23
es un objeto que se crea 00:15:25
que sirve para recorrer colecciones 00:15:27
de cualquier tipo 00:15:29
de ahí viene su nombre 00:15:30
es un literador 00:15:33
vale, entonces esto es un objeto 00:15:34
que sirve para recorrer 00:15:37
colecciones de datos, sean listas 00:15:39
sean conjuntos, sean de lo que sean 00:15:41
porque hay más colecciones de datos aparte de estas 00:15:43
de la Java útil, hay muchas más 00:15:45
para cosas específicas 00:15:47
pero para cosas genéricas 00:15:49
son estas de Java útil 00:15:51
bueno, pues esto es un objeto 00:15:52
que vale para recorrer 00:15:54
colecciones 00:15:56
y gestiona temas como concurrencia 00:15:57
entonces es bastante 00:16:01
seguro de usar 00:16:02
bueno, pues para recorrer una colección con iterador 00:16:04
hay que crear el objeto iterador 00:16:07
pues el objeto iterador pertenece a la clase 00:16:08
iterator, como uno se puede imaginar 00:16:10
entonces, ¿cómo lo instancia uno? 00:16:12
bueno, pues 00:16:16
uno piensa, a ver, ¿en dónde 00:16:17
quiero yo iterar? en una colección de objetos 00:16:19
alumno, pues iterador 00:16:21
es una clase genérica 00:16:23
la clase iterador si uno entra 00:16:24
en ella 00:16:27
la clase iterador, bueno es una interfaz 00:16:27
uno hace una implementación 00:16:39
claro, es una 00:16:41
clase lo que implementa eso 00:16:43
los que implementen eso 00:16:45
lo que hacen es iterar en colecciones 00:16:46
pero en colecciones de qué, lo deja genérico 00:16:49
de lo que sea, cuando tú me instancies para iterar 00:16:52
cuando tú me instancies ya me dirás sobre qué itero 00:16:55
pero ahora mismo es genérica 00:16:58
bueno pues como recordáis de clases genéricas del otro día 00:17:00
cuando instanciemos el iterador que es aquí 00:17:03
en este momento, aquí ya decimos 00:17:07
oye, pero a qué clase pertenecen los objetos 00:17:09
sobre los que vas a iterar, en nuestro caso una colección de alumnos 00:17:13
pues aquí es donde nosotros 00:17:16
ya nos comprometemos y decimos 00:17:18
oye, que esto es de alumno 00:17:20
ah, vale, vale, esto es de alumno 00:17:22
pues aquí ya lo fijas 00:17:24
vale, pues hacemos un iterador 00:17:25
¿y cómo se instancia el iterador? 00:17:27
pues en qué lista queremos iterar 00:17:30
en la lista que se llama alumnos 00:17:32
pues la lista que se llama alumnos 00:17:33
tiene un método 00:17:36
que es este 00:17:37
que te devuelve ya ese objeto iterador 00:17:39
¿vale? 00:17:42
vamos a importar 00:17:44
la clase de Java útil 00:17:45
cuidado con los import 00:17:48
porque como ya sabéis el Eclipse 00:17:50
obviamente no sabe absolutamente nada 00:17:52
entonces él te ofrece 00:17:53
todas las clases iterador que he visto por ahí 00:17:55
pero claro tenéis que elegir 00:17:58
cuál queréis, queréis esta que viene 00:18:00
de su Intex HTML document 00:18:02
pero que es eso, no 00:18:04
sabemos que las colecciones están en Java útil 00:18:05
lo sabemos porque lo hemos estudiado 00:18:08
entonces obviamente querremos importarla de Java útil 00:18:09
no importamos la primera que nos ofrece 00:18:12
importamos la que sabemos 00:18:14
que es. Entonces, como 00:18:17
estamos con colecciones, esto de arriba 00:18:19
no tiene ningún sentido. Es java.util. 00:18:21
¿Vale? Pues eso. 00:18:24
Cuidado con los import, obviamente. 00:18:25
Vale. Pues ya tenemos el iterador. 00:18:28
Y ahora, 00:18:30
este objeto iterador 00:18:31
es un objeto adicional que sirve para 00:18:33
recorrer esta lista. 00:18:35
Es como si apuntara esa lista. 00:18:38
Y sirve para recorrerla. 00:18:40
Y además ofrece métodos para hacer cosas 00:18:41
con esa lista. 00:18:43
De forma sincronizada, por eso es útil. 00:18:44
¿Vale? 00:18:47
Pues ahora cómo lo usamos para recorrerla. 00:18:48
Pues it tiene un método que es el clave, 00:18:50
que es el método next. 00:18:54
¿Vale? 00:18:56
Y el método has next. 00:18:58
Tiene este, que ahora vemos cómo lo usamos, 00:18:59
y este, entre otros. 00:19:04
Estos son los dos más importantes, 00:19:07
los que se usan para recorrer. 00:19:09
Estos dos métodos. 00:19:11
¿Este qué te dice? 00:19:12
O sea, el iterador inicialmente se queda posicionado 00:19:13
Antes del principio 00:19:16
Si la lista tiene 0, 1 y 2 00:19:18
Es como si se quedara en la menos 1 00:19:21
Se queda en la posición menos 1 00:19:22
Vale, pues next que hace 00:19:24
Next lo va avanzando 00:19:27
Entonces un primer next hay que hacer 00:19:28
Porque él empieza en la menos 1 00:19:30
Un primer next hay que hacer 00:19:32
Y has next que hace 00:19:34
Te devuelve un boolean para decirte 00:19:36
Si hay siguiente o si no hay siguiente 00:19:38
¿vale? entonces 00:19:40
cuando llevamos al método it has next 00:19:43
nos devuelve true si hay otro 00:19:45
más todavía, si queda 00:19:47
alguno, si queda alguno 00:19:49
y nos devuelve false si no queda ninguno 00:19:51
si ya está al final 00:19:53
¿vale? esto es para decir, ¿quedan elementos o no quedan? 00:19:54
para esto vale 00:19:58
te devuelve un true 00:19:59
y este salta 00:20:00
bueno, pues ¿cómo se combinan estos métodos 00:20:02
para recorrer con un iterador? 00:20:05
se combinan en un while de esta manera 00:20:07
mientras 00:20:08
queden elementos 00:20:12
mientras queden 00:20:16
porque en it.next hemos dicho que devuelve 00:20:21
true o false, luego es una condición 00:20:23
devuelve true o false 00:20:25
es una condición, se puede meter en un while 00:20:27
pues mientras queden 00:20:29
¿qué hacemos? pues avanza 00:20:31
para quedarte con él 00:20:33
entonces it.next 00:20:34
avanza y te recupera 00:20:36
un objeto alumno, te lo recupera 00:20:39
hombre, aquí lo ideal sería 00:20:41
meterlo en una referencia 00:20:42
ahí 00:20:45
y ahora 00:20:46
con este alumno A 00:20:48
uno ya hace lo que le dé la gana 00:20:49
este es el bucle de recorrido 00:20:52
mientras queden 00:20:54
avanza 00:20:56
y ya estás en él, que es este 00:20:58
y con él ya haces lo que sea 00:21:00
mientras que siguen quedando 00:21:01
vuelve a avanzar 00:21:04
luego ya estás en el siguiente y haces con él lo que sea 00:21:05
que siguen quedando, vuelve a avanzar 00:21:07
y ya estás en el siguiente, haz con él lo que sea 00:21:10
¿Vale? Este es el recorrido 00:21:12
El aspecto del bucle para recorrer 00:21:15
Con un iterador 00:21:17
Entonces 00:21:18
Aplicaciones más complicadas que combinen estos 00:21:23
Con otros recorridos, con otras colecciones 00:21:27
Siempre va a ser mejor 00:21:28
Siempre va a ser mejor usar un iterador 00:21:29
Nosotros ahora mismo en esto que tenemos una única colección 00:21:32
Aislada y no estamos haciendo nada 00:21:35
Pues no notaríamos diferencia 00:21:36
Pero una aplicación más complicada 00:21:38
Que mezcle hilos, que mezcle cosas 00:21:40
De repente 00:21:42
podría no funcionarnos en un caso concreto 00:21:44
por haber 00:21:46
estado recorriendo con un 00:21:48
for normal y si cambiamos a iterador 00:21:50
ya así no se estaría funcionando. Entonces, esta 00:21:52
siempre es la forma más segura. 00:21:54
Pero en las aplicaciones que hacemos nosotros ahora 00:21:56
nos da igual porque 00:21:58
no estamos en situaciones de esas 00:22:00
críticas. 00:22:02
Vale, entonces aquí 00:22:05
ya haríamos lo que fuera con el alumno. 00:22:06
¿Vale? 00:22:09
Entonces, bueno, 00:22:10
pues estas serían formas alternativas 00:22:12
de recorrerlo, vale, me da igual como lo recorra 00:22:14
me da igual como llego al alumno A de cada iteración 00:22:18
lo que hemos hecho en este método es construir el informe y ya está 00:22:22
vale, pues entonces ya tenemos 00:22:26
insertar y mostrar datos, pues vamos a hacer un main rápido 00:22:30
que pruebe estos datos, pruebe estos métodos 00:22:34
a ver que 00:22:37
vale, yo no voy a hacer el main 00:22:39
porque no quiero escribir tanto ni perder el tiempo 00:22:45
entonces si haríais un main 00:22:47
entonces voy a insertarle un alumno 00:22:48
sin más 00:22:51
alumnos, esta es mi colección 00:22:52
de alumnos, pues voy a llamar 00:23:00
al método de insertar 00:23:02
ay perdón 00:23:05
que estoy idiota 00:23:07
operaciones punto 00:23:08
insertar alumno 00:23:11
vale 00:23:13
vale, este es mi método 00:23:14
insertar alumno de la clase operaciones 00:23:18
vamos a insertar 00:23:21
un alumno 00:23:22
lo natural sería pedir antes los datos por teclado 00:23:23
pero bueno, voy a instanciar 00:23:29
ya directamente 00:23:31
un alumno aquí con mi constructor 00:23:32
con un número de matrícula 00:23:34
uno 00:23:38
y su nombre 00:23:38
ala, este 00:23:41
vale, y alumno tenía 00:23:43
por ahora 00:23:54
sin asignaturas 00:23:56
alumno 00:23:57
¿por qué no me 00:24:01
int string 00:24:02
int 00:24:07
ah vale no que era la edad 00:24:08
vale vale la edad me la estoy saltando 00:24:11
de la manga 00:24:13
vale 20 00:24:13
y tenía un constructor en el que no había metido las asignaturas 00:24:15
a propósito 00:24:18
¿no? recordáis de alumno 00:24:19
que no las habíamos metido a propósito 00:24:21
en el constructor para luego 00:24:24
irlas añadiendo a través del menú. 00:24:26
Vale, pues ya tengo aquí 00:24:31
la llamada a mi método de insertar alumno 00:24:32
donde inserto esto. 00:24:37
Lo va a insertar en los datos 00:24:41
que los dos están aquí. 00:24:43
Vale, entonces esto es 00:24:46
lo que hace la aplicación de secretaría. 00:24:48
En lugar de un menú, 00:24:51
yo estoy insertando uno a capón, 00:24:52
pero aquí habría que poner un menú 00:24:54
introduzca número de matrícula 00:24:55
edad y nombre, y ya está 00:24:57
y haría esto mismo 00:25:00
pero con los datos leídos por teclado 00:25:01
no directamente con los he puesto yo 00:25:04
vale, y ahora vamos a 00:25:05
mostrar el resultado 00:25:07
mostrar los datos de este alumno 00:25:10
mostrar datos del que tengan los matrícula 1 00:25:15
vale, este sería 00:25:17
nuestro primer caso de prueba 00:25:21
vale, bueno, vamos a hacer 00:25:23
un primer caso de prueba 00:25:26
estamos haciendo el testing de esta aplicación 00:25:28
Primer caso de prueba 00:25:30
Número de matrícula que no existe 00:25:32
A ver qué hace 00:25:34
A ver si lo que hace nos gusta o no 00:25:35
Si lo que hace nos gusta lo dejamos 00:25:37
Si lo que hace no nos gusta habrá que decir al desarrollador 00:25:39
Este caso de prueba lo has pasado fatal 00:25:42
Venga, primer caso de prueba 00:25:44
Número de matrícula que no existe 00:25:46
Vamos a ver qué hace 00:25:47
No ha dado error pero tampoco ha mostrado nada 00:25:48
Hombre, yo iría y le diría al desarrollador 00:25:58
Oye 00:26:00
Si el alumno no existe 00:26:01
Que me muestre un mensajito 00:26:04
¿Verdad? Me muestra un mensajito 00:26:06
Eso sería lo primero que yo haría 00:26:09
Si fuera del equipo de testing 00:26:11
¿Vale? 00:26:12
Pero eso lo podríamos cambiar muy fácilmente 00:26:16
Porque aquí hay mostrar datos 00:26:19
¿Qué haríais? 00:26:21
¿Qué haríais para que el programa 00:26:39
Me muestre? ¿Qué cambio incorporaríais? 00:26:41
Para que el programa me muestre 00:26:43
Cuando yo lo llamo por un número de matrícula 00:26:44
Que no existe, que me diga 00:26:47
En lugar de nada, porque me ha mostrado nada 00:26:49
que me diga, el alumno no está. 00:26:51
¿Qué cambio 00:26:55
podríais hacer en este método? 00:26:56
Si el alumno es diferente 00:27:14
de null, ¿dónde? 00:27:15
Bueno, alumno es diferente de null. 00:27:20
Claro, o sea, lo más fácil es, 00:27:26
si el alumno no existe, no ha entrado 00:27:28
nunca en el if, con lo cual esto se queda 00:27:30
vacío. 00:27:32
Pues entonces, aquí 00:27:34
simplemente decir, 00:27:36
result 00:27:38
diferente 00:27:43
de la cadena vacía 00:27:47
es porque ha encontrado el alumno 00:27:53
entonces que me devuelva result 00:27:54
y si no, que me devuelva 00:27:55
no existe alumno 00:27:58
con ese número 00:28:03
de matrícula 00:28:05
y ya está 00:28:10
es una posible forma 00:28:14
si hemos llegado a este punto 00:28:18
y esto ha cambiado de valor 00:28:20
no es el valor inicial de aquí 00:28:22
es porque hemos entrado en el if 00:28:24
y hemos encontrado al alumno 00:28:26
hemos entrado en el if y hemos construido el informe 00:28:27
pero si el alumno no existe 00:28:30
nunca hemos entrado en el if 00:28:32
luego no hemos construido el informe 00:28:33
y esto se ha quedado como tal 00:28:35
bueno pues entonces 00:28:36
una forma sencilla es 00:28:39
si la hemos construido 00:28:41
devuélvela y si no la hemos construido devuelve esto 00:28:44
entonces con ese arreglo rápido 00:28:46
ya cuando el que hace las pruebas 00:28:48
vuelva a hacer la prueba 00:28:50
Para este caso de prueba le dirá 00:28:51
Ah, vale, este caso de prueba ya lo has pasado con éxito 00:28:54
Vale 00:28:57
Este caso de prueba está pasado con éxito 00:28:57
Venga, vamos al siguiente caso de prueba 00:29:00
Que es matrícula que sí existe 00:29:02
A ver qué hace 00:29:04
Vamos a pasar el número de matrícula que sí existe 00:29:05
Vale, esto sería 00:29:09
Caso de prueba 1 00:29:11
Matrícula que no existe 00:29:13
Vale 00:29:20
Ahora, venga, caso de prueba 2 00:29:22
matrícula 00:29:24
que si existe 00:29:33
venga, caso de prueba 2 00:29:35
matrícula que si existe 00:29:39
vale, esta la dejo comentada 00:29:41
porque ya la hemos pasado, esta prueba 00:29:54
mostrar datos 00:29:56
1, matrícula que si existe 00:29:58
caso de prueba 1, a ver así 00:30:00
en 10 segundos, en menos, en 2 segundos 00:30:01
va a pasar este caso de prueba 00:30:04
o no lo va a pasar, va a pasar con 00:30:06
¿success o fail? 00:30:08
rápido 00:30:12
¿éxito o fracaso? 00:30:13
¿nadie dice nada? 00:30:17
normalmente solo fracaso 00:30:19
bueno, yo primero 00:30:22
hay que dejar un criterio 00:30:23
yo creo 00:30:25
¿por qué podría pasarlo con fracaso? 00:30:29
con lo que estamos diciendo hasta ahora 00:30:37
nuestros únicos errores hasta ahora están siendo 00:30:39
null pointer exception, ¿verdad? 00:30:41
es que no estamos haciendo más cosas 00:30:42
no hay más que 00:30:45
¿dónde podría salir aquí un null pointer exception? 00:30:46
en operaciones podría salir 00:30:51
un null pointer exception, ¿verdad? 00:30:53
esto 00:30:59
fuera null 00:31:02
pero no lo es 00:31:04
y si eso no es null 00:31:06
que esto fuera null 00:31:09
son los dos puntos clave 00:31:11
las asignaturas del alumno 00:31:14
Las asignaturas del alumno van a ser null. 00:31:17
No he introducido ninguna. 00:31:21
Vamos a ver alumno. 00:31:23
No he introducido ninguna asignatura. 00:31:24
Con lo cual, las asignaturas de alumno van a ser null. 00:31:27
Entonces, no va a pasar este caso de prueba. 00:31:30
Otra cosa es que yo aquí haya esta clase, 00:31:33
esté cambiada y esté inicializada una lista vacía. 00:31:36
Entonces, sí lo pasa. 00:31:39
Simplemente no muestra asignaturas. 00:31:40
Pero no lo va a pasar, va a decir un null pointer exception. 00:31:42
¿Verdad? Vamos a probarlo. 00:31:44
porque esto es null 00:31:45
vamos a pasar este caso de prueba 00:31:47
pues efectivamente 00:31:52
null pointer exception y donde 00:31:56
pues ahí 00:31:58
está haciendo 00:32:01
esto que es null 00:32:04
esto es un null enorme 00:32:06
punto 6 00:32:08
punto 6 de algo que es null 00:32:09
vale, no puede pasar ese caso de prueba 00:32:11
vale 00:32:15
entonces 00:32:17
si uno tiene acceso a esta clase 00:32:18
lo normal es que 00:32:23
estas clases, cuando hay colecciones 00:32:25
se generen con 00:32:27
la lista ya inicializada 00:32:29
pero sin elementos, precisamente para evitar 00:32:31
eso, ¿verdad? 00:32:33
entonces ya solo con este cambio de aquí 00:32:39
solo con este 00:32:40
cambio, ese null pointer 00:32:46
ya no está 00:32:50
ese null pointer ya no está 00:32:51
lo que pasa es que 00:32:53
como esto es cero 00:32:55
pues no va a entrar en este bucle 00:32:56
y no va a mostrar asignaturas, pero eso está bien 00:32:58
no va a mostrar asignaturas, ya está 00:33:00
¿vale? con este cambio ya 00:33:01
ese no va a estar 00:33:04
vamos a volver a pasar este caso 00:33:05
de prueba, vale 00:33:08
asignaturas vacío, a ver otra 00:33:12
cosa es que dijéramos, oye si no hay asignaturas 00:33:14
que ponga un mensaje 00:33:16
no está matriculado de nada 00:33:18
pero bueno, eso sería un cambio similar al que hemos hecho 00:33:20
¿vale? similar al que hemos hecho 00:33:22
bueno, estos métodos 00:33:23
vale, parece que 00:33:28
que están 00:33:29
vale 00:33:30
pero este de aquí operaciones 00:33:34
es que nos da mucho juego 00:33:37
este de mostrar datos 00:33:39
vamos a otra vez a este for 00:33:41
que recorre 00:33:47
otra vez a ese for que recorre 00:33:48
si pudiéramos evitar de alguna manera 00:33:52
tener que hacer ese for 00:33:55
todo el rato, ir uno por uno 00:33:56
si es igual, no habrá un método que me devuelva 00:33:58
ya directamente algo 00:34:01
no puede haber algo 00:34:02
pues realmente la interfaz list 00:34:03
tiene tropecientos métodos, a lo mejor 00:34:06
hay alguno que nos permite hacer esto 00:34:08
de otra manera 00:34:10
vale 00:34:11
no os perdáis, estamos al mismo punto 00:34:13
en el punto de recorrer mi lista 00:34:16
hasta ubicar el alumno 00:34:18
cuya matrícula es 00:34:20
igual que la que me han dado, estamos en este punto 00:34:22
vale, pero vamos 00:34:24
a seguir viendo métodos de list para ver 00:34:26
otra forma de hacer esto 00:34:28
pues en este mismo mostrar datos 00:34:30
otras formas de recorrer 00:34:32
la lista, otras formas 00:34:34
vamos a poner 00:34:36
aquí 00:34:38
otra forma más, otra cosa que se puede 00:34:39
hacer 00:34:42
vamos a ver que métodos me ofrece a mi list 00:34:42
a ver si hay alguno que me ofrece cosas 00:34:53
que me gusten 00:34:55
joe, que no quería yo esto, quería la 00:34:57
vale 00:34:58
a ver, venga, otra 00:34:59
cosa que se puede hacer, aquí está, vamos 00:35:09
vamos a ver que me ofrece la lista 00:35:11
alumnos 00:35:13
pues me ofrece aquí un montón de morralla 00:35:16
de historias de añadir de patatín 00:35:20
de no sé qué, de rollos patateros 00:35:23
y de repente me veo este método 00:35:27
que me gusta, este método te da 00:35:31
la posición donde está 00:35:35
un objeto igual a este 00:35:38
si uno describe, si uno mira la ayuda del index of 00:35:42
mira la ayuda 00:35:47
te dice, oye 00:35:48
te devuelve la posición 00:35:51
de la primera ocurrencia 00:35:54
que encuentra de un elemento 00:35:55
igual a este 00:35:57
según el método equals 00:35:59
es que te lo explica 00:36:01
según el método equals 00:36:02
te devuelve 00:36:05
la primera ocurrencia 00:36:07
en esta lista 00:36:09
de un objeto igual a este que le pasas 00:36:10
según el equals 00:36:13
cuando encuentra uno 00:36:14
get i que es igual a este 00:36:16
y este devuelve menos uno 00:36:18
si no hay ninguno 00:36:20
hombre pues justo, perfecto 00:36:21
le voy a pasar un objeto igual 00:36:24
a ese que tiene esa matrícula 00:36:25
y que me devuelva la posición 00:36:28
y ya lo tengo, no tengo que hacer un for 00:36:30
ni tengo que hacer nada 00:36:32
es decir, podemos hacer esto 00:36:33
este método 00:36:36
si yo le paso un objeto 00:36:46
igual 00:36:48
un objeto igual a uno con ese número 00:36:49
de matrícula, si yo le paso esto 00:36:56
vamos, como no tengo un constructor 00:36:58
solo con un número de matrícula, vamos a construir 00:37:03
aquí, new alumno 00:37:05
y ahora le pongo 00:37:11
aux.set 00:37:12
num matrícula 00:37:15
vale 00:37:17
ala, pues que me devuelve 00:37:19
esto 00:37:29
me devuelve la posición 00:37:29
del primer 00:37:32
objeto alumno que se encuentra 00:37:35
igual que este 00:37:36
y recordad que la igualdad de alumno 00:37:38
va por número de matrícula 00:37:40
la igualdad de alumno va por número de matrícula 00:37:42
que está aquí 00:37:44
va por número de matrícula 00:37:45
luego me va a devolver 00:37:46
una posición 00:37:52
que es la del primer alumno 00:37:53
que se encuentra igual que este 00:37:55
y como este tiene como número de matrícula 00:37:57
la que me han pasado 00:37:59
pues me va a devolver 00:38:00
la primera posición 00:38:03
que se encuentra con un alumno 00:38:04
cuyo número de matrícula es ese 00:38:06
luego el alumno que estoy buscando es este 00:38:07
es este, ya lo tengo 00:38:12
ni for ni nada 00:38:15
este es el alumno que estoy buscando 00:38:16
este es el alumno que estoy buscando 00:38:18
este, el alumno 00:38:27
que está en la 00:38:29
posición, de vuelta 00:38:31
por este método, es el alumno que estoy buscando 00:38:36
y de este es del que tengo que construir el informe 00:38:38
este es el alumno 00:38:40
que busco, ya está 00:38:42
no tengo que hacer for ni tengo que hacer nada 00:38:50
este es mi alumno 00:38:52
este es 00:38:54
Y ya con este alumno 00:39:02
Pues puedo hacer todo esto de aquí 00:39:05
Todo esto que he hecho aquí 00:39:06
Todo esto que he hecho 00:39:07
No tengo que meterlo en un for ni nada 00:39:10
Todo esto que he hecho aquí 00:39:12
Todo esto 00:39:14
Ya está 00:39:17
Es este 00:39:20
Y esto con alumno 00:39:24
Con alumno 00:39:28
Vale, pues este podría ser el código de mi método 00:39:32
Exactamente ese 00:39:47
luego con los métodos de las listas 00:39:48
se pueden hacer un montón de cosas 00:39:54
¿vale? pues ya conocemos este 00:39:55
le pasas un objeto 00:39:58
te busca la primera 00:40:01
posición de la lista de un objeto 00:40:02
igual a este 00:40:04
igual según el equals 00:40:05
como nuestro equals es con número de matrícula 00:40:08
pues te devuelve 00:40:11
la primera posición de un objeto 00:40:12
cuyo número de matrícula es igual a la de este 00:40:14
que se la acabamos de poner aquí 00:40:16
te devuelve la posición 00:40:18
y ahora esa posición se la pasas al get 00:40:20
Y ya tienes el alumno que estabas buscando 00:40:22
El alumno con ese número de matrícula 00:40:24
No tienes que meterte en un get to ni en un for ni nada 00:40:25
Ese alumno que buscábamos 00:40:28
Con ese número de matrícula 00:40:31
Y ya con él se hace lo que sea 00:40:32
¿Vale? 00:40:33
Bueno, merece la pena que lo probemos 00:40:39
Porque 00:40:40
A ver 00:40:41
Venga, este método vamos a denunciar la cabecera 00:40:49
Y lo hacéis ahora vosotros 00:40:57
Matricular a un alumno 00:40:59
De una asignatura 00:41:01
pues este método será 00:41:02
para matricular a un alumno de una asignatura 00:41:05
¿qué datos usa el secretario? 00:41:17
dime tu número de matrícula, dime la asignatura 00:41:26
y ya estás con los datos 00:41:27
pues esos son los datos que habrá que pasarle 00:41:29
el número de matrícula del alumno 00:41:31
porque es el que le identifica de forma única 00:41:34
matrícula 00:41:36
y la asignatura 00:41:39
que la asignatura hemos dicho que es un string 00:41:41
pues venga este método 00:41:43
habrá que localizar 00:41:58
el alumno con este número de matrícula 00:41:59
y una vez localizado meterle la asignatura 00:42:02
matricular uno de asignatura 00:42:04
venga pues 00:42:06
hacedlo 00:42:08
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
3 de marzo de 2024 - 19:04
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
42′ 11″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
192.74 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid