Saltar navegación

20250206 Ejer1_Colecciones_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 febrero de 2025 por Raquel G.

26 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues vamos a resolver este primer ejercicio que ya empezasteis a hacer con Raúl, pero como solo hicisteis, creo que muy poquito del principio, porque estuvisteis repasando y como no lo tenéis grabado, lo vamos a hacer entero, ¿vale? 00:00:00
Para repasar en particular listas y podemos extenderlo a conjuntos. 00:00:17
Bueno, realizar una aplicación para gestionar profesores y alumnos, ya nos vienen dadas las entidades, no tenemos que pensar. 00:00:21
alumnos con sus tres propiedades y profesor con sus tres propiedades. 00:00:28
Esta va a ser la propiedad que va a ser una colección. 00:00:34
Ahora ya en lugar de un array va a ser una lista. 00:00:38
Luego la clase main es la que gestiona ya los datos concretos. 00:00:41
Esos datos concretos también serán una colección. 00:00:45
Aquí pone una lista de profesores. 00:00:49
Podemos alterarlo y que sea un set de profesores 00:00:52
que a su vez cada profesor contenga un list y así trabajamos con las dos colecciones. 00:00:57
Vamos a hacer el ejercicio para que en la clase main los profesores no se guarden en una lista, sino en un conjunto. 00:01:02
Incluso se guardará el conjunto de profesores. 00:01:13
En realidad va a tener muy pocas implicaciones a la hora de usarlo. 00:01:20
ya sabemos que las tiene a la hora de la implementación interna pero a la hora de 00:01:24
usarlo son dos colecciones donde se añade se recupera se itera y poco más vale eso sí hay 00:01:28
que tener claro que vale un conjunto vale un set para esta situación entonces profesores 00:01:37
me interesa a mí meter los repetidos en mi conjunto de profesores de mi aplicación pues 00:01:43
no cada profesor una única instancia dentro del conjunto para que quiero tener dos instancias o 00:01:49
tres del mismo profesor en esta aplicación no parece que sea necesario luego entonces sí que 00:01:56
un conjunto que no admite duplicados no admite objetos iguales pues se adaptan vale pues venga 00:02:03
empezamos entidades alumno que es la que no depende de nadie la primera que hacemos la 00:02:10
metemos aquí, en una clase, alumno, ala, nif, nombre y nota, ponía, pues ala, vale, entonces, lo que siempre 00:02:16
hacemos, constructores, get y set, y ya está, por flexibilidad, para quien nos use, le damos las dos 00:02:46
opciones, instanciar con 00:02:54
parámetros o instanciar 00:02:56
sin 00:02:58
parámetros 00:03:00
y get y set 00:03:01
vale, y aquí ya podríamos 00:03:04
poner, podríamos poner equals, podríamos 00:03:11
poner cosas, pero vamos a irlo poniendo 00:03:13
según vayamos identificando 00:03:15
en la aplicación que es necesario 00:03:17
para que así 00:03:18
no se nos olvide y tengamos muy claro por qué 00:03:20
ponemos esos métodos y cuál es el sentido 00:03:23
de que estén ahí 00:03:25
lo que sí que vamos a avanzar es un toString 00:03:26
porque así el system.out.println que usa toString 00:03:29
y otros que usen toString para mostrar el alumno, 00:03:32
pues así en lugar de mostrarnos ese simbolito raro 00:03:38
que muestra el toString heredado de object, 00:03:40
pues nos muestra los datos que realmente tiene este alumno. 00:03:43
Entonces vamos a crear el toString que nos muestra las tres propiedades 00:03:47
y ya está. 00:03:50
Si pasamos el objeto alumno a un system.out, 00:03:53
pues nos mostrará esto en vez de lo de object. 00:03:55
Siguiente entidad 00:03:59
Profesor 00:04:03
Y ya está, no hay más entidades 00:04:04
Es una aplicación sencilla 00:04:06
Esto se correspondería a un modelo de base de datos 00:04:10
En el cual tenemos una tabla alumnos 00:04:13
Y otra tabla profesores 00:04:16
Y ya está 00:04:18
Y cada alumno tiene una clave ajena a su profesor 00:04:19
Se correspondería a eso, la base de datos 00:04:24
para que vayamos de alguna manera conectando esto con el mundo real 00:04:28
que es que los datos están en una base de datos y de ahí se vuelcan a los objetos 00:04:33
bueno, pues los profesores, ¿por qué se caracteriza NIF nombre y su lista de alumnos? 00:04:37
y ahora ya, los alumnos son un montón 00:04:54
ya no nos hace falta meterlo en un array 00:04:56
estaría muy bien meterlo en un array 00:04:58
porque es una estructura de muy buen rendimiento 00:05:01
pero difícil de más que difícil costosa pesada de desarrollar con ella porque es estática entonces 00:05:05
vamos a usar una lista qué tipo de lista bueno pues por ahora no lo sé por ahora la lista la 00:05:16
dejo la referencia como interfaz y ya está la lista de que va a ser la dejo así sin parametrizar 00:05:24
Pues podría 00:05:31
Podríamos decir 00:05:34
Mi propiedad alumnos es una lista 00:05:38
No sé si linked list 00:05:40
Array list 00:05:43
Ahora no me comprometo 00:05:44
Y además no la parametrizo 00:05:45
Entonces esta 00:05:48
Es una opción con la que podemos trabajar 00:05:50
Pero esto es arriesgado 00:05:52
Ya sabemos por qué 00:05:54
Porque entonces automáticamente el compilador 00:05:55
Nos va a dejar que a alumnos 00:05:58
Le metamos cualquier objeto 00:06:00
Da igual que sea un objeto alumno o que sea un objeto mesa. 00:06:02
Va a caer cualquier cosa. 00:06:05
Entonces, si no somos cuidadosos y aquí en esta colección, 00:06:07
en algún momento del código, algún método, 00:06:10
mete algo que no sea un alumno, va a colar. 00:06:12
Pero luego, a la hora de iterar, nos van a salir cosas de esa lista 00:06:15
que vete a saber qué son. 00:06:19
Entonces, vamos a parametrizarlo a lo que realmente vamos a meter ahí, 00:06:22
que son alumnos. 00:06:28
ahora ya en tiempo de compilación estamos más 00:06:29
constreñidos, en tiempo de compilación ya estamos más sujetos 00:06:32
porque ahora ya solo nos van a permitir meter alumnos 00:06:37
muy bien, porque aunque eso hace que el desarrollo 00:06:39
sea más rígido, pero a cambio sabemos seguro 00:06:45
que ahí solamente va a haber alumnos, entonces cuando iteremos, cuando hagamos cualquier cosa 00:06:48
es que nos hace falta hacer casting, porque esos son alumnos y así 00:06:53
Bueno, igual que hacíamos con los arrays 00:06:56
cuando declarábamos una propiedad que era de tipo array 00:07:00
ya en el momento de declararla la inicializábamos a un array vacío 00:07:03
para evitar null pointer exception 00:07:07
porque cuando metíamos el primer elemento 00:07:10
o cuando calculábamos el tamaño del array 00:07:13
en cualquier momento, si todavía no se había rellenado 00:07:16
si ese array no lo declarábamos, pues eso era un objeto null 00:07:19
entonces los primeros accesos 00:07:22
los primeros accesos a esa propiedad 00:07:25
si no somos cuidadosos 00:07:27
programando, como siempre, si no somos cuidadosos 00:07:29
los primeros accesos darían null pointer exception 00:07:31
entonces ya con Arrays 00:07:33
nos hemos acostumbrado a hacer 00:07:35
una primera inicialización de un Array 00:07:36
que existe, pero que no tiene nada 00:07:39
pues aquí igual 00:07:41
podemos seguir esa costumbre 00:07:42
que es buena costumbre 00:07:44
hacer una primera inicialización de esa lista 00:07:45
a una lista vacía 00:07:49
pero que no es nula 00:07:51
ahora ya como vamos a instanciar 00:07:53
ya sí que hay que comprometer 00:07:56
si ya no nos vale la interfaz list 00:07:57
ahora ya hay que instanciar y decir 00:07:59
oye, ¿qué quieres? ¿una lista enlazada o una ArrayList? 00:08:00
bueno, pues funcionan prácticamente igual 00:08:04
con los matices por dentro 00:08:07
son distintas como ya hemos visto 00:08:08
pero su uso es el mismo 00:08:10
su uso es el mismo 00:08:12
salvo los matices que hemos dicho 00:08:13
de que las LinkedList 00:08:15
te ofrecen métodos para simular 00:08:17
el funcionamiento de pilas y colas y eso 00:08:20
pero salvo eso, las dos sirven para lo mismo 00:08:22
para insertar elementos en una posición concreta 00:08:26
¿por cuál optamos? pues ya sabemos, lo hemos dicho mil veces 00:08:30
lista enlazada si sobre todo hay inserciones y borrados 00:08:35
y ArrayList si sobre todo hay consultas, aquí nos da un poco igual 00:08:39
pues venga, vamos a poner una LinkedList 00:08:43
ya tenemos una lista instanciada sin elementos 00:08:46
que importamos del paquete de colecciones 00:08:51
que es el java útil 00:08:54
vale 00:08:56
get y set como siempre 00:08:58
y constructores con y sin parámetros 00:09:03
para flexibilizar un poco 00:09:05
el uso de esta entidad 00:09:13
y de nuevo 00:09:15
aquí podríamos ya adelantarnos 00:09:24
con los equals hashcode etc 00:09:25
pero vamos a ponerlos cuando 00:09:27
ya identifiquemos que nos hacen falta 00:09:29
para entender 00:09:31
de nuevo bien porque los ponemos. Pero sí que vamos a hacer el toString de nuevo 00:09:32
por lo mismo, por si pasamos a un system.out o algo que lo use. 00:09:36
En un toString poner una colección lista es un rollo. 00:09:42
Entonces que el toString me muestre solo nifinombre. 00:09:45
¡Hala! Ya tenemos el toString. Si no nos gusta lo que nos muestra, pues 00:09:49
lo cambiamos. No pasa nada. Bueno, tenemos alumno y profesor. 00:09:52
Y ahora en la clase main una serie de funcionalidades para trabajar 00:09:57
con alumnos y profesores y esos profesores en la clase main que ya es la que se ejecuta la que 00:10:00
tiene los datos de verdad en esa clase main esos datos de verdad que son los profesores de mi 00:10:06
instituto van a estar en un set venga vamos a hacer el main y en esa misma clase main vamos 00:10:13
a meter estas funcionalidades pues a las entidades no tienen nada podrían tener además más métodos 00:10:19
para hacer cosas pues como por ejemplo subir nota un alumno cambiarle el nombre con profesor 00:10:25
insertar un alumno al profesor quitarle un alumno al profesor podríamos poner aquí ya métodos que 00:10:32
hicieran cosas en concreto con cada objeto ahora mismo pues vamos a hacer un main con 00:10:39
funcionalidades simplemente para ver cómo funcionan los list y los set 00:10:44
Vale, pues ahora le hacemos aquí un main 00:10:52
Bueno, pues los datos 00:10:56
¿Dónde van a estar nuestros datos reales de trabajo? 00:11:03
Hemos dicho que un conjunto de profesores 00:11:07
Venga, ¿dónde vamos a crear esa variable conjunto de profesores? 00:11:09
Ya sabemos que tenemos un montón de opciones 00:11:14
¿Vale? 00:11:16
Si la creamos local aquí dentro 00:11:17
Hay que pasársela luego a cada método que hagamos aquí fuera 00:11:20
Eso ya lo sabemos 00:11:24
porque será una variable local y visible solo aquí, como solamente vamos a tener un conjunto de profesores y solo uno, un conjunto, 00:11:25
nos podemos permitir declararla como estática, porque solo va a haber uno, un conjunto de profesores global para toda la aplicación. 00:11:34
Entonces, si nos podemos permitir declararla como estática, nos podemos permitir declararla aquí fuera, porque entonces el main ya la va a poder usar, 00:11:43
porque el main ya sabemos que este static lo tiene sí o sí 00:11:51
porque esta cabecera es obligatoria para que la máquina virtual lo identifique 00:11:54
entonces eso hace que el main 00:11:59
solo pueda usar variables que 00:12:03
están con el modificador static fuera de su ámbito 00:12:07
como acabamos de decir que el conjunto de profesores 00:12:12
solo va a haber uno global para toda la aplicación nos podemos permitir declararlo como estático 00:12:15
pues ala 00:12:19
lo podemos poner aquí fuera 00:12:21
vale set 00:12:23
pues lo importamos de java útil 00:12:32
ah no 00:12:40
lo voy a declarar dentro porque 00:12:44
lo voy a declarar dentro porque así 00:12:45
eh vemos una cosita 00:12:47
más vale lo vamos a 00:12:52
declarar dentro podríamos declararlo fuera como estático 00:12:54
y listo la ventaja de declararlo fuera ya 00:12:56
sabríamos cual es 00:12:58
que ahora todas estas funcionalidades que pongamos 00:12:59
aquí como métodos aparte para ser llamadas 00:13:02
desde main, todas estas funcionalidades 00:13:04
no necesitan que 00:13:06
se les pase por parámetro 00:13:08
el conjunto de profesores, porque 00:13:10
al estar como static aquí fuera 00:13:12
pueden acceder directamente a él 00:13:13
siempre y cuando sean métodos estáticos, claro 00:13:15
siempre y cuando sean métodos estáticos 00:13:18
vale, pero 00:13:20
la voy a declarar dentro 00:13:22
con lo cual me voy a obligar a pasarla 00:13:23
por parámetro a los métodos 00:13:26
y así 00:13:27
lo retorcemos un poco para que nos 00:13:29
Vuelvo a quedar claro algunas cuestiones de herencias. 00:13:32
Vale, pues los profesores van a estar aquí. 00:13:35
Van a ser mi variable un conjunto de profesor. 00:13:37
La voy a parametrizar por lo mismo que ya hemos dicho mil veces. 00:13:42
Porque en el conjunto quiero que ya en tiempo de compilación se me esfuerce a que solo meta profesores. 00:13:45
Así me evito errores de ejecución en iteraciones, en casting varios. 00:13:55
Pues aquí tengo mis profesores 00:14:00
Vale, inicialmente el conjunto de profesores va a ser un conjunto vacío 00:14:03
Aquí en nuestro caso, en una situación real 00:14:08
Ese conjunto de profesores podríamos haberlo volcado de una base de datos 00:14:11
De un fichero, de donde fuera 00:14:14
Pero ahora mismo no sabemos volcar de una base de datos ni de un fichero 00:14:16
Pues una colección vacía 00:14:19
¿Cuál? 00:14:24
Solo hemos mencionado Hachette ahora mismo 00:14:26
No nos ha dado tiempo a más 00:14:30
Así que vamos a poner esa 00:14:31
Hachette 00:14:33
¡Hala! Ya está 00:14:35
Y ahora, ¿qué vamos a hacer con los profesores de nuestro instituto? 00:14:39
Pues los que nos dice aquí 00:14:43
Vamos a insertar uno nuevo que ha llegado al centro 00:14:44
Con sus datos, pero sin alumnos todavía 00:14:49
Pero acaba de llegar 00:14:51
Vale, meterle alumnos a los profesores 00:14:52
Inicialmente con nota 0 00:14:55
luego poner notas a los alumnos de un profesor 00:14:56
a un alumno de un profesor, bueno, claro, poner una nota 00:15:00
de cada profesor, ver el porcentaje de aprobados que tiene 00:15:02
si me dice un alumno, oye, ¿cuáles son mis profes? 00:15:06
dime tu NIF, pues estos son tus profes 00:15:09
si me viene el profesor y me dice 00:15:11
oye, dime los alumnos que tengo yo 00:15:14
pues ala, dame tu NIF, te digo, estos son tus alumnos 00:15:16
y ahora, oye, que un alumno se me ha dado de baja, venga, te lo quito 00:15:20
pues esto es lo que esta aplicación va a hacer 00:15:23
¿Vale? Diferentes utilidades. Pues venga, vamos a hacer la primera. Utilidad de insertar profesor. La vamos a poner aquí. Insertar profesor. Vale. Vamos a ver qué datos necesitamos. 00:15:26
Bueno, esta funcionalidad sí o sí va a necesitar la colección de profesores en la que vamos a hacer la inserción 00:15:51
La va a necesitar sí o sí la colección 00:16:04
Porque el resultado de esta funcionalidad es coger los datos del profesor nuevo y meterlos en esta colección 00:16:07
Entonces va a necesitar los datos del profesor nuevo y la colección 00:16:15
Vale, pues entonces tres parámetros 00:16:19
Porque hemos dicho que va a meter los datos del profe 00:16:22
Que es NIF y nombre sin los alumnos, ¿verdad? 00:16:25
NIF y nombre sin los alumnos 00:16:27
Entonces los dos primeros datos pues están claros 00:16:29
Va a necesitar NIF y nombre 00:16:32
Pero también necesita la cajita 00:16:38
Necesita la cajita para meter ese profe dentro, el conjunto 00:16:40
Vale, entonces este método 00:16:44
Si lo queremos hacer lo más independiente, lo más aislado posible del resto del código 00:16:47
Podemos decir, oye, la caja en la que yo voy a meter mis profesores 00:16:55
Me da igual si es una lista, si es un set 00:17:02
Me da igual 00:17:06
Entonces, si a este método queremos que le dé exactamente igual 00:17:07
Si esa caja que le pasamos es una lista o un conjunto 00:17:14
pues entonces ponemos que el tipo de ese dato es collection 00:17:18
porque ya sabemos que todas las listas y todos los conjuntos 00:17:22
son implementaciones de collection 00:17:25
importemos esta interfaz o clase abstracta 00:17:27
de Java útil 00:17:32
entonces con esto que hemos ganado 00:17:33
que este método sea separado 00:17:36
del resto del código 00:17:39
porque si ahora el código cambia 00:17:42
y decimos, oye ahora ya no quiero un set 00:17:44
ahora quiero que esto sea una lista 00:17:48
porque han cambiado 00:17:49
mis requisitos 00:17:52
y ahora me interesa más que sea una lista 00:17:54
pues esto lo tengo que cambiar porque es una lista 00:17:55
pero este módulo, perdón 00:17:58
este método 00:18:00
perfectamente sigue aquí con su collection 00:18:00
no tengo que cambiar nada 00:18:03
porque list sigue siendo 00:18:05
una implementación de collection 00:18:07
entonces que he ganado poniendo aquí 00:18:09
una super clase 00:18:12
hacer este método mucho más general 00:18:13
y más independiente 00:18:16
que parte de mi aplicación cambia y ahora decido que uso listas 00:18:17
pues este no le toco 00:18:21
y eso es un objetivo deseable en el desarrollo de una aplicación 00:18:22
que cuando yo quiero modificar una parte porque han cambiado mis condiciones 00:18:29
eso implique modificar lo menos posible del resto de la aplicación 00:18:32
si yo aquí hubiera puesto 00:18:37
un set, pues fenomenal 00:18:39
pero fenomenal cuando esto sea set 00:18:44
Pero cuando eso sea list 00:18:46
Pues entonces tengo que venir y cambiar aquí a list 00:18:48
¿Vale? 00:18:51
Entonces eso es 00:18:53
Lo que he ganado poniendo aquí collection 00:18:54
Haber modularizado ese código 00:18:57
Haberlo independizado 00:18:59
Unas partes de otras 00:19:01
Haberlas independizado 00:19:02
¿Vale? 00:19:04
A cambio que he perdido 00:19:07
Pues ya lo vamos a ver 00:19:08
Que 00:19:09
Como esta colección está declarada 00:19:12
Como collection 00:19:15
por mucho que esté instanciada luego como set 00:19:16
como list, como sea, como está declarada 00:19:19
como collection, solo vamos 00:19:21
a poder, el compilador solo 00:19:23
nos va a poder dejar, solo nos va a dejar llamar 00:19:25
a los métodos de collection, a menos que yo 00:19:27
haga un casting 00:19:29
pero en este caso como lo que vamos a insertar que es un 00:19:30
add y el método add está en collection 00:19:33
pues no tenemos ningún problema, declaremoslo 00:19:35
declaremos una referencia 00:19:38
siempre como la mayor super clase 00:19:40
que tiene los métodos que a mi me interesan 00:19:42
como aquí me interesa 00:19:44
¿Add está en Collection? 00:19:46
Sí, magnífico, declarala como Collection 00:19:48
Y así la has hecho lo más general posible 00:19:50
Vale, pues venga 00:19:53
Ahora, pues insertar profesor, pues hombre, más fácil imposible 00:19:56
Vamos a meter en profesores 00:20:02
Add existe 00:20:05
Porque Add está en Collection 00:20:09
Vamos a añadir el nuevo profesor 00:20:10
Un nuevo profesor con datos ni fin nombre, los que me han dado, a ver qué constructores tenía el profesor. 00:20:13
Tenía un constructor con los tres parámetros, esto de aquí, pero lo voy a modificar porque es un poco tonto que le pase el tercer parámetro 00:20:25
si en el momento de instanciarlo ya lo estoy inicializando vacío. 00:20:35
Entonces voy a modificar este constructor para que esto fuera. 00:20:39
Normalmente las colecciones no las inicializo por constructores 00:20:42
¡Hala! Pues entonces 00:20:49
NIF, nombre 00:20:52
Ahí tengo mi nuevo profesor 00:20:55
Pero ya podemos ir adelantando 00:21:00
Para que esta aplicación tenga sentido 00:21:04
Y no tenga un funcionamiento, unos efectos secundarios extraños 00:21:06
Para que esta aplicación tenga sentido 00:21:09
No me debería dejar meter al mismo profesor con el mismo NIF varias veces 00:21:11
Porque a lo mejor se ha equivocado 00:21:16
Él se ha olvidado de que ya fue a dar sus datos 00:21:18
Y vuelve al día siguiente a dar sus datos 00:21:21
Y me aparece en la aplicación dos profesores con el mismo nivel 00:21:23
Eso puede generar efectos secundarios en la aplicación 00:21:25
Que no nos interesan 00:21:28
Vale, pues entonces 00:21:29
¿Cómo evitamos esto? 00:21:32
Pues lo evitamos 00:21:35
Permitiéndole al set 00:21:36
Distinguir cuando un profesor es igual a otro 00:21:38
Ahora mismo no solo hemos permitido distinguir 00:21:42
Porque el profesor no tiene ni Haskell ni Equals. 00:21:45
Entonces, este método add de set, cuando coja el nuevo profesor, va a ver. 00:21:48
Oye, este ya existe, porque yo soy un set y yo no permito meter nada que no exista. 00:21:54
Este ya existe. 00:21:59
Como no tiene Haskell ni Equals, cogerá el de object y el de object te dice. 00:22:00
Oye, es otra instancia, otra dirección de memoria. 00:22:05
Pues es distinto. 00:22:08
Porque eso significa ser distinto para object. 00:22:09
para object ser distinto es 00:22:14
direcciones de memoria separadas 00:22:16
entonces claro, esta dirección de memoria 00:22:17
es separada respecto a la de otro 00:22:19
con el mismo nif que se metiera ayer 00:22:21
entonces el set te lo mete dentro 00:22:23
y estupendo 00:22:26
te has quedado en tu set con dos profesores con el mismo nif 00:22:27
pues mal 00:22:29
pues para que ese set no haga eso 00:22:30
y no me meta un profesor 00:22:33
con el mismo nif dos veces 00:22:35
vamos a darle el criterio de igualdad 00:22:37
¿y cómo se da el criterio de igualdad 00:22:39
para el add? 00:22:42
Y para cualquiera de los métodos de una colección 00:22:42
Pues depende del tipo de colección 00:22:45
¿Qué tipo de colección es profesores? 00:22:48
Pues profesores es 00:22:52
La que yo le voy a pasar va a ser un set 00:22:53
Voy a pasar un set 00:22:55
Un haset, mejor dicho 00:22:57
Un haset es lo que yo habré instanciado 00:23:00
Vale, pues como esta colección será un haset 00:23:03
Para que el método add pueda distinguir 00:23:06
Si un profesor es igual a otro 00:23:10
él evaluará en cascada el Hasco de Equals, ya sabemos lo que eso hace, te lleva a la tabla Has, va por la lista enlazada, etc. 00:23:12
Y la sucesión de Hasco de Equals es la que te permite, la que le permitirá a este método ver si un profesor es igual a otro. 00:23:20
Luego, es el momento de verificar, oye, ¿tengo un profesor Hasco de Equals? Pues no, no tengo un profesor Hasco de Equals, 00:23:27
así que vamos a hacerlo, menos mal que no tenemos que escribirlo a mano, porque tenemos este. 00:23:35
¿Cuál es mi criterio de igualdad? 00:23:40
El NIF 00:23:42
Profesores del mismo NIF son el mismo 00:23:43
Pues hala 00:23:45
Ya tengo el jasco de equals 00:23:47
Vale, magnífico 00:23:50
Pues este método ya está 00:23:53
Ya sabemos que este método 00:23:54
Además de meter al profesor 00:23:58
Si no existe 00:24:01
O no hacer nada si el profesor ya existe 00:24:02
Te devuelve un valor de control 00:24:04
Un boolean 00:24:06
Que puede ser 00:24:07
¿vale? que es true o false 00:24:10
aquí está el boolean 00:24:12
que es true o false en función de si realmente 00:24:13
se insertó algo o no 00:24:16
porque ya estaba 00:24:18
podemos usarlo, podemos usarlo 00:24:19
si queremos como valor de control 00:24:22
¿vale? y decir a este método que devuelva 00:24:23
boolean, pues yo que sé 00:24:26
podemos usarlo, decir oye 00:24:27
si devuelve 00:24:30
aparte de hacer la inserción, porque 00:24:32
te hará la inserción, aparte de hacerla 00:24:34
de paso devuélveme el true o false 00:24:36
para que yo pueda verificar 00:24:38
con el resultado de este método, si me da la gana 00:24:40
pueda llevar un control 00:24:42
de si se hizo 00:24:44
la inserción o no se hizo 00:24:45
¿vale? lo habitual es llevar ese control 00:24:48
con los boolean 00:24:51
¿vale? 00:24:52
bueno 00:24:54
pues insertar profesor ya está 00:24:55
no tiene más historia 00:24:58
venga 00:24:59
agregar nuevo alumno a un profesor 00:25:01
pues esto gracias a que ya no usamos 00:25:04
a raíz, esto ya es facilísimo 00:25:06
venga 00:25:08
agregar un nuevo alumno 00:25:09
alumno nuevo a un profesor 00:25:12
pues ala 00:25:14
static 00:25:16
de nuevo vamos a adelantarnos 00:25:17
haciendo que devuelva boolean 00:25:19
que nos sirva como valor de control 00:25:22
si realmente se insertó de forma efectiva el alumno o no 00:25:23
añade un alumno 00:25:26
a un profesor 00:25:30
¿qué datos va a necesitar este método? 00:25:32
el alumno es nuevo 00:25:34
pues un if y su nombre 00:25:35
porque nos han dicho que la nota cuando le metas un alumno 00:25:37
a un profesor la nota sea cero, luego no hay que ponerle la nota, pues el NIF del alumno 00:25:39
y el nombre del alumno, vale, hay que agregárselo a un profesor en concreto, luego hay que identificar 00:25:52
a qué profesor se lo agrego, pues ese es otro dato que vamos a necesitar, el NIF del 00:25:59
profesor al que se lo voy a agregar, y dónde está mi caja de datos, dónde está mi cajita 00:26:05
de datos donde yo voy a hacer estas cosas 00:26:12
buscar el profesor, una vez que he encontrado 00:26:14
el profesor en la caja, meterle al alumno 00:26:16
donde está mi cajita de datos 00:26:18
pues mi cajita de datos se la tengo que pasar 00:26:19
porque la he declarado localmente 00:26:22
¿vale? 00:26:24
repito, si lo hubiéramos declarado fuera 00:26:26
como estático, obligatoriamente 00:26:27
no tendría que pasársela 00:26:29
¿vale? 00:26:32
pero lo he declarado dentro a propósito 00:26:33
simplemente para 00:26:36
verlo de colección 00:26:38
nada más 00:26:39
Pues venga, vamos a pasarle la cajita 00:26:40
¡Hala! 00:26:44
Ahora ya este método tiene que hacer 00:26:50
Pues buscar en la cajita 00:26:52
Buscar hasta que encuentre el profesor con ese nif 00:26:53
Ya está 00:26:56
La cajita es un set 00:26:56
Luego la cajita tiene que iterar 00:26:58
Perdón 00:27:02
Lo que tenemos es que iterar por el set 00:27:03
Vale 00:27:05
Es un set, no tiene posiciones 00:27:06
No podemos iterar 00:27:09
con un for de índice, posición 1, posición 2 00:27:11
posición 3, no podemos, tenemos que iterar 00:27:17
o con un for each o con un iterador que todavía no hemos visto 00:27:20
vale, mucho más recomendable con un iterador 00:27:24
pues venga, vamos a iterar por ahora con un for each 00:27:28
pues ala, para cada profesor 00:27:32
p en mi cajita de profesores 00:27:36
Vamos a buscar el profesor que yo quiero 00:27:39
Si este profesor que yo estoy cogiendo de la cajita 00:27:44
Resulta que su NIF es igual al NIF del profesor que me han dado 00:27:51
Ya lo he encontrado 00:27:59
Ya lo he encontrado 00:28:01
Pues ¿qué tengo que hacer? 00:28:03
Pues coger sus alumnos que son una lista 00:28:05
Y a esta lista le tengo que añadir el nuevo alumno, el nuevo alumno con nif alumno, nif, perdón, nombre alumno y como me han dicho nota cero, pues cero. 00:28:08
entonces este método 00:28:35
add pues me devuelve 00:28:41
vale 00:28:42
aquí aunque 00:28:44
como alumnos es una lista 00:28:46
aunque exista ya un alumno 00:28:48
con ese nif aunque ya 00:28:51
exista lo va a agregar 00:28:53
igualmente porque 00:28:54
la lista si admite duplicados 00:28:56
vale 00:28:58
entonces si yo agrego al alumno 00:28:59
de nif1 y mañana agrego al alumno 00:29:02
de nif1 otra vez va a estar en la lista 00:29:05
en diferente posición 00:29:07
¿vale? entonces depende 00:29:08
aquí lo estamos haciendo pues 00:29:11
para ejemplificar la 00:29:13
forma diferente que tienen de funcionar 00:29:14
listas y conjuntos 00:29:17
pues depende si yo quiero que pase eso o no quiero 00:29:18
que pase eso pues uso un conjunto 00:29:21
o uso una lista pero solo en el caso 00:29:22
de que no exista etc. 00:29:25
¿vale? entonces por ejemplo aquí 00:29:26
para 00:29:28
seguir viendo cosas de listas 00:29:30
entonces nosotros aquí antes de agregarlo 00:29:33
podríamos hacer lo siguiente 00:29:37
que es antes de agregarlo vamos a decir oye no espérate 00:29:40
yo solamente quiero hacer este ad 00:29:45
solo quiero hacer este ad si el alumno no está previamente en la lista 00:29:49
porque si está previamente en la lista no quiero añadirle 00:29:53
vale pues entonces que podemos hacer 00:29:57
Tenemos un método, que es el método contains, ¿vale? 00:30:01
Que está también en, es de collection. 00:30:11
Tenemos el método contains, que tú le pasas un objeto y te dice, te devuelve true o false, 00:30:14
en función de si existe o no un objeto igual a este en esta lista. 00:30:24
Entonces, esta es la idea de lo que querríamos hacer, ¿no? 00:30:31
Querríamos. 00:30:33
Si no, si no existe un objeto igual a este en esta lista, solo en ese caso lo añado. 00:30:34
Si esto fuera un set, nos ahorraríamos esto, porque ya sabemos que un set ya lo hace el solito. 00:30:46
Bueno, pues si no existe un objeto igual a este en esta lista, lo añadimos. 00:30:52
vale, entonces para que este 00:30:58
contains haga lo que queremos 00:31:00
aquí tendremos que pasarle 00:31:02
un objeto 00:31:04
igual al objeto 00:31:06
alumno, que vamos a insertar 00:31:08
vale 00:31:11
aquí nos viene de nuevo lo de la igualdad 00:31:12
espérate, en alumno 00:31:14
¿qué significa ser igual? 00:31:16
¿qué significa ser igual en alumno? 00:31:18
vámonos aquí a alumno 00:31:21
en el sentido de mi aplicación 00:31:22
va a ser que 00:31:24
sea en el mismo nif 00:31:26
El NIF sería la clave primaria 00:31:27
Pues para que esta aplicación tenga sentido 00:31:30
Dos alumnos son iguales y su NIF es el mismo 00:31:33
Pero es que eso yo no lo he reflejado 00:31:35
Aquí, yo no lo he reflejado 00:31:38
Entonces, el criterio de igualdad 00:31:40
Lo tengo que reflejar 00:31:43
Si quiero que el resto de la aplicación sea coherente con él 00:31:45
¿Cómo lo reflejo? 00:31:48
¿Con jasco de equals con los dos? 00:31:50
¿O con equals solo? 00:31:52
Depende 00:31:54
depende de qué colección esté usando este guardando alumnos vámonos aquí estoy hablando 00:31:55
de la colección está los alumnos del profesor los alumnos del profesor que son son una lista 00:32:04
bueno pues la lista solo necesita el método equals para comprobar la igualdad solo con lo 00:32:11
cual esto me va a funcionar bien si yo pongo aquí el jasco de iguales perdón el licua sólo 00:32:19
basado en que en mi clave primaria a ver puede dejar el jasco si no molesta lo que pasa es que 00:32:27
los métodos de list los métodos de list sólo van a mirar y cuáles para ver la igualdad solo pero 00:32:40
bueno el jasco no molesta y si lo dejo que ventaja saco que si luego cambio mi aplicación y empiezo 00:32:46
hacer conjuntos de alumnos 00:32:53
haset de alumnos 00:32:55
o linked haset, entonces voy a 00:32:57
tener que incorporar el hascode, entonces ya sí 00:32:59
entonces bueno, como no molesta, lo puedo dejar 00:33:01
ahí y si en futuras ampliaciones 00:33:03
de mi aplicación empiezo a usar 00:33:06
haset de alumnos, pues 00:33:07
ya lo tengo, no tengo que incorporarlo 00:33:09
bueno, pues lo puedo dejar 00:33:11
bueno, pues entonces ahora ya 00:33:12
este contains ya va a ser 00:33:15
capaz de saber qué significa ser 00:33:17
igual a, porque tiene el equals en alumno 00:33:19
pues ahora lo único que tengo que hacer es 00:33:21
pasarle yo un objeto igual 00:33:23
al que quiero verificar si existe 00:33:25
pues hombre 00:33:27
para 00:33:29
entenderlo, le paso yo 00:33:31
un objeto cualquiera 00:33:33
con ese if 00:33:34
el nombre me da lo mismo 00:33:36
el nombre me da 00:33:41
lo mismo, le puedo poner un null 00:33:43
tranquilamente y la nota 00:33:45
me da lo mismo 00:33:47
porque este objeto de aquí 00:33:48
está creado, solo 00:33:50
está creado, solo 00:33:53
para dárselo al contains 00:33:55
y que el contains busque a ver 00:33:57
si hay alguno igual a este 00:34:00
y cuando el contains va a decir 00:34:01
si hay alguno igual a este 00:34:03
pues cuando haya uno cuyo nif sea igual 00:34:05
porque el equals solo tiene el nif 00:34:07
luego por eso 00:34:10
aquí me da igual lo que le ponga 00:34:12
me da igual 00:34:14
pero eso sí, al contains hay que pasarle un objeto alumno 00:34:14
la igualdad es entre objeto 00:34:17
alumno y objeto alumno 00:34:20
no tiene sentido que yo aquí le pase 00:34:22
solamente un if, porque la igualdad 00:34:24
no es entre if y alumno 00:34:26
la igualdad es entre objeto 00:34:28
alumno y objeto alumno 00:34:30
entonces le tengo que pasar un objeto alumno 00:34:31
pero eso sí, estos dos parámetros me dan 00:34:34
exactamente igual, porque el equals 00:34:36
que va a usar contains para ver 00:34:38
si existe alguno igual a este 00:34:40
en esta colección 00:34:42
solo va a mirar esto de aquí 00:34:43
bueno, pues entonces ahora ya sí 00:34:45
si no existe 00:34:48
un alumno igual 00:34:50
que este, o lo que es 00:34:52
mismo con ese en mi colección de alumnos si no existe pues lo añades y ya está como hemos puesto 00:34:54
el valor boolean de control pues le podemos poner aquí un retorno y estupendo porque así ya matamos 00:35:04
dos pájaros de un tiro vamos a devolver el true o el falso que en este caso será true porque la 00:35:13
inserción se va a hacer de forma efectiva a menos que falle alguna otra cosa extraña 00:35:17
no solo ya tenemos el valor de retorno 00:35:20
sino que 00:35:24
además 00:35:26
paramos ya el for 00:35:27
¿vale? como solo va a haber 00:35:29
un profesor con este nif, se supone 00:35:32
solo va a haber un profesor con ese nif 00:35:34
pues ya paramos el for each 00:35:35
el for each no se está ahí hasta el infinito, es como hacer un break 00:35:37
bueno, feillo 00:35:40
pero ya está 00:35:42
¿vale? nos da un error 00:35:43
de compilación que es 00:35:46
fácilmente esperable 00:35:48
que te dice, oye, cuidadín 00:35:50
y que pasa si no encuentro ningún profesor con este NIF 00:35:53
no entraríamos jamás a este NIF 00:35:59
con lo cual nunca saldríamos por este retun 00:36:02
llegaríamos a este punto de aquí fuera 00:36:06
y el método necesita un retun, sí o sí lo necesita 00:36:08
porque me devuelve un boolean 00:36:12
el método necesita un retun, sí o sí 00:36:13
pues hombre, si yo salgo del método por este camino 00:36:16
porque no encontré ningún profesor 00:36:19
con ese nif, si salgo del método por este camino 00:36:21
el return hay que dárselo igual 00:36:24
no habría que dárselo si fuera un void 00:36:25
claro, pero es un boolean 00:36:27
bueno, pues 00:36:29
¿qué return le damos en ese caso? 00:36:30
pues false, porque es que no he hecho ninguna inserción 00:36:33
pues magnífico, este valor 00:36:35
boolean efectivamente nos va a devolver 00:36:37
nos va a devolver true 00:36:39
si hemos encontrado al profe y le hemos insertado 00:36:40
el alumno 00:36:43
¿vale? 00:36:45
Y nos va a devolver 00:36:46
False en caso contrario 00:36:49
Si no hemos encontrado al profesor 00:36:51
O si habiendo encontrado al profesor 00:36:53
Tiene ya a ese alumno 00:36:56
Que es justo lo que queremos 00:36:58
True 00:37:00
Si se hizo la funcionalidad de forma efectiva 00:37:00
False 00:37:04
Si no se hizo de forma efectiva 00:37:04
¿Verdad que sí? 00:37:06
Venga 00:37:10
Adalumno profesor 00:37:10
Estaría ahí 00:37:14
poner nota a un alumno de un profesor 00:37:15
dado, pues vamos a ir 00:37:22
método, pues mira, ya que nos estamos 00:37:24
aficionando a los valores de control true o false para ver si el método 00:37:38
de forma efectiva ha cumplido con su funcionalidad o no, vamos a seguir con el boolean 00:37:42
y ahora venga 00:37:46
poner nota, poner nota a quien? a un alumno 00:37:47
alumno. ¿A un alumno de quién? De un profesor. ¿Qué nota? Pues no lo sé, vamos a dársela. 00:37:54
¿Y dónde está mi caja de trabajo? ¿Dónde están los profesores? ¿Mis datos? ¿Dónde 00:38:10
están mis datos? Pues están aquí. Aquí le paso la cajita. ¿Más datos? Pues no, 00:38:14
que me vengan a mí a la cabeza, no van a necesitar más datos. Pues el mismo rollo, 00:38:27
vamos a tener que iterar por la caja de profes, hasta encontrar el profesor. Cuando encontremos 00:38:31
el profesor, localizar al alumno 00:38:36
con ese NIF y ponerle la nota. 00:38:38
Es un rollo de iteraciones. 00:38:41
Es un rollo de iteraciones. 00:38:43
¿Por qué? Porque tenemos una caja 00:38:46
ahí con todos los profesores a mogollón. 00:38:48
Y para localizar 00:38:51
uno, hay que ponerse a iterar. 00:38:52
¿Eres tú? No. ¿Eres tú? No. 00:38:55
¿Eres tú? No. ¿Eres tú? No. 00:38:56
Este rollo de iterar en la caja hasta que 00:38:58
encontramos el que queremos, 00:39:00
nos lo van a facilitar 00:39:03
los mapas y diccionarios. 00:39:04
Porque cuando buscamos un significado en un diccionario, no nos vamos por todos los significados del libro hasta que encontramos el que queremos. 00:39:06
No, nos vamos directamente a la palabra que está ordenada por orden alfabético. 00:39:14
Nos vamos a la palabra y ahí nos vamos a tiro fijo. 00:39:19
Pues los mapas, que todavía no hemos visto, van a evitarnos todo este rollo de iteraciones. 00:39:22
Pero ahora tenemos un conjunto, pues hay que meternos en la caja y empezar a sacar, a sacar, a sacar. 00:39:27
De nuevo, no tenemos el literador 00:39:32
Un rollo, porque literador es la mejor forma de literar 00:39:34
No lo tenemos porque no lo hemos visto 00:39:37
Pues ala, literamos otra vez 00:39:39
En nuestra cajita 00:39:42
Literamos en nuestra cajita 00:39:46
A ver si encontramos al profesor 00:39:49
Con ese nif 00:39:51
¿Y cuál es el nif de profesor? 00:39:52
Uy, ya me he encontrado 00:40:01
Al profesor correspondiente 00:40:02
Vale, pues ahora 00:40:04
nos toca iterar por su cajita de alumnos hasta encontrar el alumno con este NIF, ¿vale? Cuando 00:40:06
lo encontremos le ponemos la nota y punto pelota, ¿vale? Pero aquí vamos a operar de forma distinta. 00:40:20
Los alumnos del profesor tenemos la suerte de que son una lista. Esto, que son los alumnos del 00:40:29
Entonces, como son una lista, tienen posición. 00:40:35
Entonces, si yo tuviera la suerte de tener la posición del alumno con ese NIF, 00:40:42
si yo tuviera la suerte de tener la posición del alumno con ese NIF, 00:40:52
si la tuviera, genial, porque me cojo al alumno de esa posición, 00:40:55
que podré hacerlo porque esto es una lista 00:41:01
que podré hacerlo 00:41:04
y a este alumno ya 00:41:06
le pongo la nota que sea 00:41:07
¿vale? 00:41:10
pero claro 00:41:13
el problema es que, jolines, ¿y cuál es la 00:41:14
posición del alumno con ese NIF? 00:41:16
ojalá la tuviera, pero no la tengo 00:41:18
¡ah! 00:41:20
ojo 00:41:22
las listas tienen un método 00:41:22
que es el método 00:41:26
indexOf 00:41:28
que no tienen los conjuntos 00:41:29
porque los conjuntos no tienen posiciones 00:41:32
entonces las listas 00:41:34
sí que tienen este método 00:41:36
que este método 00:41:38
te devuelve 00:41:40
la primera posición 00:41:41
en la que ha encontrado 00:41:44
un objeto igual a este 00:41:46
que tú le des 00:41:48
entonces esto te va a devolver 00:41:49
una posición 00:41:52
¿y qué posición te va a devolver? 00:41:53
te va a devolver la posición dentro de la lista 00:41:58
La primera en la que ha encontrado un objeto igual a ese 00:42:00
Pues justo lo que queremos 00:42:03
Vamos a pasarle aquí un objeto igual al alumno que estamos buscando 00:42:05
Un objeto igual al que estamos buscando 00:42:10
Y ya tengo su posición 00:42:12
Pues venga, para eso me creo un alumno igual al que estoy buscando 00:42:14
Y como el criterio de igualdad que hemos programado en Equals 00:42:20
Solo se basa en alumno 00:42:23
Pues yo aquí le paso cualquier nombre y cualquier cosa al constructor 00:42:25
si tuviera un constructor solo con clave primaria 00:42:29
con el nif, pues más cómodo 00:42:31
no lo tengo 00:42:33
vale, pues ya está, genial 00:42:33
este índice me da 00:42:36
la posición, la primera posición que ha encontrado 00:42:39
única, porque 00:42:41
cuando estamos insertando alumnos 00:42:43
no los estamos insertando repetidos, gracias a este 00:42:45
contains 00:42:47
la primera y única posición 00:42:47
en este caso, que ha encontrado donde hay un alumno 00:42:51
con ese nif, ostras, pues magnífico 00:42:53
me voy a la lista 00:42:55
y ahora ya a esta lista 00:42:57
recupero el alumno por su posición 00:43:00
cosa que puedo hacer 00:43:02
porque es una lista 00:43:04
no es un conjunto 00:43:05
lo recupero por su posición 00:43:07
y ahora ya a este alumno le digo 00:43:09
tú, nota la que me han pasado 00:43:11
y ya está 00:43:14
¿vale? y ya está 00:43:15
entonces 00:43:17
si he llegado hasta aquí 00:43:19
es que he encontrado el profe 00:43:22
dentro del profe 00:43:23
Vale, he encontrado el alumno, bueno, espérate, porque index of, si no encuentra, hay que ver que te devuelve pos, menos 1, ¿vale? 00:43:25
Cuidadín, te devuelve menos 1, entonces esto habría que meterlo dentro de un if pos diferente de menos 1, no vaya a ser que hagamos un get menos 1, excepción, ¿vale? 00:43:37
Si post es 00:43:50
E mayor 00:43:53
O igual que 0 00:43:56
Es decir, me ha encontrado una posición 00:43:58
0, 1, 2, 3, la que sea 00:44:01
Me ha encontrado una posición 00:44:03
Ahí, ojo 00:44:04
Y ya aprovecho y con el retun me voy de ahí 00:44:06
Como si fuera un break 00:44:09
Aprovecho 00:44:11
Ya encontré el profe, ya encontré el alumno 00:44:13
A la aprovecho y me piro 00:44:15
Me piro con un retun true 00:44:17
Porque se ha hecho 00:44:19
Todo lo que había que hacer 00:44:21
me piro de ahí, pero ya sabemos 00:44:22
lógicamente que el compilador que mira 00:44:24
la línea de flujo, dice 00:44:26
ah, sí, claro, ¿y qué pasa si nunca 00:44:28
encuentras profesor 00:44:30
con lo cual nunca entras en este if 00:44:32
o si entrando en ese if 00:44:34
no encuentras al alumno, luego 00:44:36
no sales por aquí, ¿qué pasa? 00:44:38
si llegamos a este punto de aquí 00:44:40
pues si llegamos a ese punto 00:44:42
de ahí 00:44:44
lo que ha pasado es que no hemos 00:44:45
encontrado 00:44:48
los datos que buscábamos 00:44:49
pues entonces tenemos que irnos del método igualmente 00:44:52
pero en este caso devolviendo falso 00:44:54
vale 00:44:56
el compilador se queda tranquilo 00:44:57
y el método bien hecho 00:45:00
vale pues ya está 00:45:01
a ver vamos a parar aquí un momentito 00:45:04
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
26
Fecha:
6 de febrero de 2025 - 11:56
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
45′ 07″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
193.43 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid