Saltar navegación

Clase 10-05-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 11 de mayo de 2024 por Raquel G.

19 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues nada, vamos a hacer entonces un nuevo proyecto, aplicación gestión FCT, ¿vale? Entonces, la de gestión de alumnos es más sencillita, pero al final viene a ser siempre la misma historia. 00:00:01
un modelo de datos que se supone 00:00:30
que uno lo ha decidido porque ha estudiado 00:00:32
bien el problema 00:00:35
aquí ya está decidido, el modelo de datos es este 00:00:35
ya está, no hay más que decidir 00:00:39
y luego ya 00:00:40
una interfaz 00:00:42
para intercambiar los datos 00:00:44
gráfica o consola 00:00:46
y luego ya una serie 00:00:49
de operaciones a hacer 00:00:50
una serie de operaciones, normalmente se meten 00:00:52
en o en las propias clases 00:00:55
entidad a veces o en clases 00:00:56
aparte están esas funcionalidades 00:00:58
y luego un main que las llama, y ya está 00:01:01
bueno, aquí el modelo de datos ya está 00:01:02
que es 00:01:05
empresa, alumno y profesor, son las 00:01:06
tres cosas que va a manejar la aplicación 00:01:09
vale, pues entonces 00:01:10
empresa 00:01:12
es la que no depende de ninguno, entonces vamos 00:01:16
a hacer la primera, la empresa se 00:01:19
caracteriza por su código, su nombre 00:01:21
y las sedes 00:01:23
las localizaciones 00:01:25
en las que trabaja, entonces las localizaciones 00:01:27
en las que trabaja podría haber una entidad sede 00:01:30
una entidad sede que tuviera su código 00:01:33
y su ubicación, pero en lugar de hacer una entidad sede 00:01:36
aparte se mete en un map y se acabó, entonces 00:01:39
esto lo haríamos 00:01:41
primer paquete 00:01:45
entidades 00:01:46
bins, model, como uno quiera llamar, vamos a llamar model 00:01:48
que es otro nombre bastante habitual 00:01:53
modelo, modelo, modelo 00:01:57
como te la gana, pues venga 00:01:59
empresa, vale, pues 00:02:01
empresa, propiedades, hemos dicho que 00:02:09
el código 00:02:11
el nombre, creo que era otra 00:02:11
y luego una 00:02:20
serie de sedes 00:02:27
que en lugar de hacer, repito, una clase 00:02:29
sede, para los datos de la sede 00:02:33
pues las sedes se guardan 00:02:35
como un map 00:02:40
de esta manera, a ver, hacer 00:02:41
así este diseño no es por justificar 00:02:45
que sea mejor así, ni nada, sino se elige 00:02:47
pues para que sea un ejemplo, un ejercicio en el que se toca un poco todo 00:02:51
entonces, nos han fijado 00:02:55
aquí el tipo de map, un hash map, vale, pues venga 00:03:01
un hash map, vale, desde el momento en el que escribimos 00:03:04
hash map, automáticamente ya nos salta la primera de las 00:03:27
alarmas que tenemos programadas en la cabeza, que es, cuidado 00:03:30
eso significa que las claves 00:03:33
se van a guardar en un hash set 00:03:36
entonces 00:03:39
para que ese hash set 00:03:41
de claves sea 00:03:43
correctamente gestionado 00:03:44
para que pueda ser correctamente 00:03:46
gestionado 00:03:48
esa clase a la que pertenecen las claves 00:03:49
tiene que tener correctamente 00:03:53
implementado el hash code de equals 00:03:54
porque si no tiene correctamente implementado el hash code de equals 00:03:56
un hash set 00:03:59
de esa clase no va 00:04:00
funcionar correctamente 00:04:02
no es que vaya a haber errores de ejecución 00:04:05
pero los resultados no van a ser 00:04:07
correctos 00:04:09
bueno pues 00:04:10
integer tiene jasco de equal, si 00:04:12
como string, como todas las clases 00:04:14
de la librería que usamos 00:04:17
las que hacemos nosotros son las preocupantes 00:04:18
porque las que hacemos nosotros son las que tenemos que darles 00:04:21
el jasco de equal, pero integer ya lo tiene 00:04:23
pues entonces ya esa alarma ya está 00:04:24
resuelta 00:04:27
ala pues 00:04:29
seguimos, pues nada, constructor 00:04:30
getter y setter y mientras no me digan 00:04:32
que meta ningún método más aquí, pues así 00:04:37
me quedo, a ver 00:04:39
un constructor con parámetros y un 00:04:54
constructor sin parámetros 00:04:59
vale, cuando una de las propiedades 00:05:00
cuando una de las 00:05:11
propiedades de 00:05:14
una clase es una colección 00:05:16
una o más de una, es habitual que haya un constructor 00:05:18
que excluya las propiedades que son colecciones, es habitual 00:05:23
ya lo hemos dicho otras veces, de tal forma que tú puedas crear 00:05:27
una empresa con los datos básicos y ya el conjunto 00:05:31
de sus sedes, de sus alumnos, de lo que sea 00:05:36
se pueda ir añadiendo posteriormente uno a uno, es relativamente 00:05:40
habitual, entonces aquí este constructor 00:05:43
pues en lugar de hacer otro 00:05:47
para no 00:05:49
pues este constructor empresa 00:05:50
le vamos a quitar esto 00:05:53
porque nos va a ser mucho 00:05:55
más útil un constructor 00:05:59
así 00:06:01
este constructor no va a ser más útil 00:06:02
porque tiene más sentido crear una empresa con su código 00:06:05
y su nombre y las sedes írselas añadiendo 00:06:07
después, es más 00:06:09
más realista 00:06:11
esa situación, bueno pues ya está 00:06:13
esta entidad ya está, vale 00:06:15
siguiente 00:06:17
el alumno 00:06:18
tendrá su 00:06:21
unía, su nombre y las 00:06:23
empresas en las que 00:06:25
la empresa en la que 00:06:26
trabaja y la sede dentro 00:06:29
de la empresa, eso serían dos números 00:06:31
enteros, el código de la empresa 00:06:33
y la sede dentro de la empresa 00:06:35
entonces se puede guardar en dos números 00:06:37
enteros y ya está, pero aquí pues nada 00:06:39
simplemente pues para que no se nos olviden 00:06:41
los arrays y sepamos usarlos, solo por eso 00:06:43
vamos a meter esos dos códigos 00:06:45
en un array de enteros 00:06:47
bueno, pues entonces 00:06:48
la clase alumno 00:06:51
la clase alumna 00:06:53
hemos dicho que tiene 00:07:01
su número de matrícula 00:07:03
su nombre 00:07:10
el NIA-C 00:07:15
y la sede 00:07:21
y la empresa en la que está asignado 00:07:28
que serían dos códigos enteros 00:07:30
repito, pero se van a meter 00:07:32
los dos juntitos 00:07:34
en un array de enteros 00:07:34
podemos llamar empresa 00:07:38
pero sabemos que aquí dentro de empresa 00:07:43
irán las dos cosas 00:07:44
irá la empresa y la sede 00:07:45
ahí tendrá los dos datos el alumno 00:07:47
vale, pues bueno 00:07:49
get y set 00:07:53
constructor 00:07:55
con parámetros 00:08:05
y constructor sin parámetros 00:08:08
ala, el alumno ya está 00:08:13
esto es 00:08:22
y ahora ya el profesor 00:08:23
que gestiona pues las prácticas de este alumno 00:08:26
pues ahora que tiene 00:08:28
el profesor tiene su if, su nombre 00:08:30
y los alumnos de los que se ocupa 00:08:32
ya está, que van a estar en una lista 00:08:34
una lista de alumnos 00:08:36
aquí 00:09:09
entonces en las listas, pues lo normal 00:09:10
es que ya directamente aquí 00:09:13
la inicialicemos a vacía, para que un profesor 00:09:15
parta con una lista de alumnos 00:09:17
vacía, pero no null 00:09:18
para evitar los null pointer exception 00:09:20
bueno, pues nada 00:09:23
linked list, array list 00:09:25
pues bueno, depende de que vayamos a hacer 00:09:30
si inserciones o consultas 00:09:33
a falta de datos 00:09:35
pues bueno, linked list y ya está 00:09:37
si va a tener pocos alumnos 00:09:39
si no va a pasar de 5 alumnos 00:09:44
pues un array list 00:09:45
porque un array siempre es mucho más eficiente 00:09:47
incluso para inserciones 00:09:49
si son 5 solo, pero como tampoco tenemos ese 00:09:51
dato, pues venga 00:09:53
un linked list 00:09:55
y ahora, constructores, get y set, lo mismo 00:09:56
en el constructor 00:10:07
tiene sentido hacer un constructor 00:10:09
solo con estos dos parámetros 00:10:11
y que los alumnos se vayan agregando luego 00:10:12
seguramente sea más útil esa situación 00:10:14
sea más útil 00:10:16
entonces vamos a hacer un constructor 00:10:17
con ni fin nombre solamente 00:10:19
un constructor sin parámetros 00:10:22
get y set 00:10:27
y ya está 00:10:33
vale 00:10:35
bueno pues aquí 00:10:43
cuando yo he hecho esto 00:10:47
aquí es cuando tendría que haber saltado 00:10:49
otra alarma 00:10:52
desde el momento en que yo 00:10:53
defino una colección, declaro una colección 00:10:56
me tiene que saltar la alarma correspondiente 00:10:59
que tengo ya programada en la cabeza 00:11:01
cuidado, tienes una lista 00:11:02
de alumnos 00:11:05
si tienes una lista de alumnos 00:11:06
normalmente vas a querer usar 00:11:08
los métodos que la clase list 00:11:10
te ofrece, pues como 00:11:12
borrar un alumno 00:11:14
ver si una lista contiene a este alumno 00:11:16
remove, contains, etc. 00:11:18
Ya sabemos que eso solamente funciona 00:11:20
correctamente 00:11:22
si la clase 00:11:23
a la que pertenecen los objetos 00:11:26
de la lista tiene implementado 00:11:28
¿qué? 00:11:30
No, no, no, el comparator no. 00:11:36
No. 00:11:40
El equals. 00:11:41
Solo el equals. Es una lista. 00:11:43
El jasco de equals es para haset. 00:11:44
Entonces, 00:11:48
cuando una lista va a tener 00:11:49
elementos, si queremos 00:11:50
usar la clase LinkedList 00:11:52
o ArrayList sin efectos 00:11:54
secundarios extraños, 00:11:56
esa clase tiene que tener implementado el método 00:11:58
Equals, porque la clase LinkedList 00:12:00
y la clase ArrayList 00:12:02
usan el método Equals 00:12:03
en sus métodos Remove, Contains, etc. 00:12:06
Usan el método Equals. 00:12:09
Si no lo hemos implementado, va a usar 00:12:10
el método Equals de Object. 00:12:12
Y ya sabemos que el método Equals de Object 00:12:15
trabaja por direcciones de memoria. 00:12:16
Y esa no es la realidad. 00:12:18
la realidad es que dos alumnos son iguales 00:12:20
si su NIA es igual, esa es la realidad 00:12:23
no que estén en el mismo sitio en memoria 00:12:24
no, la realidad es que son 00:12:27
iguales si su NIA es igual 00:12:29
y nuestra aplicación gestiona la realidad 00:12:30
no gestiona un mundo inventado de direcciones de memoria 00:12:32
y de RAM 00:12:35
pues entonces para que la linked list 00:12:35
y la array list funcione con el sentido 00:12:38
real 00:12:41
y sus métodos remove, contains 00:12:41
tengan un significado real 00:12:45
alumno tiene que tener un equals 00:12:46
entonces esa alarma es la que nos salta 00:12:48
alumno tiene equals, no lo tiene 00:12:51
entonces va a usar el de object, el de object no es real 00:12:53
el de object es por direcciones de memoria 00:12:56
ese no es real 00:12:58
el método equals real 00:12:58
¿cuál será? 00:13:02
pues por nia en este caso 00:13:03
dos alumnos con el mismo número de identificación 00:13:04
van a ser el mismo 00:13:07
pues entonces yo aquí tengo que darle 00:13:08
realidad 00:13:12
a esta aplicación 00:13:13
me va a gestionar un problema real 00:13:15
entonces me tiene que dar 00:13:18
tiene que modelar 00:13:20
ese problema real, no una cosa rara 00:13:22
de direcciones de memoria y de historias 00:13:24
pues venga 00:13:26
vamos a generar el equals, ¿por qué parámetro? 00:13:27
por el que yo decido que representa 00:13:30
la igualdad, claro, ¿cuál representa 00:13:32
la igualdad en este caso? 00:13:34
pues el NIA solamente 00:13:36
no me hace falta ni la empresa 00:13:38
ni el nombre para ver 00:13:42
si dos a uno son iguales 00:13:44
este valor lo representa de forma única 00:13:45
puede haber entidades 00:13:48
en las cuales para representar 00:13:50
de forma única un objeto 00:13:52
necesito yo dos propiedades, pero en este no 00:13:54
con este ya está 00:13:56
vale, pues si usamos el 00:13:56
a ver, mira mucho por ahí 00:13:59
¿qué pasa? hay una avispa 00:14:02
¿eh? 00:14:03
¿pero porque hay una avispa 00:14:07
intentando entrar o qué? 00:14:08
pobrecita, hombre 00:14:13
vale 00:14:14
el hashcode que nos ha generado 00:14:15
nos sobra, pues fuera, nos quedamos con el 00:14:21
equals y se acabó. 00:14:23
¡Hala! Pues ya tenemos alumno, 00:14:25
empresa, profesor, que ese es nuestro 00:14:27
modelo de datos. 00:14:29
Vale, ahora, 00:14:31
esas clases se supone 00:14:33
que representan una base de datos 00:14:35
que tiene tres tablas, alumnos, profesores, 00:14:37
empresas, y 00:14:39
habrá una correspondencia entre campos de la tabla, 00:14:40
campos de las clases, 00:14:43
pero nosotros ahora mismo no tenemos esa base de datos. 00:14:45
Entonces, nuestros objetos, 00:14:47
los que maneja la aplicación, ¿dónde van a estar? 00:14:49
¿En base de datos? No. 00:14:51
Los objetos tendrán que estar en una colección 00:14:53
de la aplicación. Tienen que estar ahí. 00:14:55
¿Vale? Pues es lo que nos dicen. Nos dicen, los datos 00:14:57
de la aplicación, ya los datos reales, 00:14:59
porque esto es la plantilla. 00:15:01
Esto es el modelo, 00:15:04
la plantilla. Pero luego, los datos 00:15:05
reales, ya los alumnos en 00:15:07
concreto, los profesores en concreto, las 00:15:09
empresas en concreto, o sea, los objetos, los datos 00:15:11
reales, ¿dónde van a estar? ¿En base de datos? No. 00:15:13
¿Dónde van a estar? En un triset 00:15:15
tendremos los alumnos 00:15:17
y profesores 00:15:18
y en un hashe tendremos las empresas. 00:15:21
Ahí están mis datos. 00:15:24
En lugar de tener una tabla de alumnos, 00:15:25
una tabla de profesores y una tabla de empresas 00:15:27
tendremos un triset de alumnos, 00:15:29
un triset de profesores y un triset de empresas. 00:15:31
Bueno, pues venga. 00:15:35
Vamos a... 00:15:36
¿Dónde metemos esos datos? 00:15:39
Vamos a meterlos en otra clase. 00:15:41
Vamos a meterlos en otra clase. 00:15:43
A ver si me ha ido el ratón. 00:15:45
Ah, está aquí. 00:15:46
Bueno, vamos a hacer un paquete de datos 00:15:47
Por hacer más paquetes 00:15:50
Claro, es que este paquete en realidad 00:15:52
No existiría 00:15:55
Porque estos datos estarían en una base de datos 00:15:56
Pero nosotros no, como no tenemos base de datos 00:15:58
Pues entonces nos hacemos 00:16:00
La clase repositorio 00:16:03
Que la llama ahí, o base de datos 00:16:05
Como la queráis llamar 00:16:06
Como dice el enunciado 00:16:07
Y aquí están nuestros datos 00:16:10
Idealmente 00:16:13
Volcados de la base de datos 00:16:14
Pues ala 00:16:17
Aquí tenemos a los profesores 00:16:21
Vale, inicialmente 00:16:24
Inicialmente 00:16:35
Bueno, no hace falta que le ponga 00:16:39
Se lo puedo poner, ¿no? 00:16:43
Pero bueno, hace falta 00:16:44
Inicialmente no hay profes 00:16:45
Se irán metiendo, se irán 00:16:47
Vale, ahí 00:16:49
¿Por qué pongo yo profesores? 00:16:50
Será profesor 00:16:52
Pues lo mismo con alumnos 00:16:53
y lo mismo 00:17:07
con 00:17:09
empresas 00:17:11
alumno 00:17:12
importamos 00:17:15
y esto 00:17:31
era una lista, habíamos dicho 00:17:33
de empresas 00:17:34
una lista que nos han dicho de qué tipo 00:17:38
no, pues el que nos dé la gana 00:17:46
o sí, ah un 00:17:48
haset en caso de empresa, vale 00:17:50
un triset y un haset en caso de 00:17:52
empresa, pues venga 00:17:54
entonces aquí esto es 00:17:56
vale, pues bueno 00:17:58
ahora 00:18:05
nos vuelven a saltar 00:18:09
las 00:18:11
alarmas, vale 00:18:13
aquí nos salta una primera alarma 00:18:15
oye, cuidado 00:18:18
que los profesores van a ir a un triset 00:18:19
eso significa 00:18:22
que yo, de mi triset 00:18:24
profesores, usaré los métodos 00:18:25
que me ofrece el triset para hacer cositas 00:18:28
meter, sacar, etc, etc 00:18:29
claro, pero para que la clase triset 00:18:30
funcione correctamente 00:18:33
la clase a la que pertenecen 00:18:35
los objetos que va a tener dentro 00:18:39
va a tener 00:18:41
tiene que tener implementado el que 00:18:42
triset estoy hablando 00:18:44
casi 00:18:48
eso sí 00:18:54
el claro 00:18:58
el comparable hace el papel del equals 00:19:00
en el caso de los triset 00:19:01
entonces profesor tiene 00:19:03
implementa comparable y tiene implementado 00:19:06
compare tú, no, pues esto 00:19:08
no va a funcionar. ¿Puedo 00:19:09
yo ir a profesor e implementárselo? 00:19:11
Magnífico. Voy y se lo implemento. 00:19:14
No puedo porque esas clases no son mías. 00:19:15
¿Cuál es la siguiente solución que 00:19:18
teníamos? Pasarle un 00:19:19
comparator al constructor. 00:19:23
Decir, vale, 00:19:26
profesor no lo puedo tocar, pero tú, Triset, 00:19:27
usa este criterio de comparación. Te lo paso 00:19:29
a ti solo para que lo uses tú 00:19:31
a través de un comparator. 00:19:32
¿Pero que podemos acceder a profesor? 00:19:35
Genial. 00:19:38
Pues la hacemos que implemente 00:19:39
comparable y ahora ya 00:19:41
los profesores son comparables entre sí 00:19:54
al implementar comparable tengo que 00:19:56
sobreescribir el método 00:19:58
vacío de comparable, el compare tú 00:20:00
y ahora claro lo que tengo es que recordar el sentido 00:20:02
de compare tú, este método es para 00:20:04
ordenar y decidir que profesores 00:20:05
van antes que otros 00:20:08
criterio de ordenación, cual 00:20:09
el que yo quiera 00:20:11
pero que 00:20:13
tenga sentido acorde a mi aplicación 00:20:15
entonces aquí en el enunciado me dicen 00:20:18
El objetivo de que se guarden 00:20:20
Unas y profesores en triset 00:20:22
Es que cuando iteremos 00:20:23
Esta iteración se haga 00:20:25
Ordenadamente según los nombres 00:20:28
¿Vale? 00:20:30
Pues entonces 00:20:32
Vamos a 00:20:33
A que el criterio de compare tú 00:20:34
Sea por orden alfabético de nombre 00:20:38
Pues venga, esto ya lo hemos hecho 00:20:40
Otras veces 00:20:42
Y esto 00:20:44
pues this.getNombre 00:20:47
.compareTo 00:20:52
o .getNombre 00:20:57
vale, este método 00:20:59
ya recordáis que la idea 00:21:03
era devolvía menos uno, cero o uno 00:21:05
menos uno, cero o uno 00:21:07
en función de si iba antes 00:21:09
este, si era el mismo 00:21:11
o si iba antes 00:21:13
este otro 00:21:15
el criterio es 00:21:15
el nombre 00:21:18
pues entonces ordeno alfabéticamente 00:21:20
el nombre, que para eso tengo el compare to 00:21:23
de la clase string, bueno, esto lo hemos hecho 00:21:25
unas cuantas veces 00:21:27
a ver, primero 00:21:29
aquí os aparece el profesor u object 00:21:37
claro, porque no habéis hecho el comparable 00:21:39
parametrizado, habéis hecho el comparable a palo seco 00:21:41
y os ha aparecido 00:21:44
cuando habéis hecho, os ha aparecido una cosa amarilla 00:21:48
a la que no habéis hecho ni caso 00:21:51
a las cosas amarillas hay que hacerles caso 00:21:52
que no pasa nada, lo puedes dejar sin parametrizar 00:21:54
y aquí con object, entonces tienes que hacer el casting 00:21:57
entonces haces el casting 00:21:59
Vale, pues entonces 00:22:00
Alumno también va a un triset 00:22:05
Pues en alumno tenemos la misma historieta 00:22:07
Alumno tendrá que implementar 00:22:09
Comparable de alumno 00:22:11
Y al implementar comparable alumno 00:22:12
Pues otra vez 00:22:24
Ala 00:22:26
Lo mismo 00:22:27
Retundis 00:22:30
Punto getNombre 00:22:36
Punto compareTo 00:22:37
o .getNom 00:22:41
ala 00:22:43
ahora ya 00:22:45
nuestros tríceps 00:22:47
de profesores y alumnos ya van a funcionar 00:22:48
sin ningún problema 00:22:51
a la hora de hacer un contains 00:22:52
a la hora de hacer un remove 00:22:54
lo que sea, va a poder encontrar un alumno igual a otro 00:22:56
porque es el compare to el que se lo dice 00:22:59
vale 00:23:01
ya va a poder encontrarlo, si no, no lo iba a poder encontrar 00:23:03
empresas 00:23:05
va un haset, luego profesor 00:23:07
tiene que tener jasco de equals también 00:23:09
Profesor tiene 00:23:10
Hasco de Equals 00:23:13
Profesor no tiene 00:23:14
Ni Hasco ni Equals 00:23:17
Ni tiene nada 00:23:18
Tiene que tenerlo 00:23:18
Para que este 00:23:19
Es que soy idiota 00:23:20
Esto es empresa 00:23:22
Perdón 00:23:22
Empresa 00:23:23
Empresa 00:23:25
Empresa tiene 00:23:29
Hasco de Equals 00:23:31
Tiene que tenerlo 00:23:32
Para que la colección esta 00:23:33
Funcione correctamente 00:23:35
Porque es un Haset 00:23:36
Pues nos vamos a empresa 00:23:38
Y le hacemos el 00:23:40
Hasco de Equals 00:23:41
por lo que caracterice de forma única 00:23:42
la empresa, vamos a mirar las propiedades 00:23:50
el código 00:23:52
a ver si me dan dos propiedades código y nombre 00:23:53
a ver entiendo yo que es 00:23:58
mucho más probable 00:24:00
que sea el código el que sea único 00:24:02
que no que sea el nombre 00:24:04
pero bueno eso habría que hablarlo con el que nos 00:24:05
mandó la aplicación, decirle oye las empresas con las que vas a 00:24:10
trabajar tienen nombre único 00:24:12
hasco de equals por código 00:24:13
bueno, pues a ver 00:24:20
los datos 00:24:34
todo relacionado con la estructura de datos, ya está 00:24:36
ya está correcto 00:24:38
¿el casco de Icon de qué lo has hecho? 00:24:40
de la propiedad 00:24:43
que lo identifique de forma 00:24:44
única, en profesores 00:24:46
¿no hago el qué? 00:24:53
en la clase de profesor 00:24:54
¿profesor va a formar 00:24:56
parte de algún haset? 00:24:59
¿habla algo de mi aplicación? 00:25:01
Pero eso no es un hased, es un triset 00:25:03
Por eso he hecho el comparable 00:25:07
Que lo acabo de hacer hace 3 minutos 00:25:09
Vale, pues entonces 00:25:11
Ahora, la vista 00:25:16
Pues ya es para comunicarse, pero claro, antes de hacer la vista 00:25:17
Pues lo que hay que ver es 00:25:20
Que vamos a hacer 00:25:21
Que va a hacer la aplicación para ver que componente necesitamos 00:25:22
Etcétera, la vista es lo de menos 00:25:26
Es arrastrar 4 chorradas y ya, la vista no nos importa 00:25:27
Vale, ¿qué tiene que hacer la profesión? 00:25:30
La aplicación 00:25:32
pues 00:25:33
dado ni fin hombre 00:25:35
hacer un alta de un profesor 00:25:38
estos métodos están directamente 00:25:39
ubicados en repositorio, ¿por qué? porque son métodos 00:25:42
que trabajan con datos, entonces tiene sentido que estén ahí 00:25:44
pues venga 00:25:46
alta profesor, esto es 00:25:47
una chorrada, ¿no? 00:25:50
métodos 00:25:53
venga, vamos a ponerlo 00:25:54
aquí, estos serían los requisitos funcionales 00:25:56
o funcionalidades, como los 00:25:58
Quiero no llamar 00:26:02
Funcionalidades 00:26:02
Alta de un profesor 00:26:05
Dados 00:26:09
Su NIF 00:26:22
Y su nombre 00:26:23
Vale 00:26:26
¿Alguien no sabría hacer esto rápidamente 00:26:39
En un minuto en una única línea? 00:26:45
Sabríais, ¿no? 00:26:53
Es meter en un set 00:26:54
Instanciar un profesor con estos datos 00:26:55
Y añadirlo al set 00:27:03
Vamos a dar esto primero, pero vamos 00:27:04
Profesores.add 00:27:08
New 00:27:13
Profesor 00:27:14
Como tenemos un constructor con nif y nombre solamente 00:27:16
Pues nos viene fenomenal 00:27:19
Para esto, y los alumnos ya llegarán más tarde 00:27:22
Perdón 00:27:25
El put solo para maps 00:27:28
Y el add para el resto de colecciones 00:27:33
Vale, a ver 00:27:35
La siguiente 00:27:37
Y son igual de chorras 00:27:39
Vale, 2 y 3 00:27:40
Las ponemos ahí pero las dejamos vacías 00:27:42
Porque es hacer esa línea vosotros 00:27:45
O ya está 00:27:47
Alta alumno 00:27:48
Nia, nombre, código, nombre 00:27:54
Vale, alta alumno 00:28:00
Ahí lo hacéis 00:28:15
Vale 00:28:17
Y alta empresa 00:28:19
Alta empresa 00:28:22
Con la empresa 00:28:31
Lo único que hay que dar de alta 00:28:33
Código de empresa 00:28:34
Y código y dirección 00:28:37
A código y nombre 00:28:40
Perdón, alta empresa, código y nombre 00:28:42
Vale, entonces esta empresa 00:28:44
Cuando se crea inicialmente 00:29:03
Se crea sin sedes 00:29:05
En este método, vale 00:29:06
Porque la empresa luego puede tener sedes 00:29:08
Y la cuarta es 00:29:11
Dada una empresa 00:29:19
Darle una sede 00:29:20
Alta de sede en empresa 00:29:22
Dado el código de empresa 00:29:25
Y código de dirección de la sede 00:29:26
vale, aquí dicen las cuatro 00:29:28
si se trata de dar alta a un elemento 00:29:30
que ya existe 00:29:32
se avisa al usuario 00:29:33
y ya está 00:29:36
el alumno ya existe, el alumno ya existe, etc 00:29:37
entonces 00:29:40
¿eso en qué se traduciría? 00:29:41
en esta primera parte de aquí 00:29:45
profesores, alumnos 00:29:46
empresas, todos están en un set 00:29:56
recordamos todos que en un set 00:30:00
no se pueden meter duplicados 00:30:02
entonces, ¿qué habrá ocurrido con el add 00:30:03
si el profesor ya existe 00:30:06
que no habrá metido nada 00:30:08
que no habrá metido nada 00:30:10
y además el add te avisa con un valor de retorno 00:30:11
¿verdad? eso no ocurre con los list 00:30:15
los list como admiten 00:30:16
duplicados 00:30:19
si tú metes un elemento que ya está 00:30:19
te lo mete en la posición que sea 00:30:22
en la última, normalmente si haces el add 00:30:24
sin parámetros, pero te lo mete 00:30:26
en el set no 00:30:28
entonces si el profesor ya estaba 00:30:29
esto no ha dado error pero no ha insertado 00:30:32
nada, pero sí que ha 00:30:35
devuelto 00:30:37
un false con que no se ha insertado nada 00:30:38
entonces lo que dice aquí de 00:30:41
si el 00:30:42
elemento ya existe, se avisa 00:30:45
bueno, pues esto simplemente 00:30:47
podemos hacer esto 00:30:49
añadimos este if 00:30:51
y ya 00:30:55
¿vale? 00:30:56
entonces 00:30:59
aquí, ¿cuál es el tema? 00:31:00
Aquí el tema es 00:31:04
Esto es lo más interesante 00:31:06
¿Qué significa esto de que se avisa? 00:31:08
Hemos dicho que la comunicación es por interfaz gráfica 00:31:10
Luego esto de avisar aquí poniendo esto 00:31:13
El profesor ya existe 00:31:15
Esto no tiene absolutamente ningún sentido 00:31:18
Porque la consola no va a ver nadie viéndola 00:31:22
Esto saldrá una consola 00:31:25
Pero no va a ver nadie viéndola 00:31:27
Entonces la información del profesor ya existe 00:31:29
Tiene que ir a una interfaz gráfica 00:31:31
A ver, interfaz gráfica 00:31:33
que no hemos construido, está en la vista 00:31:35
la vista ya la haremos con una interfaz gráfica 00:31:37
decidiremos cómo nos comunicamos 00:31:39
con ella, vale, entonces este método 00:31:41
este método 00:31:43
el sentido que tiene es que avise 00:31:44
con un valor de retorno 00:31:47
como no mandando aquí a la vista 00:31:51
nada, porque tenemos que separar clases 00:31:53
la vista ya la haremos 00:31:55
la vista la da otro tío, que no somos nosotros 00:31:56
entonces nosotros no podemos ahora meternos 00:31:59
en su trabajo, la vista la da otro tío que no somos nosotros 00:32:01
entonces, este método nuestro 00:32:03
¿qué hace? se limita a avisar 00:32:06
con el valor de retorno, avisa 00:32:08
de si pudo 00:32:09
dar de alta al profesor o no 00:32:11
y ya el que llame a este método 00:32:13
el que llame a este método 00:32:15
en el main, y en el main ya sí que está a la vista 00:32:17
el que lo llame en función de valor de retorno 00:32:20
ya decide si pone una etiqueta 00:32:22
si pone un semáforo 00:32:24
en rojo, ya lo decide él, ese no es 00:32:26
nuestro trabajo, nuestro trabajo 00:32:27
simplemente es, que estamos haciendo el back 00:32:30
la lógica, nuestro trabajo es avisar 00:32:32
de que no, el profesor 00:32:34
no se pudo dar de alta 00:32:36
como avisamos, repito, no con la consola 00:32:37
avisamos con el valor de retorno 00:32:40
entonces este void 00:32:42
efectivamente, convirtamoslo en un boolean 00:32:43
y entonces 00:32:48
esto 00:32:49
que se convierta en esto 00:32:55
y yo seguro que me he pasado con algún paréntesis 00:32:57
y estupendamente, tan ricamente 00:33:06
vale, esto es 00:33:10
desacoplamiento, que es lo que se persigue 00:33:12
en el desarrollo 00:33:14
desacoplar las partes de la aplicación 00:33:15
yo estoy haciendo la lógica 00:33:17
insertar profesores, recuperar 00:33:19
y aviso 00:33:21
a quien tenga que avisar, que es al que me llama 00:33:23
y el que me llama usa esa 00:33:26
información como le dé la gana 00:33:28
para sacar una ventanita, para lo que quiera 00:33:29
entonces, ¿qué va a hacer este método? 00:33:32
este método 00:33:34
hará el ad 00:33:35
también 00:33:37
también, vale 00:33:42
entonces este método 00:33:44
intenta hacerlo, que lo ha conseguido hacer 00:33:46
fenomenal 00:33:48
lo mete, que no me devuelve 00:33:49
false y me devuelve true, que no me devuelve false 00:33:52
y ya está, entonces estos de abajo 00:33:54
pues será la misma idea 00:33:56
vale, será la misma 00:33:58
idea, voy a poner yo ahora 00:34:00
aquí esto 00:34:04
para que lo completéis vosotros 00:34:05
y aquí lo mismo 00:34:07
esto será 00:34:09
boolean 00:34:11
Pongo esto para que 00:34:15
Ya está 00:34:18
Vale, entonces ahora nos quedaba 00:34:19
Este otro que es 00:34:21
Alta de una sede en la empresa 00:34:23
En una empresa con tal código 00:34:25
Un código y dirección de sede 00:34:27
Pues venga, a ver 00:34:28
Alta sede, empresa 00:34:30
Le tengo que dar 00:34:40
El código de la empresa 00:34:42
Código, empresa 00:34:44
Código 00:34:48
De la sede 00:34:51
Y la ubicación de la sedera 00:34:55
O algo así sería 00:35:00
Vale 00:35:05
Pues aquí que tenemos 00:35:13
Aquí tenemos 00:35:16
Las empresas están aquí 00:35:18
Tendremos que localizar la empresa 00:35:20
Y a esa empresa 00:35:23
Ponerle 00:35:25
En su array correspondiente 00:35:26
Pues venga 00:35:29
hacedlo ahora en estos dos minutos 00:35:31
este método 00:35:33
dos o tres 00:35:34
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
19
Fecha:
11 de mayo de 2024 - 0:18
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 40″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
182.18 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid