Saltar navegación

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

18 visualizaciones

Más información Transcripción

Descargar la transcripción

Habéis hecho algo así 00:00:00
Entonces aquí habrá que 00:00:03
Habrá que 00:00:04
Localizar la empresa 00:00:13
Y como la empresa está en un set 00:00:15
Para localizarla hay que iterar por ella 00:00:18
Si tuviéramos un map 00:00:20
Es más fácil porque tenemos el método get por clave 00:00:22
Y pa, de golpe nos sale la empresa por la clave 00:00:24
Como no está en un map 00:00:27
Sino que está en un set, pues para localizarla hay que iterar 00:00:28
Vale, pues una vez que hemos iterado 00:00:30
Ya le pondremos la sede 00:00:32
que me han dado en su 00:00:34
map de sedes 00:00:35
en su map de sedes 00:00:37
pero para localizarla hay que iterar 00:00:39
entonces 00:00:42
pues para iterar, pues bueno 00:00:43
le he puesto un iterador 00:00:46
para que nos lo veamos del iterador 00:00:50
y ahora ya iteramos 00:00:51
para cada empresa, si es la que 00:00:53
estamos buscando 00:00:56
si es la que estamos buscando 00:00:57
cojo su 00:00:59
primero voy a mirar a ver si no está 00:01:01
esa sede ya que quiero meter 00:01:04
si no está, la meto 00:01:06
y devuelvo true 00:01:08
vale, he podido meter la sede 00:01:10
que no está 00:01:12
perdón, que sí que estaba 00:01:14
que sí que contenía ya esa sede 00:01:15
pues devuelvo false, no hago nada 00:01:18
ya está, algo así 00:01:20
ya está, ¿no? 00:01:22
entonces aquí, repito 00:01:24
para localizar la empresa en un set 00:01:25
tenemos que recorrerlo 00:01:27
bueno, pues he recorrido con un iterador 00:01:28
ya la hemos localizado a través de este if, ya está 00:01:31
Ahora, ¿qué queremos hacer con esa empresa? 00:01:34
Con esa empresa queremos coger sus sedes 00:01:36
Que es un map 00:01:38
Para ver si ya está 00:01:38
La que me han pedido que meta, que es esta 00:01:40
Para ver si ya está 00:01:43
Si no está, le pongo la nueva sede 00:01:44
Y ya está, y el método termina 00:01:50
Que sí que estaba 00:01:51
Pues devuelvo false 00:01:54
Y ya el que haga este método 00:01:55
Diga, oye, que ya existía la sede, no existía 00:01:57
Y el error este 00:02:01
Yo creo que tengo una llave de más o de menos 00:02:03
Esta es la del while 00:02:05
Esta es esta 00:02:17
La del método 00:02:21
¿Eh? 00:02:22
¿Qué me falta? 00:02:24
A ver, pero no sé dónde 00:02:27
Porque, a ver, esta es la del while 00:02:28
Ah, no, esta me sobra entonces 00:02:29
Espera, vamos a ver 00:02:32
Sí, porque esta es la del if 00:02:33
Ah, vale, vale, es que esta es 00:02:36
Me estoy liando 00:02:38
A ver, voy por partes 00:02:40
Esta está clara, que es esta 00:02:41
Esta es la del if, vale, entonces sí, me falta 00:02:43
Porque esta es la del método 00:02:46
Vale, me falta la del while 00:02:47
Sí, pero 00:02:49
Vale 00:02:57
Vale 00:02:58
Y ahora ya me falta 00:03:06
Este error de compilación, lógicamente me da 00:03:12
Porque yo aquí estoy saliendo 00:03:14
Por true o saliendo por false 00:03:16
Asumiendo que he encontrado la empresa 00:03:17
Asumiendo que la encuentro 00:03:20
Porque si yo no encuentro la empresa, este while termina 00:03:21
y yo no he entrado nunca ni aquí ni aquí 00:03:24
entonces puede que la empresa no exista 00:03:26
y entonces yo me encuentro en este punto 00:03:28
y en este punto también tengo que hacer 00:03:30
algún return 00:03:32
bueno pues en este caso 00:03:33
yo llego aquí si la empresa no está 00:03:36
entonces si la empresa no está tampoco he podido dar 00:03:38
de alta nada, pues aquí entonces tiene sentido 00:03:40
que yo diga false 00:03:42
es decir, el método 00:03:43
solo va a devolver true 00:03:46
solo si se ha podido dar de alta 00:03:48
correctamente una sede en la empresa 00:03:50
es decir, si la funcionalidad se pudo completar 00:03:52
la sede se dio de alta en la empresa 00:03:54
si no se pudo completar la funcionalidad 00:03:56
bien porque la sede ya existía 00:03:59
o porque la empresa no está 00:04:01
devuelve false 00:04:03
y no puedo distinguir más 00:04:04
el que usa este método no puede distinguir 00:04:07
el false de donde viene, no puede 00:04:10
no puede 00:04:11
porque solamente hay un posible valor de retorno 00:04:12
si yo quisiera 00:04:15
que el que llama al método pueda distinguir 00:04:16
si el error ha sido 00:04:19
porque no existe la empresa 00:04:21
o el error ha sido porque existiendo la empresa 00:04:23
ya tenía la sede. Si quisiera 00:04:25
esa distinción, ¿qué tendría 00:04:27
que hacer? ¿Qué herramienta podría utilizar? 00:04:29
Tendría que generarme 00:04:34
excepciones. 00:04:35
Empresa no encontrada exception. 00:04:37
Sede ya existente exception. 00:04:40
Y aquí 00:04:43
en lugar de retun, hacer un throw. 00:04:43
Throw, aquí en lugar de 00:04:45
este retun falso, es decir, throw 00:04:47
sede ya existente exception. 00:04:49
Y aquí hacer throw 00:04:51
empresa no existente exception 00:04:53
esa sería la otra utilidad de programación 00:04:55
que yo podría usar, si quisiera distinguir eso 00:04:57
pero bueno, en este caso 00:04:59
pues el que me llame al método, cuando 00:05:01
le devuelva, se dirá, no se pudo completar 00:05:03
la funcionalidad, y ya está, no le damos más detalles 00:05:05
de por qué no se pudo 00:05:07
bueno, pues venga 00:05:08
asignar una empresa a un alumno 00:05:12
dado código de 00:05:15
empresa, código de NIA y patatín 00:05:17
vale, y aquí efectivamente 00:05:19
me dice, cuidado 00:05:23
si pasa algo de esto 00:05:25
avisa con una excepción 00:05:27
pues venga, a ver 00:05:28
este método, vamos a poner la cabecera 00:05:36
y se queda ahí, vamos a 00:05:39
se avisará, entonces con avisarse 00:05:41
ese es el retún falso 00:05:49
claro, claro, luego ya el que llame 00:05:50
al método, ese falso, que lo use en su vista 00:05:53
poniendo un mensajito 00:05:55
lo que quiera 00:05:57
Vale, en 4, 5 es la que estamos 00:05:57
Asignar empresa, alumno, dado 00:06:04
Vamos a poner la cabecera y 00:06:06
Empresa, alumno 00:06:08
Entonces, ¿qué datos van a hacer falta 00:06:20
Para asignar una empresa a un alumno? 00:06:23
Pues código de empresa, código de alumno 00:06:25
Y la sede en la que va a trabajar, ¿verdad? 00:06:26
Código de empresa 00:06:30
Sede y alumno 00:06:31
Las únicas tres cosas que hacen falta 00:06:32
Pues 00:06:34
Code 00:06:37
Empresa 00:06:43
Code, sede 00:06:44
y nia del alumno 00:06:51
vale 00:06:53
int 00:07:04
y este método 00:07:06
va a tener que 00:07:10
lanzar 00:07:15
lanzar 00:07:18
empresa sede 00:07:23
exception 00:07:27
si no existe empresa o sede dentro 00:07:28
de la empresa 00:07:31
y también puede ser que lance 00:07:32
esto otro 00:07:40
alumno exception 00:07:42
vale 00:07:48
bueno vamos a completar este por eso de la excepción 00:07:55
y luego vamos a hacer 00:07:58
algún otro pero no todos 00:08:00
para luego ya hacer la vista 00:08:01
hacer ya una vista para que la aplicación funcione 00:08:03
entonces aquí 00:08:05
lo primero que tenemos que hacer son estas dos 00:08:07
excepciones, estas dos vamos a tener que crearlas 00:08:10
nosotros porque obviamente no son excepciones que existen 00:08:12
en la máquina virtual de Java 00:08:14
hay que crearlas, pues para eso 00:08:15
nos hacemos un paquete 00:08:18
exception 00:08:19
venga, pues este 00:08:27
paquete exception que tenga 00:08:31
una primera clase 00:08:33
voy a ver que 00:08:37
alumno exception, empresa sede exception 00:08:38
empresa sede 00:08:41
exception 00:08:45
ala 00:08:47
esta que herede 00:08:50
de exception 00:08:55
y le hacemos un constructor con el 00:08:57
mensajito que nos dé la gana y ya está 00:09:02
pues era 00:09:04
no existe la sede, no existe 00:09:20
la empresa o la sede, para cualquiera de esas 00:09:23
dos cosas, se daba ese 00:09:25
o no existía la empresa, o bien no existía 00:09:26
la sede dentro de la empresa, para cualquiera de las dos 00:09:29
salía esto, ala, esta 00:09:31
ya está, y ahora 00:09:33
nos falta la otra, alumno 00:09:35
excepción, vale 00:09:37
pues un constructor 00:09:55
vale, uy, que hago yo 00:09:56
no existe 00:10:06
el alumno era, no 00:10:15
ala, pues estas excepciones son para avisar 00:10:16
de estas dos cosas, no existe 00:10:25
el alumno que quieres dar de alta en una empresa 00:10:27
o no existe 00:10:29
la empresa o la sede en la que quieres 00:10:31
situar a ese alumno. Esas excepciones son 00:10:33
para avisar de eso. Entonces, el método de 00:10:35
avisar con excepciones es mucho más específico 00:10:37
obviamente y más complejo que 00:10:39
mediante un retunfalse. 00:10:41
El que usa el método sabe que cuando 00:10:42
recibe un false algo raro ha pasado. 00:10:44
Pero este al menos tiene una información 00:10:47
más completa. El problema 00:10:48
¿cuál es? Que tiene que capturar. 00:10:51
Vale, pues nada. Entonces, ahora ya 00:10:54
sí que podemos hacer el método. 00:10:56
que el método nos dice 00:10:57
asignar empresa a un alumno 00:10:59
entonces el alumno donde tiene 00:11:00
las empresas puestas 00:11:03
pues las tiene aquí 00:11:05
entonces 00:11:07
habrá que ver 00:11:09
primero hay que localizar el alumno 00:11:10
aquí, hay que localizarlo 00:11:12
porque si el alumno no existe 00:11:14
se lanza la primera de las excepciones 00:11:16
y una vez localizado 00:11:18
ahora ya hay que meter 00:11:20
hay que añadir 00:11:23
en este array un código 00:11:25
y una 00:11:27
perdón, no estoy liando 00:11:27
empresa 00:11:31
tiene código y 00:11:33
entonces hay que ponerle aquí en empresa su código 00:11:34
y su sede, pero hay que ver previamente 00:11:37
que esa empresa y que esa sede estén aquí 00:11:39
porque si no están se lanza la excepción 00:11:40
vale, pues entonces, ya está, primero 00:11:43
vamos a comprobar a ver si el alumno existe 00:11:46
porque si no existe lanzamos la excepción 00:11:48
¿el alumno dónde está? 00:11:50
el alumno está en un set 00:11:52
luego hay que recorrerlo 00:11:54
Hay que recorrerlo. 00:11:56
Entonces, lo primero que podemos hacer es para... 00:11:58
Así como... 00:12:03
Vale, pues venga, vamos a recorrerlo con un for each esta vez para variar. 00:12:06
Pues para cada alumno A en alumnos. 00:12:10
Vale, para cada alumno A en alumnos. 00:12:18
Entonces, si a.getNia es igual a el Nia del alumno que me han pasado 00:12:23
Ah, lo he llamado alumno 00:12:35
Mejor si este parámetro lo llamo Nia, ¿no? 00:12:38
Es igual a este Nia 00:12:45
Vale, pues este sería el alumno al que tengo que fijarle 00:12:46
A este alumno tendría que fijarle aquí 00:12:52
En setEmpresa 00:12:54
Tendría que fijarle un array 00:12:56
Con el código de empresa 00:12:59
Y con el código de la sede, algo así 00:13:01
¿Vale? Esta sería la idea 00:13:02
¿Vale? 00:13:13
¿Vale? Pero yo lo he hecho así 00:13:16
Para tener claro que tendríamos que hacer 00:13:17
Pero recordad que esta forma 00:13:18
De darle valor a arrays 00:13:20
Solo vale 00:13:23
Solo le vale al compilador cuando estamos dando 00:13:24
Un primer valor a un array declarado 00:13:27
Entonces yo lo he puesto aquí 00:13:29
Entonces esto no lo haríamos así, lógicamente 00:13:30
Aquí tendríamos que hacer 00:13:32
Lo hacemos así 00:13:33
Pero sí, nos falta verificar si existe o no 00:13:41
¿Vale? 00:13:44
Entonces 00:13:47
Ahora esto sí que me deja hacerlo así 00:13:47
Y ahora aquí ya podría ponerle 00:13:50
Esto 00:13:53
¿Vale? Esto sería 00:13:54
Sin lanzar ninguna excepción 00:13:59
Sin verificar nada 00:14:02
Este sería el método que no verifica nada 00:14:03
Recorre la raíz de alumnos 00:14:05
Cuando encuentra el alumno 00:14:07
cuyo NIA es el que estoy buscando 00:14:08
le pone como empresa 00:14:11
y sede la que me acaban de dar 00:14:13
¿vale? este sería el método 00:14:15
sin hacer ninguna verificación 00:14:17
sin lanzar excepciones ni nada 00:14:19
sin hacer ninguna 00:14:20
¿vale? pero a ver, no, vamos a hacer esas verificaciones 00:14:21
es decir 00:14:25
antes de fijar yo 00:14:26
esto vamos a ver si realmente 00:14:28
existe la empresa 00:14:30
entonces vamos a hacernos aquí 00:14:32
las empresas 00:14:34
¿dónde están? las empresas están aquí en un set 00:14:39
vale, pues entonces yo aquí puedo hacer tranquilamente 00:14:41
mi array de empresas 00:14:46
perdón, mi set de empresas 00:14:50
no contiene, por eso le he puesto un 00:14:52
no delante 00:14:54
no contiene 00:14:55
a una empresa con ese código 00:14:57
de empresa 00:15:00
no tengo un constructor solo por código 00:15:01
una pena, voy a tener que ponerlo aquí 00:15:04
igual a 00:15:06
aquí sería mucho más bonito tener un constructor 00:15:10
solo por código 00:15:17
setCódigo 00:15:18
con empresa 00:15:20
y aquí le pongo e 00:15:22
vale 00:15:26
vale, pues si mis empresas 00:15:28
no contienen 00:15:31
una empresa igual a esta 00:15:33
o lo que es lo mismo 00:15:35
con ese código de empresa, porque la igualdad 00:15:37
en empresa iba por código, ¿no? 00:15:39
empresa tenía su 00:15:41
Hasco de equals por código 00:15:43
Hasco de equals por código 00:15:44
Bueno, pues entonces 00:15:47
Si no contiene una empresa con ese, ya está 00:15:48
No hago nada más, lanzo una excepción y se acabó 00:15:51
New 00:15:53
Empresa exception 00:15:54
Empresa sede exception 00:15:56
Ah, la he avisado 00:15:59
Vale 00:16:08
Ah, que no le he puesto 00:16:09
Public a las excepciones, no las he puesto 00:16:21
Public al constructor, claro 00:16:22
Entonces no puedo usar el constructor 00:16:24
Vale, public 00:16:26
ya está, vale 00:16:28
throw, me dice, oye cuidado 00:16:34
que como es step, tienes que avisar 00:16:37
con el 0 y luego lo ponemos, vale 00:16:38
primera situación de error 00:16:40
identificada 00:16:42
si la empresa no existe, empresa 00:16:44
ahora, que más 00:16:46
si la empresa existe 00:16:48
pero la empresa 00:16:50
no tiene una sede 00:16:52
no tiene una sede 00:16:54
con ese código 00:16:57
también tengo que lanzar la excepción 00:16:58
vale, pues venga 00:17:00
vamos a localizar esa empresa 00:17:02
vamos a localizarla 00:17:04
y vamos a ver si tiene 00:17:06
una sede así 00:17:08
como las empresas están en un set 00:17:09
no hay un get, como en los 00:17:11
put, no lo hay, como en los map 00:17:14
perdón, entonces 00:17:16
no me queda más remedio que iterar 00:17:17
para cada empresa 00:17:20
en empresas, todo este rollo 00:17:22
es repetir una y otra vez el manejo de colecciones 00:17:24
que no liemos, etc 00:17:26
para cada empresa es 00:17:27
aquí me dices, uy, cuánta E, Dios mío 00:17:30
me estoy estresando, pues venga 00:17:32
así mejor 00:17:33
para cada empresa 00:17:34
empresa.getCódigo 00:17:39
resulta que 00:17:42
es igual 00:17:44
al código de empresa 00:17:45
ya la tengo localizada, ¿vale? 00:17:48
y además sé que voy a entrar aquí, seguro 00:17:50
sí o sí, sé que voy a entrar, porque si no 00:17:52
habría salido ya por aquí 00:17:54
habría salido ya con el throw, entonces alguna vez 00:17:55
voy a entrar aquí, vale, pues ahora que tengo que ver 00:17:58
Tengo que ver si esta empresa 00:18:00
Tiene en su map 00:18:02
Alguna sede con este código 00:18:04
Esto es mucho más fácil de ver 00:18:06
Porque está en un map 00:18:09
Entonces me puedo hacer un get 00:18:10
Y me puedo hacer 00:18:13
Sim 00:18:15
Emp.get 00:18:16
Sedes 00:18:19
Y tiene un contains key 00:18:22
Contains key 00:18:26
el código de sede 00:18:29
que me han pasado 00:18:32
y le pongo el no delante 00:18:33
si el map de sedes de esta empresa 00:18:38
no contiene 00:18:41
una sede con ese código 00:18:42
pues entonces ahora ya 00:18:44
lanza esta excepción también 00:18:46
porque será para recorrer 00:18:48
para recoger 00:18:50
listo, ya está 00:18:51
ya tengo verificadas las dos primeras 00:18:53
de las tres posibles causas de error 00:18:57
que 00:18:58
no tenga yo una empresa 00:19:01
contenida en mi set de empresas 00:19:06
con ese código 00:19:07
que dentro de mi set 00:19:09
que dentro de esa empresa que sí que existe 00:19:11
ya en este caso 00:19:14
no tenga una sede con ese código 00:19:15
vale, ahora que llego a este punto 00:19:17
la empresa existe 00:19:19
y además tiene una sede 00:19:22
con ese código, vale 00:19:24
ahora, el siguiente caso de error es que yo no haya 00:19:25
encontrado nunca a este alumno 00:19:28
bueno, pues podemos avisar a esto lo más sencillo 00:19:30
que yo lo modifique ahora 00:19:32
de esta manera 00:19:33
inicialmente asumo que no existe alumno 00:19:35
y si alguna vez 00:19:39
entro aquí es porque encontré el alumno 00:19:42
entonces pongo ya existe 00:19:44
alumno 00:19:45
igual a true 00:19:47
vale 00:19:50
entonces cuando mi for ha terminado 00:19:51
mi for ha terminado puede haber ocurrido 00:19:53
dos cosas, que nunca jamás haya encontrado 00:19:56
al alumno, luego este if nunca entró 00:19:57
o que si haya encontrado al alumno 00:19:59
y le haya puesto la empresa, que es de lo que se trataba 00:20:01
Encontré por la empresa 00:20:03
Vale, entonces yo ahora ya aquí puedo hacer 00:20:05
Oye, si no existe 00:20:08
Si no existe alumno 00:20:09
En ese caso 00:20:13
Me haces el throw 00:20:15
Y apaña 00:20:17
Importo alumno exception 00:20:25
Y ya tengo mi método completo 00:20:29
Avisando de todas las opciones, recorriendo todas las colecciones 00:20:33
Haciendo todo 00:20:36
Claro, el compilador me dice 00:20:37
Cuidado, este método puede lanzar excepciones 00:20:39
tienes que avisar aquí con un throws 00:20:42
no pasa nada 00:20:44
avisamos con un throws 00:20:46
ala, avisado 00:20:48
este método puede lanzar estas dos excepciones 00:20:50
recordad que si fueran del tipo 00:20:53
runTimeException 00:20:57
no haría falta 00:20:59
pero como son excepciones y más, sí 00:21:00
y aquí tengo un error yo 00:21:03
¿dónde? 00:21:06
unhandledException 00:21:10
ya, pero es que le he puesto aquí 00:21:11
Ah, es que no me ha hecho el throws de las dos a la vez 00:21:15
Pues venga, añádeme el throws 00:21:17
Throws, ya está 00:21:19
Vale, entonces me puede lanzar 00:21:20
Dos diferentes, esta y esta 00:21:23
Ese método de dos 00:21:26
Bueno, pues ya tenemos unas cuantas 00:21:27
Funcionalidades a hacer con los alumnos, con los profes 00:21:31
Dado ni de profesor 00:21:34
Esto, el mismo rollo de siempre 00:21:35
Buscar, no sé cuántos 00:21:37
Vale, entonces 00:21:39
Cuando uno se pone a hacer la vista 00:21:49
ahora claro, la vista es un rollo porque tendría que ver 00:21:51
madre mía, ¿cómo organizo yo 00:21:54
meter los datos para todo esto? 00:21:56
pues lo ideal sería a lo mejor hacer varias paneles 00:21:58
un panel alumnos, otro panel profesos 00:22:00
otro panel empresas 00:22:02
y a lo mejor en cada panel poner los componentes 00:22:03
para cada cosa 00:22:06
¿vale? 00:22:07
por ejemplo, vamos a 00:22:10
hacer 00:22:12
una vista rápida 00:22:14
con tres paneles y vamos a llamar 00:22:16
alguna de las funcionalidades estas 00:22:18
claro, porque ya 00:22:20
con la excepción ya vas a ver 00:22:25
qué ha pasado, ya no le hace falta 00:22:27
el valor de retorno 00:22:30
entonces venga, vamos a 00:22:30
hacer una vista 00:22:33
el de altarse de empresa 00:22:34
sí, este 00:22:39
vale, entonces 00:22:46
ya, sí, sí 00:23:01
esto, sí 00:23:04
lo que pasa es que he dicho 00:23:13
un iterator, para que no se nos olvide 00:23:15
de qué va el iterator, pero sí, porque no 00:23:17
Vamos a borrar nada de la colección 00:23:19
Entonces, sí, sí 00:23:21
¿Vale? Vale, vamos a hacernos 00:23:22
Una vista ya para poder probar 00:23:25
Algo, para poder probar algo 00:23:27
Pues nos hacemos un paquete vista antes que nada 00:23:29
Y ahora en nuestro paquete 00:23:31
Vista ya nuestro frame 00:23:37
Pues venga, un frame 00:23:39
Un frame 00:23:45
Up FCT 00:23:48
Jolines 00:23:49
Qué velocidad extrema 00:24:25
vale, pues a ver 00:24:27
vale, pues voy a ponerle 00:24:43
para que no quede muy apiñado todo 00:24:57
dios 00:25:00
espera un momento, ves, ahora ya le he quitado 00:25:03
el pause y ya está grabando otra vez 00:25:09
vale 00:25:11
bueno, pues entonces aquí 00:25:12
venga, rápidamente estamos lanzados 00:25:15
antes que nada, el panel este le ponemos 00:25:17
un gestor de ubicación absoluto 00:25:19
ya está en absoluto, le voy a poner un 00:25:23
Tabet pane al panelillo 00:25:25
Aquí 00:25:27
Joder, que tontería he hecho 00:25:28
Esto aquí, ¿no? 00:25:30
Vale, Tabet pane 00:25:34
Joder 00:25:36
Nada, estoy poniendo el Tabet pane 00:25:42
Para llevar las 00:25:46
Los 00:25:48
Los paneles 00:25:49
Entonces, a ver, ahora me llevo 00:25:50
Un panel 00:25:54
No, pero no me lo, es que 00:25:55
A ver 00:25:58
¿Dónde estamos? Aquí 00:26:02
A ver, jolín, ¿cómo lo puse el otro día 00:26:03
Que no se me traspapeló? 00:26:11
Este fuera 00:26:14
Ese ahí no lo quiero 00:26:15
Vale 00:26:17
Entonces vamos a ver 00:26:18
Vale 00:26:21
No, aquí no 00:26:28
No, este fuera 00:26:29
Este 00:26:33
Ahora 00:26:37
Joder, pero 00:26:39
¿Por qué no me lo adapta directamente el tamaño? 00:26:41
Bueno, venga, ya está 00:26:45
Pues lo pongo yo a mano, se acabó 00:26:45
Pues lo que hicimos el otro día 00:26:47
Lo que es el panel con pestañitas 00:26:50
Entonces, a ver 00:26:53
Lo he quedado demasiado grande 00:26:54
Primero un tabezpane 00:26:55
Para que tenga, ala, aquí se queda 00:26:58
Vale, y ahora 00:27:00
Le voy poniendo un panel 00:27:02
Ahí 00:27:04
Venga, pues este, le pongo 00:27:06
El nombrecito 00:27:08
Panel alumnos 00:27:10
Y lo que va a tener 00:27:14
Arriba va a ser 00:27:19
Text 00:27:20
Alumnos 00:27:23
Ahora ya está 00:27:27
Ahora me llevo otro panel 00:27:33
Ahí 00:27:35
No, este no, ahí no lo quiero 00:27:36
A ver, tablet panel, ahí, vale 00:27:39
Y ahora me llevo un panel 00:27:42
Ahí 00:27:44
Se me va la línea roja 00:27:46
Ahí, vale 00:27:49
Lo hice el otro día 00:27:54
No, no, no, no 00:27:55
Son paneles con pestañitas 00:27:58
Para cambiar de uno a otro 00:28:00
Primero pones un tablet panel 00:28:01
Y luego a ese tablet panel le vas añadiendo 00:28:03
Todos los paneles que quieras 00:28:06
Y a cada uno se le pone una pestañita 00:28:08
Entonces 00:28:10
Esto 00:28:11
no lo sé 00:28:13
no lo sé, si está subida o no 00:28:18
no me acuerdo 00:28:22
pero no 00:28:23
no fue del martes, fue de antes 00:28:26
entonces 00:28:28
a ver, este panel 00:28:30
le ponemos 00:28:31
a ver 00:28:33
design 00:28:34
panel, venga 00:28:36
este, propiedades 00:28:40
panel profesores 00:28:44
y el texto va a ser 00:28:50
ah no, era profesores aquí, vale 00:28:57
y ahora este 00:29:00
el panel 1 00:29:10
empresas 00:29:20
las pestañas son paneles 00:29:25
a ver, lo único que tienes que hacer es 00:29:35
te coges un tablet pane 00:29:37
y lo colocas 00:29:39
todo lo grande que puedas 00:29:41
y ahora arrastras paneles 00:29:42
normalitos dentro de ese tablet pane 00:29:45
y entonces se te meten dentro del tablet pane 00:29:47
y aparece solo la pestañita 00:29:50
¿Vale? Aparece solo la pestaña 00:29:51
Y luego tú ya cada panel lo seleccionas 00:29:54
Y cambias el nombre de la pestaña 00:29:56
En propiedades, lo que quieras 00:29:58
Y ya la ventaja que tenemos es que ya tenemos 00:29:59
Tres paneles y no tenemos que tener 00:30:02
Todos los componentes apiñados en el mismo 00:30:04
Porque ya tenemos tres distintos 00:30:06
Que cambian 00:30:08
En función de la pestaña que yo seleccione 00:30:09
¿Vale? 00:30:11
Entonces 00:30:18
En el panel de alumnos 00:30:19
si quisiéramos insertar alumno 00:30:23
pues para insertar alumno ¿qué nos hace falta? 00:30:25
para insertar alumno nos hace falta 00:30:28
el NIA y el nombre 00:30:30
porque la empresa se le asigna luego 00:30:31
vale, pues entonces podemos hacer aquí 00:30:33
en el panel de alumno 00:30:36
¿dónde estoy? 00:30:37
aquí en el panel 00:30:43
de alumno me coloco en el panel de alumnos 00:30:44
pero voy a cambiar nombre 00:30:46
a este para aclararme 00:30:47
este es el panel de empresas 00:30:49
y este de aquí 00:30:51
es el panel 00:30:57
de profesores 00:30:57
vale, pues me coloco 00:31:01
en el panel de alumnos 00:31:06
aquí a la izquierda, panel de alumnos 00:31:07
y voy a poner un text fill 00:31:10
para el NIA y otro para el nombre 00:31:11
y así podemos hacer ya una funcionalidad 00:31:14
ejecutarla porque a partir de ahí 00:31:16
es hacer lo mismo una y otra vez 00:31:18
pues venga, componentes 00:31:19
un text fill 00:31:22
ah bueno 00:31:23
tengo que poner el layout 00:31:26
absoluto en cada panel 00:31:27
pues venga, en cada panel 00:31:29
panel de alumnos 00:31:32
le voy a poner el layout 00:31:34
no, aquí, no, este fuera 00:31:36
panel de alumnos 00:31:40
joder 00:31:43
a ver, es que estoy pendiente 00:31:44
de tener 00:31:48
¿sí? 00:31:49
Gracias. 00:31:57
¡Gracias! 00:32:32
Vale, pero 00:33:02
No llego a casa hasta esta noche 00:33:04
Entonces la subiré esta noche 00:33:06
¿Vale? Esta noche la subo 00:33:07
Sí, vale 00:33:10
Pues entonces 00:33:12
Me voy a poner un recordatorio 00:33:13
Para acordarme esta noche 00:33:17
Antes de acostarme 00:33:19
Subirla 00:33:19
Vale, a ver, entonces 00:33:20
Pues mira 00:33:23
Llego a casa sobre las once y media 00:33:30
Si a las once 00:33:32
Si me envías un correo a esa hora 00:33:33
Si no me he acordado 00:33:35
Me acordaré 00:33:38
Vale, a ver, en alumnos entonces 00:33:38
Estábamos poniéndole el layout 00:33:40
Absolute 00:33:43
Layout absoluto 00:33:44
Vale, y ahora 00:33:46
Nos llevamos a un textfield 00:33:48
Para poner el nombre 00:33:50
Joder 00:33:51
Y otro textfield para poner 00:33:53
Es que por rapidez no voy a poner ni la etiqueta 00:33:55
Nombre, Nia, Nia, nombre 00:33:57
Da igual, ya está 00:33:59
Entonces, este text field lo vamos a llamar NIA para que en el código no nos hagamos lío. 00:34:02
Y a este text field le vamos a llamar nombre para que luego en el código no nos hagamos lío. 00:34:07
Ya tengo los dos text fields. 00:34:14
Y ahora vamos a poner un botoncito de insertar. 00:34:15
Pues venga, un botón, insertar. 00:34:18
Le vamos a poner el nombre de la variable, que se llame la variable insertar alumno. 00:34:25
BT, insertar alumno 00:34:30
para saber que es el botón 00:34:32
insertar alumno 00:34:34
y el texto que va aquí 00:34:35
encima que sea 00:34:38
pues insertar 00:34:40
vale, pues entonces la vista 00:34:41
la vista para 00:34:46
insertar alumno, esta ya está 00:34:50
ahora ya tenemos que hacer 00:34:52
la funcionalidad 00:34:54
y esto sería para todas las funcionalidades 00:34:55
para todas las funcionalidades que están aquí recogidas 00:34:57
asignar alumno a profesor 00:35:00
mostrar nombre de profesor que tenga alumnos 00:35:02
todas estas funcionalidades 00:35:04
que están aquí, pues habrá 00:35:05
que ver qué componentes 00:35:08
necesito yo aquí, qué componentes 00:35:10
ya está, en el caso de insertar un alumno 00:35:12
pues estos ya está, con estos 00:35:14
vale, pues venga, vamos a darle 00:35:16
ahora ya funcionalidad a esto 00:35:18
qué componente va a recibir la funcionalidad, vamos a 00:35:20
dársela al botón, pues venga 00:35:22
vamos a hacerle, oye, añádeme 00:35:24
o me hago yo la clase interna 00:35:26
o como ya sé que es el evento por defecto 00:35:28
me vengo aquí 00:35:30
bueno, pues aquí que tendremos que hacer 00:35:31
coger de los text fill 00:35:34
los dos datos 00:35:36
pues venga, el nia lo vamos a coger del text fill 00:35:37
que como le he cambiado el nombre 00:35:44
afortunadamente, pues no me voy a liar 00:35:45
se llama nia 00:35:48
nia.vectest 00:35:49
ala, este es el nombre del alumno 00:35:53
el niv del alumno 00:35:56
donde va a estar 00:35:58
pues el text fill 00:35:59
nombre, lo he llamado 00:36:03
nombre, juraría 00:36:05
Pues ala 00:36:07
Perdón 00:36:11
Porque lo estoy dando tan rápido que no estoy ni pensando 00:36:15
Nombre 00:36:18
Nombre, vale 00:36:20
Nombre, ¿qué pasa? 00:36:23
¿Que no se llama nombre el text field? 00:36:24
Sí, entonces, es que lo estoy llamando igual 00:36:26
Nombre 00:36:28
Alumno, ala 00:36:30
Ahí, vale 00:36:32
Y ahora, ¿qué quiero hacer con esto? 00:36:34
Meterlo en 00:36:36
Habrá alguna funcionalidad en repositorio 00:36:37
que esta es la que trabaja con los datos 00:36:40
vale, y aquí viene la separación 00:36:42
esta es la vista, la vista me recoge 00:36:44
y ahora yo ya, cuando ya tengo que operar 00:36:46
trabajar con los datos, llamo a esta clase 00:36:48
que esta clase ya es la que se ocupa 00:36:50
de trabajar con los datos, se ocupa esta 00:36:51
vale, y esta clase efectivamente 00:36:53
tendrá, ¿no he puesto public en los métodos? 00:36:56
pues no he puesto public 00:36:58
entonces si no he puesto public 00:36:59
si, si están public 00:37:01
ya, pero 00:37:03
repositorio 00:37:08
bueno, porque 00:37:10
vale, vale, vale, porque 00:37:11
repositorio, sí 00:37:13
bueno, ¿cómo se llama? voy a ponerlo y que luego 00:37:14
me haga el import automáticamente 00:37:17
vale, entonces esto será 00:37:19
¿dónde estamos? en app, aquí 00:37:22
pues esto 00:37:23
repositorio 00:37:25
punto 00:37:28
alta 00:37:30
alumno, y aquí 00:37:30
¿qué le pasábamos? el nif y el nombre precisamente 00:37:33
el nia y el nombre 00:37:35
nombre, alumno 00:37:36
esto recibía el altalumno 00:37:40
y repositorio 00:37:43
habrá que importarlo de datos 00:37:45
y esto 00:37:46
altalumno 00:37:50
ah, perdón, claro, es que no les he 00:37:56
dado static 00:37:58
se me han olvidado todos los static en todos los métodos 00:37:59
¿vale? 00:38:02
public static, se me han olvidado todos los static 00:38:04
con lo cual 00:38:06
tendría que hacer un new repository 00:38:08
¿y para qué voy a hacer un new repository? 00:38:09
Pongo esto como static y ya está 00:38:11
Porque solo trabajan con estas de arriba 00:38:13
Que son static 00:38:14
Vale, se me han olvidado los static 00:38:15
En todas ellas 00:38:19
¡Hala! Pues esta funcionalidad ya está 00:38:20
Se comunica y alta 00:38:32
Entonces si ejecutamos esto 00:38:34
Lo único que vamos a ver es si nos da error o no nos da 00:38:39
Vale, bueno, a ver aquí 00:38:42
Este método 00:38:44
¿Qué pasa? 00:38:46
Te daba un false si el alumno 00:38:48
Ya estaba y no lo había podido haber dado de alta 00:38:50
Entonces aquí 00:38:53
habría que hacer esto 00:38:54
si esto me dio true 00:38:56
si esto me dio true 00:38:59
pues entonces yo me hago 00:39:01
mi j option pane 00:39:03
mi j option pane 00:39:04
que me diga 00:39:08
alumno dado de alta 00:39:09
porque para eso 00:39:12
he hecho el retunfalse y true 00:39:15
para que desde la vista podemos distinguir 00:39:16
si algo fue bien o mal 00:39:18
entonces 00:39:19
alumno insertado 00:39:23
Pero si esto me dio false 00:39:29
Es porque no se dio de alta 00:39:33
Porque ya existía, ¿no? 00:39:35
Así funcionaba el método repositorio alta alumno 00:39:36
El método repositorio alta alumno 00:39:38
Este de aquí 00:39:41
Alta profesor, alta alumno 00:39:43
Ah, bueno, que justo este es el que está sin hacer 00:39:47
Cachilaman, pues venga, vamos a ponerle 00:39:49
Esto 00:39:51
Control V, retoma alumnos 00:39:51
Add new alumno 00:39:57
Ni a nombre 00:40:02
New alumno, ni a nombre 00:40:09
y alumno no tenía constructor sin la empresa. 00:40:16
No tenía constructor. 00:40:19
¿Vale? 00:40:22
Entonces, vamos a hacerle un constructor sin la empresa. 00:40:23
Vamos a hacerle un constructor sin la empresa y listo. 00:40:29
Bueno, tú insertas el alumno en la aplicación 00:40:41
y luego le puedes asignar una empresa después. 00:40:43
Claro, de hecho hay una funcionalidad 00:40:46
que es asigna empresa al alumno. 00:40:47
Esto es el profesor cuando se le asignan unos alumnos. 00:40:49
A ti te asignan 20 alumnos 00:40:52
y luego tú ya te dedicas a ubicarlos. 00:40:54
Entonces, ahora ya el método repositorio inserta el alumno con este nombre y este NIA. 00:40:56
Por ahora sin empresa, pero está insertado en su alta de alumnos. 00:41:12
Me devolverá true o false en función de si existe o no existe. 00:41:15
Me devolverá true o false, para eso está ese método, para controlar con el true o false si existía o no. 00:41:19
Y ahora ya este recoge esa información. 00:41:23
que el altalumno te dio true 00:41:26
lo has insertado y avisas 00:41:29
que no, pues entonces 00:41:31
lo dices en tu jOptionPanel 00:41:33
lo dices aquí y dices 00:41:35
ala 00:41:38
hay que estar más rápido 00:41:39
y lo tenéis que hacer de hecho más adelantados 00:41:46
a mí, antes de que yo lo haga 00:41:49
vosotros tenéis que dar cuenta que son más jóvenes y más rápidos 00:41:51
y pum pum pum pum 00:41:53
rapidez 00:41:54
Pues sí, estáis bastante mayores 00:41:56
No se pudo insertar alumno 00:42:01
El alumno ya existe, el mensaje que sea 00:42:05
El alumno ya existe 00:42:07
A ver, ¿qué pasa? ¿Qué quieres mirar? 00:42:08
¿Dónde te has perdido? 00:42:13
Vale, pues esto ya está 00:42:15
Cojo el alumno 00:42:17
Lo doy de alta con el método correspondiente 00:42:18
Y además recojo el valor de control 00:42:22
Recojo el valor de control para avisar 00:42:26
¿Vale? 00:42:28
Pero aquí hay dos partes muy claras 00:42:29
Hay dos partes, la vista 00:42:31
Y la lógica, y la lógica está aquí 00:42:33
Y yo llamo a este método 00:42:36
Y este 00:42:38
Y yo llamo a los métodos de repositorio 00:42:39
Y esto no lo he hecho yo, esto es el back, esto está por ahí 00:42:41
¿Vale? 00:42:44
Me los ofrecen y yo los llamo desde aquí 00:42:45
Y cojo el valor de retorno para avisar 00:42:47
A ver, vamos a probar esta 00:42:49
Burrada, a ver si nos sale algo 00:42:52
Venga 00:42:53
vamos a meter a un primer alumno 00:42:56
si hemos hecho las cosas bien 00:43:00
nos dirá que el alumno está insertado 00:43:02
alumno 00:43:04
venga, vamos a meter al alumno 00:43:06
Pepito 00:43:08
ah no, el Nia iba a lo primero, pero bueno 00:43:10
me da igual, Nia, papapá, un, dos, tres, cuatro 00:43:12
y el alumno Pepito 00:43:14
yo le doy a insertar 00:43:16
y el alumno se ha insertado, muy bien 00:43:18
ahora, si yo vuelvo 00:43:20
trato de insertarlo de nuevo 00:43:22
porque me he equivocado 00:43:24
y he puesto el NIA dos veces 00:43:25
me va a tener que decir 00:43:28
el alumno ya existe 00:43:29
y no me lo dice 00:43:32
¿eso qué significa? que el repositorio 00:43:33
este no me ha devuelto el falso 00:43:36
o sea, aquí algo ha fallado 00:43:37
¿verdad? me debería haber dicho 00:43:40
el alumno ya existe 00:43:42
entonces me ha devuelto true 00:43:43
el método repositorio me debería haber devuelto 00:43:46
falso, si no lo ha podido insertar 00:43:48
o bien es que en el set no está bien el jasco de equals 00:43:49
algo nos ha fallado, que no sé lo que es 00:43:52
no sé lo que es, no sé, yo me esperaba que lo hiciera bien 00:43:54
a ver, vamos a ver 00:43:56
que ha fallado, vamos a ver que ha fallado 00:44:03
vale, vale, vamos a ver que ha fallado 00:44:05
primero, alumno 00:44:11
Nia, ¿qué es? Nia es un string 00:44:12
vale, entonces 00:44:15
el jasco de equals 00:44:17
a ver, entonces en alumnos 00:44:20
en repositorio, ¿los alumnos están 00:44:29
¿Dónde? ¿Está en un tríset? 00:44:31
¡Ah! 00:44:35
Claro. 00:44:36
¿Qué ha fallado? 00:44:38
¿Eh? 00:44:43
A ver, vamos a 00:44:47
recopilar. ¿Qué ha fallado aquí? Vamos a ver. 00:44:48
Repositorio. 00:44:52
Tiene los alumnos en un tríset. 00:44:52
¿Eso qué 00:44:55
significa? Que 00:44:56
el tríset utiliza el 00:44:58
comparable para la igualdad. 00:45:00
El compare tú. El compare tú. 00:45:02
No utiliza equals ni nada, usa el compare to. 00:45:03
Vámonos al compare to de alumno. 00:45:06
El compare to de alumno, que lo tiene que tener, 00:45:08
porque se lo hemos tenido que hacer, 00:45:12
el compare to de alumno trabaja por nombre. 00:45:13
Luego, para este triset, 00:45:17
la igualdad de alumnos viene por nombre. 00:45:19
¿Vale? Viene por nombre. 00:45:23
Que queremos que la igualdad venga por nía, 00:45:24
que es lo que tiene sentido. 00:45:26
Este compare to lo tenemos que hacer por nía. 00:45:28
¿Vale? 00:45:32
¿Eso qué implicación tiene? 00:45:33
Simplemente que cuando nos da por iterar, 00:45:35
para sacar un listado, 00:45:38
la iteración lo va a sacar por orden alfabético de NIA. 00:45:39
¿Que queremos un orden alfabético de nombre? 00:45:43
Hacemos un comparator aparte para el sort. 00:45:45
Pero desde luego, para que la aplicación funcione 00:45:48
y detecte alumnos iguales ahora a insertar, 00:45:50
ya que está en un triset, 00:45:54
como está en un triset, 00:45:56
la igualdad la tiene que fijar el compareTo. 00:45:57
Es que no hay otra. 00:46:00
Para el triset, la igualdad es el compareTo. 00:46:01
entonces si nuestro compare tú es por nombre 00:46:03
la igualdad es por nombre 00:46:05
de hecho si volvemos a ejecutar la aplicación 00:46:06
y le vamos a dar ahora 00:46:09
un pepito 00:46:11
con otro nía diferente 00:46:13
un pepito, insertar 00:46:16
¿por qué no me sale el joto de acción pane? 00:46:20
espera, voy a volver a ejecutarlo 00:46:26
momentico, nos estamos estresando mucho todos 00:46:28
a ver 00:46:30
es que 00:46:32
se nos ha pasado 00:46:34
nos cunde poco, yo entiendo que es normal que nos cunda poco 00:46:36
entonces, yo hablar y pensar 00:46:38
no se me da muy bien 00:46:40
venga, a ver 00:46:43
venga, metemos a Pepito 00:46:44
alumno insertado 00:46:46
muy bien, que sí, que sí, que insertado 00:46:47
vamos a meter a otro Pepito 2 00:46:50
con este Nia, alumno insertado 00:46:52
vamos a meter a otro 00:46:54
Pepito 2 00:46:57
el alumno ya existe 00:46:57
porque para él la igualdad es por nombre 00:47:00
no es por NIA 00:47:03
es por nombre 00:47:05
entonces si yo no quiero que la igualdad sea por nombre 00:47:06
simplemente el compare tú de alumno 00:47:09
se lo cambio a 00:47:11
NIA 00:47:13
y punto pelota 00:47:15
ala, ahí está 00:47:16
y ya uno se puede adelantar al profesor 00:47:27
porque el profesor el compare tú así muy alegremente 00:47:30
por el famoso orden alfabético 00:47:32
lo habíamos puesto con nombre 00:47:35
pero cuidado 00:47:37
lo que identifica un profesor es el nif 00:47:39
y como mis profesores van a estar 00:47:42
en un triset 00:47:45
el compare to tiene que ser por nif 00:47:46
entonces ya nos podemos adelantar 00:47:48
para el resto de funcionalidades que podáis ir haciéndonos 00:47:50
podemos adelantar y esto tiene que ser 00:47:52
nif 00:47:55
y nif 00:47:57
entonces ahora ya 00:47:58
con esta modificación 00:48:00
si volvemos a ejecutar la aplicación 00:48:02
ahora ya si 00:48:04
que me lo, uy, que he hecho 00:48:06
ahora ya si 00:48:08
venga, inserta alumno con 00:48:16
ni a 1, 2, 3, 4 00:48:18
Pepito 00:48:19
insert, alumno insertado 00:48:22
vamos a 00:48:24
insertar a 1, 2, 3, 4 que me he equivocado 00:48:26
y a Pepito 2 le he puesto a mi monía 00:48:28
que aún no ya existe 00:48:30
vale, pues a partir de aquí 00:48:31
es el 00:48:37
tirar de la rueda 00:48:39
una y otra vez, por ejemplo 00:48:41
que funcionalidad hacemos, cual de estas 00:48:43
más complicada que nos pueda 00:48:45
interesar hacer y ponerle luego una vista 00:48:47
para ejecutarla 00:48:49
tenemos hechas las 5 primeras 00:48:50
¿vale? que uno podría probarlas 00:48:53
pues poniendo los componentes, el rollo es que hay que poner 00:48:56
los componentes para probarlas, un peñazo 00:48:57
por ejemplo 00:48:59
¿cuál os gusta? 00:49:01
venga, decid una al azar 00:49:03
entre 6 y 12 00:49:04
entre 6 y 12 00:49:07
mirad 00:49:10
un texto que os guste. 00:49:12
¿Cuál os parece más rollo y más fea? 00:49:19
¿Cambiar todos los alumnos 00:49:25
de la primera sede a la segunda sede? 00:49:26
Yo qué sé. 00:49:28
La 10, esa. A ver qué será esto. 00:49:30
Venga, la 10. 00:49:33
Código de empresa 00:49:35
y dos códigos de sede. 00:49:35
La idea es que los alumnos que estén en esa sede 00:49:37
pues ha habido un terremoto. 00:49:40
Y esa sede 00:49:43
ha fallecido 00:49:43
y hay que cambiar a todos los alumnos a la otra sede 00:49:45
vale, pues entonces se le da 00:49:48
al código de empresa la sede 00:49:50
que se derrumbó y la otra sede 00:49:51
pues venga 00:49:54
repositorio, vámonos ahí 00:49:55
funcionalidades 00:49:57
public static 00:49:59
esta genera 00:50:05
excepciones, te da un false si lo pudo 00:50:06
hacer o no, esta que te dice 00:50:08
esta dice que si 00:50:10
no existe la empresa o la sede 00:50:12
dentro de la empresa 00:50:15
empresa sede exception 00:50:16
pues entonces vamos a decir que devuelva void 00:50:20
y ya va a avisar con excepciones y ya está 00:50:23
cambiar 00:50:25
alumnos de sede 00:50:29
entonces todos 00:50:31
los que estén en esta empresa 00:50:33
se van a ir 00:50:35
de la 00:50:39
sede antigua 00:50:40
a la sede nueva 00:50:43
a la todos los que estén 00:50:50
bueno, pues nada 00:50:56
vale 00:51:00
entonces, aquí 00:51:06
vamos a ver 00:51:08
habría que ir, nuestros alumnos 00:51:10
¿dónde están? punto de partida para tirar 00:51:13
nuestros alumnos están aquí 00:51:15
entonces habrá que iterar 00:51:17
alumno por alumno 00:51:19
para cada alumno 00:51:20
coger la empresa en la que está 00:51:23
si la empresa 00:51:25
por ahora vamos a no meter excepciones 00:51:26
ni nada, vamos a hacer el código 00:51:29
alumno por alumno 00:51:31
si la empresa del alumno es esta 00:51:32
pues entonces 00:51:35
su sede 00:51:37
que sea esta 00:51:39
y estaba en esta sede, que se vaya a esta 00:51:40
y si no estaba en esta sede, la dejemos 00:51:45
porque esa no se derrumbó 00:51:47
pues venga, vamos a ver 00:51:48
recorremos los alumnos 00:51:50
vale 00:51:52
voy a hacer un iterator 00:51:54
para que os acostumbréis a iterator 00:51:57
porque hay veces que no hay más remedio que usarlo 00:52:00
si yo no voy a consultar 00:52:01
sino que voy a eliminar de un iterador 00:52:04
o tengo multi-heal o lo que sea 00:52:05
pues venga, vamos a iterar por los alumnos 00:52:07
iteramos por los alumnos 00:52:09
y ahora 00:52:17
nos quedamos con cada alumno 00:52:18
alumno a igual a i.next 00:52:28
vale, pues a ver 00:52:31
si este alumno estaba 00:52:34
en esta empresa y en esta sede 00:52:37
le muevo a la sede nueva 00:52:39
bueno, pues entonces 00:52:41
primero habrá que ver 00:52:43
si el alumno tenía sede asignada 00:52:46
a empresa asignada porque si no 00:52:47
me arriesgo 00:52:49
a un pedazo de null pointer exception 00:52:51
es decir, yo podría 00:52:53
hacer esto a lo bestia 00:52:55
si a.get 00:52:56
empresa 00:53:00
de 0 00:53:01
resulta 00:53:04
que es igual a code 00:53:05
empresa 00:53:07
a.get 00:53:09
empresa de 1 00:53:13
lo voy a bajar abajo para que se vea mejor 00:53:15
de 1 00:53:19
es igual 00:53:21
a COD sede 00:53:23
no a COD sede, no a sede all 00:53:26
porque la empresa y la sede de un alumno 00:53:28
están en las posiciones 0 y 1 de este array 00:53:33
es verdad 00:53:35
vale, pues 00:53:37
si el alumno estaba en esta empresa 00:53:39
y dentro de esta empresa estaba en esa 00:53:41
sede que se acaba de derrumbar 00:53:43
pues entonces a esta 00:53:45
a este alumno 00:53:47
le voy a poner 00:53:48
como nueva sede 00:53:50
esta 00:53:52
y se acabó el método 00:53:54
se acabó el método sin hacer ninguna 00:53:59
verificación de error 00:54:02
esta aplicación está bien 00:54:03
si nunca jamás nadie 00:54:06
se va a equivocar 00:54:08
haciendo consultas 00:54:09
si todo el mundo que meta un código de sede 00:54:11
o código de empresa, mete un código 00:54:14
de sede y de empresa que existen 00:54:16
pero no hay que contar con eso 00:54:17
lo que hay que contar es cuando introduce tu NIF 00:54:19
tú pones tu NIF y te ponen 00:54:22
lo pones todo mal 00:54:24
entonces hombre, hay que contar con que 00:54:25
la aplicación en lugar de boom 00:54:28
explotar el ordenador y salir mil letras rojas 00:54:30
tú esperas que la aplicación te diga 00:54:32
has tecleado mal tu NIF 00:54:33
por favor teclealo de nuevo 00:54:35
pues aquí igual, si nosotros dejamos esto 00:54:37
como está y el usuario 00:54:40
luego mete el código de empresa 00:54:42
mal o el código de sede antigua mal 00:54:44
o el alumno no tiene empresa 00:54:46
pues entonces aquí te va a salir 00:54:49
unas letras rojas tremendas 00:54:52
entonces aquí hay que empezar a meter 00:54:53
verificaciones 00:54:55
la primera verificación 00:54:57
estamos recorriendo todos los alumnos 00:54:58
para ver si su empresa es esa 00:55:01
pero puede ser que alguno de estos alumnos 00:55:03
ni siquiera tenga empresa asignada 00:55:05
si no lo tiene 00:55:07
¿qué le va a ocurrir a este alumno? 00:55:09
que este array va a ser 00:55:11
un pedazo de null pointer 00:55:13
de null como un castillo 00:55:14
entonces si eso es un pedazo de null 00:55:16
como un castillo, esto va a ser 00:55:18
un pedazo de null pointer 00:55:20
gigante 00:55:22
perdón, un null pointer no 00:55:23
va a ser un 00:55:26
array index bound exception 00:55:28
¿verdad? agate empresa va a ser null 00:55:30
yo trato de acceder 00:55:33
a la posición 0 de null 00:55:34
pues malamente 00:55:36
entonces 00:55:37
¿qué es lo primero que tendremos que hacer? 00:55:40
pues verificar 00:55:43
si A es diferente 00:55:44
los métodos de la misma instrucción 00:55:46
si A.getEmpresa 00:55:47
es distinto de null 00:55:50
es decir, el alumno ya sí que tiene 00:55:53
empresa asignada 00:55:55
si tiene empresa 00:55:55
porque si no la tiene 00:56:00
el resto de comprobaciones no las quiero 00:56:02
y teniendo empresa 00:56:03
su empresa es cero 00:56:06
y su código de sede es este 00:56:08
entonces esto es fundamental 00:56:10
incorporarlo 00:56:12
y por supuesto 00:56:13
con un doble AND 00:56:15
si uno pone un único AND 00:56:17
porque le da pereza 00:56:19
no hace nada, no arregla nada 00:56:20
porque ya sabemos la diferencia 00:56:22
entre doble AND y simple AND 00:56:25
el simple AND 00:56:26
aunque ésta te dé false y por tanto 00:56:28
ya puedas concluir que el total es false 00:56:30
porque false AND lo que sea es false 00:56:32
si hay un simple AND te va a evaluar 00:56:35
lo demás igual 00:56:37
entonces éste te va a seguir dando el ArrayIndexBoundException 00:56:37
Null pointer exception, pero sin embargo 00:56:41
Si ponemos el doble AND 00:56:43
Como esto ya es falso 00:56:44
La máquina virtual dice 00:56:46
¿Para qué quiero yo mirar lo demás? 00:56:48
Si eso ya es falso 00:56:50
El total del AND va a ser falso 00:56:51
Bueno, pues la primera verificación para evitar 00:56:54
El primer null pointer exception por el array 00:56:56
Ya está, aquí no hay problema 00:56:58
Solo va a comprobar los alumnos 00:57:00
Que no sean null 00:57:03
Perdón, los cuya empresa 00:57:04
No sea null 00:57:07
vale, y ahora ya 00:57:07
siguiente verificación, que me dicen 00:57:10
oye, cuidado, si la empresa 00:57:12
que te han dicho que cambies de sede, no existe 00:57:14
esa empresa, o no existe 00:57:16
para esa empresa 00:57:19
no existen las sedes que estás dando 00:57:20
lanza una excepción 00:57:22
pues esa es la siguiente comprobación 00:57:24
que habría que hacer 00:57:26
la misma que hemos hecho cuando hemos dado de alta 00:57:27
una sede en una empresa, pues lo mismo 00:57:30
tendríamos que 00:57:32
vale, y esto 00:57:34
bueno 00:57:38
queréis que lo incorporemos 00:57:40
es la misma comprobación de 00:57:43
bueno 00:57:44
digo no 00:57:46
vale, que falta lanzar la excepción 00:57:47
si la empresa no existe o si 00:57:51
no existiendo la empresa, la sede no existe 00:57:53
pero eso es hacer lo mismo que hicimos 00:57:55
en otro método, entonces 00:57:57
para ver si la empresa no existe, la empresa 00:57:59
está pues aquí en este set 00:58:01
pues entonces ya 00:58:03
pues 00:58:04
Esto es que ya 00:58:07
Si no contiene 00:58:08
Si empresas 00:58:10
No contiene 00:58:12
Una nueva 00:58:14
Una empresa 00:58:16
Con ese código de empresa 00:58:18
Si no la contiene 00:58:20
Entonces 00:58:24
Throw 00:58:26
New 00:58:27
La excepción que se llamaba 00:58:30
Empresa setException 00:58:31
Perfecto 00:58:32
Si este set de empresas 00:58:42
No contiene una empresa 00:58:43
Con este código 00:58:45
¿Vale? Pues lanza 00:58:46
Lo que pasa es que empresa, como no tiene constructor 00:58:49
Solo con el código, no pasa nada 00:58:52
Vamos a hacérselo, rápidamente 00:58:53
Chain constructor 00:58:55
Create constructor 00:58:58
Si es que ya me lo ofrece aquí abajo 00:58:59
Crea un constructor, venga, créalo tú solo 00:59:00
Ah, la ha creado, ya está 00:59:03
CodeEmp 00:59:04
Igual a 00:59:10
CodeEmp 00:59:12
Ah, es que se llama código 00:59:14
he hecho en empresa un constructor 00:59:18
solo por código 00:59:22
y ahora 00:59:23
que mi set de empresas no contiene 00:59:28
una empresa con ese código 00:59:30
lanza la excepción, no sigas 00:59:32
porque no tiene sentido que cambie de empresa 00:59:34
a los alumnos de sedes si no existe 00:59:36
siguiente comprobación 00:59:38
la empresa existe, vamos a recorrerla 00:59:40
si no existen sedes 00:59:42
con estos valores 00:59:44
pues también 00:59:46
y es que eso mismo podemos copiar y pegar 00:59:47
de uno de los métodos de arriba, que ya lo teníamos 00:59:50
era esto, es que ya lo teníamos aquí 00:59:52
lo podemos copiar y pegar 00:59:54
cogemos la empresa 00:59:57
si no contiene sede old 01:00:04
o no contiene la otra 01:00:06
o si no contiene esta 01:00:10
o no contiene la otra 01:00:14
porque tiene que contener las dos 01:00:16
ala, pues este método ya está con todas las verificaciones 01:00:17
nos falta 01:00:31
ponerle el throws al método 01:00:33
y ya estaría, ¿qué hace el método? 01:00:35
primero, verifica que existe 01:00:39
una empresa con el código que yo le he pasado 01:00:41
porque si no existe, lanza excepción y para 01:00:43
siguiente, busca esa 01:00:45
empresa y verifica 01:00:47
que existan sedes en 01:00:49
esa empresa con código viejo y nuevo 01:00:51
porque 01:00:53
como con el normal 01:00:54
porque me han pasado estos dos, me han dicho 01:01:00
verifica, o sea, de esta empresa 01:01:02
se le ha derruido la sede vieja y vamos 01:01:04
a una sede nueva, dices 01:01:06
verifica que esa empresa tenía esas dos sedes 01:01:08
no las dos porque 01:01:10
tenía una vieja que se ha derruido y los vas a 01:01:14
pasar a una nueva 01:01:16
entonces esa empresa se tenía 01:01:17
las dos 01:01:20
entonces si no tenía 01:01:20
alguna de las dos lanza 01:01:24
y ahora ya 01:01:26
si tenía las dos ya te vas a los alumnos 01:01:27
el que estuviera en la vieja lo pasas 01:01:30
a la nueva 01:01:32
el que estuviera en la vieja lo pasas a la nueva 01:01:33
entonces si la empresa no tenía 01:01:35
la sede vieja o no tenía 01:01:38
la nueva que tenía que tener las dos 01:01:40
pues no tiene sentido moverlos de una a otra 01:01:42
tenía que tener las dos 01:01:43
ahora ya si hemos llegado a este punto 01:01:45
es porque existe la empresa 01:01:48
y la empresa tenía sus dos sedes 01:01:50
tenía las dos, ahora ya recorremos 01:01:52
a los alumnos y para 01:01:54
todo alumno que tuviera empresa asignada 01:01:56
si esa empresa era la que me han dado 01:01:58
y su sede vieja 01:02:00
era la que me han dado 01:02:02
que la tenía esa empresa 01:02:04
pues ahora le pones la sede nueva 01:02:05
que también la tiene, luego lo he verificado 01:02:07
¿vale? o sea no tiene sentido 01:02:09
pasar a esta parte ya final, no tiene sentido 01:02:12
si no existía la empresa 01:02:14
con sus dos sedes 01:02:15
que es lo que hemos verificado aquí 01:02:17
y ahora se trata de 01:02:19
llamar a estos métodos desde la vista 01:02:22
simplemente 01:02:23
pues aquí 01:02:25
asignar empresa a alumno 01:02:26
pues habrá que poner código de empresa 01:02:29
código de alumno, código no sé qué 01:02:32
asignar y llamar al método 01:02:33
¿Vale? Entonces lo que pasa es que es un rollo 01:02:35
Porque hay que poner los componentes 01:02:37
Y ya está 01:02:39
A ver 01:02:40
¿Hacemos alguna otra funcionalidad? 01:02:46
¿O metemos alguna otra en la vista? 01:02:53
Para probarla 01:02:55
Por ejemplo 01:02:56
¿Qué funcionalidades tenemos? 01:02:59
¿Tenemos hecha la de asignar alumno a empresa? 01:03:01
Para ponerla en la vista 01:03:03
Vamos a ver 01:03:04
Tenemos asignar a empresa alumno 01:03:06
Vale, vamos a asignar a empresa alumno ahora ya desde la interfaz 01:03:08
vale, asignar a empresa alumno 01:03:10
vamos a suponer que eso, el usuario 01:03:13
el que me ha pedido la aplicación 01:03:15
lo quiere 01:03:17
hacer 01:03:19
claro, tenemos que consensuar con él 01:03:20
el prototipo, y me dice, oye lo quiero hacer 01:03:23
desde el panel de empresas 01:03:25
en el panel de empresas yo te voy a dar 01:03:26
el código de empresa 01:03:28
el código de 01:03:30
sede, el código de alumno y tú lo asignas 01:03:32
pues tendremos que meter textfield 01:03:35
3 textfield 01:03:37
entonces primero al panel de empresas 01:03:39
el panel de empresas le vamos a poner 01:03:40
un layout absoluto 01:03:43
antes de nada 01:03:45
y ahora al panel de empresas 01:03:47
vamos a ponerlos 01:03:49
como no voy a poner etiquetas para no liarnos 01:03:51
en el orden en que están en el método 01:03:52
en el método asignar 01:03:55
empresa alumno está primero código 01:03:57
de empresa, código de sede y luego el 01:03:59
NIA del alumno 01:04:01
pues venga, vamos a poner 01:04:02
un textfield para 01:04:07
el código de empresa 01:04:09
Vale 01:04:11
Lo voy a llamar 01:04:12
Aquí habría que usar nombres más largos 01:04:14
Que se distinguiera mejor en qué panel estás, etc 01:04:18
Vale, ahora otro text field 01:04:20
Para el código de sede 01:04:23
Aquí abajo 01:04:24
¿Ya habéis tenido bastante? 01:04:25
Vale 01:04:30
Código de sede 01:04:30
Y ahora otro text field 01:04:34
Para el NIA del alumno 01:04:38
NIA 01:04:39
Sí, es verdad 01:04:46
Código de sede 01:04:49
Empresa 01:04:50
Alumnos 01:04:52
Vale, y ahora vamos a poner el botón 01:04:55
Para asignar 01:04:59
Adiós 01:05:00
Para asignar 01:05:04
Alumnos a empresa 01:05:06
Pues venga, este botoncito 01:05:07
Asigna 01:05:10
Empresa 01:05:13
A alumnos 01:05:16
Ala 01:05:22
Pues entonces 01:05:23
Con estos tres datos es suficiente 01:05:24
Código de empresa, código de sede y línea del alumno 01:05:27
No hacen falta más datos para asignar 01:05:29
Un alumno a una empresa 01:05:31
Ahora hay que hacer la funcionalidad del botón 01:05:32
Pues venga 01:05:34
Como es el evento por defecto 01:05:36
Pues ala 01:05:39
Y ahora, ¿qué hay que hacer aquí? 01:05:39
Pues cogemos los tres datos y vamos al método correspondiente 01:05:44
Entonces 01:05:47
Los datos serán 01:05:49
El código 01:05:51
De la empresa 01:05:52
El código de la empresa está en ese textfield 01:05:54
Que se llamaba 01:05:57
CodeEmpresa 01:05:58
CodeEmpresa.gectest 01:06:00
Ya tengo el código de empresa 01:06:07
Ahora el código de sede 01:06:11
A la que asigno ese alumno 01:06:12
El código de sede está 01:06:15
En el textfield que he llamado 01:06:17
CodeSede.gectest 01:06:19
Vale 01:06:28
A ver 01:06:34
Type mismatch 01:06:34
Ah bueno, claro, pero lo tengo que convertir a entero 01:06:37
Claro, porque esto tendré que hacerle 01:06:40
Un integer.parseIn 01:06:41
Porque el string me lo da en 01:06:43
Code empresa 01:06:48
Punto get test 01:06:53
Ala 01:06:56
Convertido a entero 01:06:56
Integrer parsing 01:06:59
Code empresa se llama 01:07:00
Vale, lo mismo con el otro 01:07:03
Integrer parsing 01:07:06
Y este me dice 01:07:19
Get test to the primitive 01:07:20
On the primitive type 01:07:23
Es que no se llama code sede, debe ser 01:07:25
A ver como se llama 01:07:27
Sí, el text field se llama coccede 01:07:29
Ah, porque les he llamado igual a las 01:07:32
A las variables estas 01:07:39
Vale 01:07:41
Ala, y ahora cojo el nia del alumno 01:07:42
Que es mi string 01:07:45
Nia 01:07:47
Alumno 01:07:49
Lo cojo de 01:07:50
Mi text field que se llama 01:07:52
Nia alumno 01:07:55
Los nombres están fatal elegidos pero todo es por 01:07:56
Rapidez 01:07:59
Nia alumno creo que se llamaba 01:08:00
Nia, alumno con minúscula 01:08:03
¿Dónde estoy? 01:08:10
Ahí 01:08:14
¡Hala! 01:08:14
Y ahora ya 01:08:23
Tengo algún 01:08:24
Ahora ya llamo a la lógica 01:08:24
Bueno, pues 01:08:26
Yo tengo un método 01:08:27
Estático 01:08:29
En repositorio 01:08:30
Que me permite 01:08:31
Asignar 01:08:33
Un alumno 01:08:35
A una empresa 01:08:35
Este de aquí 01:08:36
Pasándole los datos 01:08:37
Pues venga 01:08:40
Código de empresa 01:08:41
Código de sede 01:08:41
Y Nia de alumno 01:08:42
¿Vale? 01:08:43
Ya está 01:08:45
Pero claro 01:08:45
Este método 01:08:46
me está diciendo, eh, ojo 01:08:48
que como no existe 01:08:49
el alumno con este NIA 01:08:52
porque el que ha metido los datos lo ha metido mal, que puede ocurrir 01:08:53
o porque no existe esta 01:08:56
empresa y esta sede, porque es lo que puede ocurrir 01:08:58
que uno mete los datos mal el usuario 01:09:00
cuidado que como no existe voy a lanzar una excepción 01:09:01
es lo que nos está diciendo 01:09:04
claro, es que 01:09:06
este método está muy bien programado 01:09:08
está programado haciendo todas las verificaciones 01:09:10
para que si el usuario ha metido mal 01:09:12
los datos, se avise 01:09:14
está bien programado porque está avisando 01:09:16
y ahora esta 01:09:18
el que hace la vista te lo dice 01:09:20
uuuh, cuidado, pues voy a hacer los try-catch 01:09:22
correspondientes 01:09:24
venga, ala 01:09:25
yo tengo aquí mis try-catch 01:09:28
y ahora, intento hacerlo 01:09:29
que ha habido 01:09:32
una excepción por empresa 01:09:34
o por alumno, pues aviso 01:09:36
con el hot-option panel, lo que pasa es que el try-multi-catch 01:09:38
es muy feo 01:09:40
porque no te permite aquí 01:09:42
distinguir, tendrías que hacer un e1 o get-source 01:09:44
a mí me gustan más 01:09:46
el try-catch 01:09:47
separado 01:09:51
entonces voy a 01:09:52
un momentito 01:09:53
sí, o sea es que hay 01:09:54
diferentes try-catch 01:09:57
claro, ese 01:09:59
es decir 01:10:01
tú puedes 01:10:03
capturarlas por separado con varios catch 01:10:05
catch una excepción, catch otra, catch otra 01:10:08
y así en cada una distingues, o está el multi-catch 01:10:09
que te dice catch cualquiera de ellas separadas por oro 01:10:12
el que me ha salido antes 01:10:14
este de aquí 01:10:14
el multicatch 01:10:17
entonces en este 01:10:18
sea esta 01:10:20
o sea esta otra 01:10:23
se mete aquí 01:10:25
entonces si tú quieres distinguir por dónde se ha metido 01:10:26
si por esta o por esta 01:10:29
tienes que irte al objeto E1 01:10:31
y hacerle un get source o un get class 01:10:33
a ver cuál es, no merece la pena 01:10:35
es más bonito, a mí me gusta más 01:10:37
hacer un try catch 01:10:39
separado 01:10:43
hacer esto 01:10:44
Exacto, pero vamos, que eso también va en gustos 01:10:46
Y también depende de si tú lo quieres distinguir o no 01:10:51
Con tus mensajitos 01:10:53
Entonces yo aquí querría distinguirlo 01:10:55
Y quería decirle, oye 01:10:57
Que la empresa que me has dado está mal 01:10:58
Entonces yo aquí le diría 01:11:01
Empresa o sede 01:11:05
Aquí es que claro 01:11:12
He hecho una excepción para ambos casos 01:11:14
Porque si no teníais que hacer un montón de cosas 01:11:16
Empresa o sede 01:11:18
Errónea, que revise la empresa y la sede 01:11:20
Porque una de ellas está mal 01:11:22
y ahora, aquí lo mismo 01:11:23
pero aquí le diré, nia de alumno erróneo 01:11:26
nia 01:11:28
erróneo, vale, y esta sería 01:11:47
la forma en la que lo haríamos 01:11:55
aquí, a diferencia del método 01:11:56
anterior, en lugar de saltar el 01:11:59
jActionPanel con el false 01:12:01
salta dentro del catch 01:12:02
entonces yo ahora si pruebo esto 01:12:04
como no tenemos empresas asignadas 01:12:07
el único error que me puede salir, o sea 01:12:08
este me va a salir todo el rato 01:12:10
o sea, porque no tenemos todavía 01:12:12
puesta 01:12:15
tenemos para insertar alumnos 01:12:17
esto sí, yo puedo insertar un alumno 01:12:19
Pepito 01:12:21
y el alumno ya está dentro 01:12:23
vale 01:12:29
pero 01:12:30
si yo pongo aquí, como no tengo 01:12:31
la funcionalidad de meter empresas, me va a tener 01:12:34
que decir que no encuentra la empresa 01:12:36
vale 01:12:38
aunque 01:12:41
asignar empresa 01:12:44
pues me dice empresa sederronia 01:12:46
pero claro, porque es que no he podido meterle 01:12:48
no tengo empresas 01:12:49
no tengo empresas metidas porque no tengo 01:12:50
esa funcionalidad en la vista 01:12:54
para poder meterlas 01:12:55
¿vale? y me está saliendo 01:12:56
esto rojo es el print de extract trace 01:13:01
este rojo 01:13:03
de aquí es esto 01:13:05
en tiempo 01:13:07
de desarrollo yo querré que esté 01:13:09
porque pueden salir errores 01:13:11
que yo no sé por qué y el 01:13:13
joptionpanel es que no me dice nada 01:13:15
quien me dice es este, es el que me está 01:13:16
diciendo, uh, cuidado que está pasando esto 01:13:19
en esta línea, es el que me avisa 01:13:21
en tiempo de desarrollo, pero cuando yo ya entregue 01:13:23
hombre, a ver 01:13:25
tú alguna vez no has entrado 01:13:30
en la sede electrónica de alguna administración 01:13:32
y no te ha salido esto mismo 01:13:34
en rojo pero en negro en la pantalla 01:13:36
seguro que alguna vez te ha salido 01:13:38
depende 01:13:40
si no han 01:13:44
comentado el print 01:13:48
de extract trace y no han cerrado 01:13:50
el recurso de consola del servidor 01:13:52
que tiene desplegada la aplicación 01:13:54
te va a salir eso, y a veces 01:13:55
yo me lo he encontrado 01:13:58
solito una aplicación y de repente me encuentro 01:13:59
en mi pantalla de mi navegador 01:14:02
eso, me encuentro eso 01:14:04
pero en negro 01:14:06
claro, es que esa es la idea 01:14:07
eso es como se hace, o sea, tú aquí habría que hacer 01:14:12
un fichero de log 01:14:14
pero claro, con la librería de log te haces un fichero 01:14:15
lo configuras y aquí en lugar de un print 01:14:18
de extract trace, tú aquí harías 01:14:20
con ese fichero log 01:14:22
y pondrías ya esto mismo 01:14:23
si quieres, lo que tú quieras 01:14:26
pues te harías un fichero de log 01:14:28
que había que hacerlo y luego ya 01:14:30
con el método log le pasas esto 01:14:32
claro, o le pasas 01:14:34
esto directamente 01:14:38
o te pones ahí el mensaje que tú quieras 01:14:39
según lo que tú creas que te vas a enterar mejor 01:14:41
claro, la idea efectivamente es derivarlo 01:14:44
a un fichero de log, a un archivo de log 01:14:46
pero no dejarlo así 01:14:48
directamente 01:14:49
uy tenía esto enchufado pero con esto bajado 01:14:50
vale 01:14:53
pero no dejarlo así 01:14:54
porque hay que tener cuidado porque luego en función de como 01:14:56
esté el servidor configurado 01:14:59
esa consola puede estar saliendo 01:15:00
por el servlet del 01:15:03
o sea esto luego 01:15:05
si está en una aplicación web me refiero 01:15:06
bueno es que 01:15:08
se monta en un servlet y ese servlet puede estar conectado 01:15:09
y como esté el print stress 01:15:12
va a salir y es que yo me lo he encontrado 01:15:14
en definitiva que esto en tiempo 01:15:16
de desarrollo es muy útil, pero 01:15:18
cuando tú entregas la aplicación, nunca lo entregas 01:15:20
con esto, porque es muy peligroso, cuando tú la 01:15:22
entregas, efectivamente, si lo has 01:15:24
hecho bien, lo que tendrás será 01:15:26
llamadas archivos de logs, y un 01:15:28
archivo de logs se quedará 01:15:30
y si hay problemas, te vas al archivo de logs 01:15:31
y lo ves ahí, pero no lo ve el usuario 01:15:34
obviamente, lo ve el técnico 01:15:36
porque se va ese archivo de logs a mirarlo 01:15:38
claro 01:15:40
vale 01:15:41
vale, pues nada 01:15:43
vale, entonces, esto va simplemente 01:15:48
para que lo rojo que nos ha salido en consola 01:15:50
es porque está esto aquí, si eso no estuviera 01:15:52
pues no nos habría salido nada en la consola, lógicamente 01:15:54
si yo ejecuto la aplicación 01:15:56
asigno a empresa alumno 01:16:00
empresa o sede errónea 01:16:02
pero aquí no hay nada en rojo 01:16:05
entonces claro, en tiempo de desarrollo 01:16:08
yo tendría un problema, diría, uy, empresa y sede errónea 01:16:10
¿y por qué? no tengo ninguna ayuda 01:16:12
para saber por qué, entonces en tiempo 01:16:14
de desarrollo, sí 01:16:16
pondríamos esto 01:16:17
para así tener esa ayuda 01:16:19
nada que ver 01:16:20
entre tener esto 01:16:24
y no tenerlo 01:16:25
a la hora de depurar errores 01:16:26
vale 01:16:28
bueno 01:16:30
pues 01:16:32
la idea es esa 01:16:34
pues completar funcionalidades 01:16:37
de esta aplicación 01:16:38
de otras 01:16:39
a ver 01:16:40
no os olvidéis 01:16:41
del tema 01:16:42
de que este modelo 01:16:42
no tiene 01:16:44
herencia 01:16:45
e implementación de clases propias 01:16:47
pero podría haber a lo mejor 01:16:50
una clase alumno y luego dos tipos de alumnos 01:16:51
entonces el modelo pues dos alumnos 01:16:54
que implementan la interfaz alumno o que heredan 01:16:55
y eso que nos permitiría 01:16:57
tener a todos los alumnos 01:17:00
en el mismo set 01:17:02
pero luego si yo lo recorro 01:17:03
cada alumno en función del tipo 01:17:06
que fuera 01:17:08
pues funcionaría de una forma o funcionaría de otra 01:17:09
que esa es la ventaja de la herencia y las interfaces 01:17:11
que yo podría seguirlos teniendo todos 01:17:14
en el mismo set, todos irían ahí 01:17:16
todos irían en este set 01:17:19
pero dentro de este set podría tener 01:17:23
alumno FP, alumno no sé qué 01:17:25
cada uno con sus propias 01:17:28
versiones de métodos 01:17:30
¿vale? bueno, pues todo eso no os olvidéis 01:17:31
porque es que eso es el meollo de la 01:17:34
programación 01:17:35
a ver, no, lo orientaremos a uno 01:17:36
más grande y ya está 01:17:41
¿vale? 01:17:42
pues bueno, alguna 01:17:46
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
18
Fecha:
11 de mayo de 2024 - 0:21
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 17′ 49″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
393.01 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid