Saltar navegación

20241213 POO-Clases-Ejer_4 - 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 13 de diciembre de 2024 por Raquel G.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

Fumaba mucho. 00:00:00
De hecho, no ha murido de cáncer de pulmón o algo así. 00:00:01
Es que acabo de poner... 00:00:08
Venga, entonces. 00:00:09
Vale, pues a ver, dos entidades solamente. 00:00:16
Empleado y departamento. 00:00:18
El empleado tiene dentro 00:00:22
una clase de... 00:00:24
Un objeto, una propiedad, que es departamento 00:00:25
porque trabaja en un departamento. 00:00:28
Luego la clase empleado, que no se ha hecho aquí, amablemente Ana, tiene estas cuatro propiedades. 00:00:30
Perfecto. 00:00:37
Tiene dentro un objeto departamento. 00:00:39
Vale, entonces, departamento, ¿por qué se caracteriza? 00:00:41
Solamente por el nombre, quién lo dirige, que es un empleado, y un conjunto de empleados. 00:00:45
¿Vale? 00:00:54
Entonces, esta clase de departamento es esta de aquí, que tiene el nombre, solamente un objeto empleado como director y un array de los empleados que lo caracterizan. 00:00:54
Entonces, ya de partida lo ha iniciado como un array cero para que no sea null, de forma que cuando se agregue el primer empleado, pues no tengamos un null pointer exception, ¿vale? 00:01:09
que es la práctica habitual 00:01:21
entonces cuando se instancia un objeto de departamento 00:01:23
lo primero que se hace es 00:01:25
se reserva en memoria 00:01:26
espacio para estas propiedades 00:01:29
si alguna está inicializada 00:01:30
si alguna está inicializada 00:01:33
se le da ese valor 00:01:34
y luego ya se ejecuta lo que haya en el constructor 00:01:36
¿vale? 00:01:39
entonces aquí tú en el constructor 00:01:41
de departamento, cuando se instancia un departamento 00:01:43
si lo instancias así 00:01:45
pues se le da un nombre y un director 00:01:46
y los empleados 00:01:48
todavía no va a tener ninguno, los empleados se van a ir agregando 00:01:51
después, se crea el departamento por ahora sin empleados 00:01:53
¿vale? pues bien 00:01:55
de hecho es lo habitual 00:01:56
cuando tenemos 00:01:58
entidades que dentro 00:02:01
tienen colecciones de datos o arrays 00:02:02
lo habitual es que esas colecciones 00:02:04
se metan en el constructor 00:02:07
tú haces, creas el objeto que sea 00:02:08
con las propiedades básicas 00:02:11
y luego lo que tiene dentro 00:02:12
que ya son colecciones ya se irán agregando 00:02:15
No se meten de golpe en el 00:02:17
En el objeto cuando se crea 00:02:19
Suele ser lo habitual, ¿vale? 00:02:22
Entonces, bueno, no has puesto get y set, pero bueno 00:02:24
Se podrían agregar, se pondría esto en privado 00:02:25
Venga, si lo vamos a subir 00:02:28
Vamos a ponerlo rápidamente 00:02:29
¡No! Pues 00:02:31
No pasa nada, porque tus compañeros te lo cambian 00:02:36
El que es público 00:02:38
Si lo pongo privado es privado 00:02:42
No es público 00:02:44
¿Cómo lo vas a hablar a todo el mundo? 00:02:44
lo sabrá si llaman al set 00:02:48
o al get 00:02:51
claro, al get sabrán 00:02:52
y al set podrán además modificar 00:03:00
y yo además podría en estos 00:03:01
métodos a lo mejor hacer cosas 00:03:04
porque yo los he dejado los básicos 00:03:06
pero podría a lo mejor en el set 00:03:07
pues hacer una verificación 00:03:10
aquí antes, pues yo que sé 00:03:12
para que solo 00:03:13
si el nombre cumple unas condiciones 00:03:14
me sirviera para actualizar 00:03:18
por ejemplo, entonces el set y el get 00:03:20
me permiten hacer muchas más cosas 00:03:22
si no accedo a las propiedades 00:03:23
con get y set, sino directamente 00:03:26
con punto nombre, no estoy 00:03:27
abriendo la posibilidad 00:03:30
ni de validar nada, ni de hacer nada 00:03:32
si lo pongo en el método, sí 00:03:33
vale, pues ya tenemos los get y set y si cambian 00:03:35
muchas cosas, pues las cambiamos 00:03:38
bueno, pues entonces 00:03:39
efectivamente 00:03:41
aquí ya, esto 00:03:43
simplemente, en tu clase 00:03:46
empleado, pues esto se cambia 00:03:48
que el directory se acabó, tampoco es tanto cambio 00:03:50
y ya no había más 00:03:52
errores aquí, vale, entonces 00:03:57
aquí ya en estas dos entidades 00:03:59
ya hay relaciones 00:04:01
es decir, esto 00:04:02
en una aplicación real tendríamos una base 00:04:05
de datos de empleados 00:04:07
y una base de datos de departamentos 00:04:08
y además habría relaciones entre ellas 00:04:11
por ejemplo, que primera 00:04:13
relación se os ocurre 00:04:15
teniendo en cuenta 00:04:17
que empleado tiene un objeto director 00:04:19
dentro, perdón, un objeto 00:04:21
departamento dentro 00:04:23
y departamento tiene una raíz de empleados 00:04:24
pues habrá 00:04:27
una relación de cuánto a cuánto 00:04:29
entre quién y quién 00:04:31
si, es que 00:04:32
tienes que ligarlo todo 00:04:35
de verdad, porque tú vas a ser un buen 00:04:36
desarrollador, aunque no estés 00:04:39
gordo, ni sea feo, ni sea raro, vas a ser 00:04:40
un buen desarrollador, así que tienes que ligar 00:04:43
los dos mundos desde ya 00:04:45
a ser posible, poco a poco 00:04:46
entonces, ¿qué relación 00:04:48
En las tablas, empleados y departamentos que mapearán, ya lo haremos el año que viene, mi módulo de acceso a datos, mi módulo de acceso a datos por el que me pagan, no es que lo haga por amor al arte, bueno, que también, se ocupa de eso, de aplicaciones donde sus datos están ya en bases de datos. 00:04:50
y no es trivial el volcado de los datos 00:05:14
en absoluto 00:05:16
pero es una parte imprescindible de cualquier aplicación 00:05:17
entonces 00:05:21
aquí ya, entre esa tabla 00:05:22
empleado y esa tabla de departamentos, ¿qué tipo de relación va a haber? 00:05:24
no, muchos a muchos no 00:05:29
uno a muchos 00:05:30
sí, había pocas alternativas, más, uno a muchos 00:05:31
el lado de uno y el lado de muchos 00:05:33
¿dónde está? 00:05:36
en el empleado, o sea, una clave ajena 00:05:37
habrá una clave ajena 00:05:39
hay que distribuir la clave a uno y a la de muchos 00:05:40
claro, o sea 00:05:42
un departamento 00:05:43
muchos empleados 00:05:46
¿vale? 00:05:47
y un empleado 00:05:50
un departamento solamente 00:05:53
entonces la clave ajena estará en empleado 00:05:54
que tendrá ahí un campo 00:05:56
que nos llevará a la tabla departamento 00:05:58
habrá una clave ajena que vaya 00:06:00
de empleado a departamento 00:06:02
pues eso 00:06:03
esa clave ajena 00:06:05
es la que cuando hagamos el volcado de los datos 00:06:07
hará que tú cojas todo el objeto 00:06:10
departamento al que apunta 00:06:12
ese empleado y lo metas aquí dentro 00:06:14
y efectivamente 00:06:16
un departamento puede tener 00:06:18
muchos empleados porque eso significa 00:06:20
una clave ajena 00:06:22
donde está la 00:06:23
clave es uno y a donde apuntas 00:06:25
al revés es muchos y a donde 00:06:28
apuntas es uno 00:06:30
bueno y luego 00:06:31
aparte tenemos una relación 00:06:34
más 00:06:35
dada por esto 00:06:37
¿verdad? 00:06:39
esta relación 00:06:40
es de 1 a 1 00:06:43
o de 1 a 0 00:06:45
es decir 00:06:45
un departamento 00:06:47
tiene 1 00:06:50
o 0 directores 00:06:52
si habilitamos que esto sea nulo o no 00:06:54
todo eso no es que aquí 00:06:56
tenga restricciones 00:06:58
aquí es la interpretación 00:07:00
depende del resto de la aplicación 00:07:01
si hace validaciones o no 00:07:03
aquí es que no 00:07:05
esto de las relaciones no implica que aquí haya que programar 00:07:06
nada, es la interpretación que se hace 00:07:10
de esto simplemente 00:07:12
no hay una forma de gestionarlo que 00:07:13
no afecte, que sea algo 00:07:15
en vez de apuntar a un director 00:07:17
que sea no 00:07:20
que sea ausente, un objeto opcional 00:07:21
hay una clase opcional 00:07:24
claro, que se 00:07:26
inventó a posteriori precisamente 00:07:28
por eso, tú puedes un objeto 00:07:30
cualquiera, o sea una clase 00:07:32
una referencia que es un objeto 00:07:34
la puedes, no, más que apuntada 00:07:35
meterla dentro como propiedad de un 00:07:38
opcional. Y ese opcional 00:07:40
se caracteriza por el valor 00:07:41
del objeto y 00:07:44
si existe o no existe. 00:07:45
Si está ausente o no lo está. 00:07:48
Entonces, tú no tiras del objeto directamente, 00:07:50
tiras del opcional, para ver si el 00:07:52
objeto está o no está. Entonces, no te 00:07:54
vas a encontrar nunca el nul. Esa es la idea 00:07:56
del opcional, ¿vale? Pero bueno, eso es una cosa ya más 00:07:57
rara para el año que viene. 00:08:00
La dejamos. Vale, pues aquí abre una relación 00:08:01
también. Un departamento, 00:08:03
un empleado, un director. 00:08:06
Un empleado director de un departamento solo. 00:08:08
No puede haber un empleado que dirija varios departamentos. 00:08:12
Es decir, aquí está puesta solo a un lado. 00:08:16
Podríamos haber puesto aquí otra propiedad. 00:08:19
Voy a ponerla abajo para que se vea mejor. 00:08:24
Departamento depto dirigido. 00:08:28
Así se vería mejor la relación de uno a uno. 00:08:36
Aunque esta no es de 1 a 1, es de 1 a 0 00:08:39
Porque no todos los empleados tienen por qué dirigir un departamento 00:08:41
Entonces 00:08:44
Un empleado puede o no 00:08:45
Dirigir un departamento 00:08:47
Ahí está el 0 00:08:49
Y un departamento es dirigido por un empleado sí o sí 00:08:50
Ahí está el 1 00:08:53
Eso se mapearía aquí en esta relación 00:08:54
Aquí hay uno solo 00:08:56
Y aquí hay uno solo 00:08:57
A ver, 1 a 1 00:09:00
O 1 a 0 dependiendo de si permitimos 00:09:03
Que esto sea nulo o no 00:09:05
Es que eso no es como en bases de datos 00:09:06
es que está todo absolutamente 00:09:09
encorsetado y tienes que programarlo 00:09:11
y ponerlo en restricciones, aquí no 00:09:13
tú lo pones así y luego ya haces tus 00:09:15
validaciones para permitir si es null, si no es null 00:09:17
ya programas interpretándolo como tú quieras 00:09:19
no pones la restricción como 00:09:21
la pones en el modelo relacional 00:09:23
pero esto representa eso 00:09:25
una relación de uno a uno o de uno a cero 00:09:27
depende si tú permites null o no permites 00:09:29
un empleado dirige un departamento 00:09:30
como mucho, un departamento es 00:09:33
dirigido por un empleado como mucho 00:09:35
¿vale? pero bueno 00:09:37
Bueno, no hace falta que para expresar una relación en Java pongamos en los dos lados, no hace falta, solo con que esté en departamento, un departamento es dirigido por un director, ya tenemos ahí expresada la idea. 00:09:38
al igual que aquí hemos puesto 00:09:51
un empleado trabaja en un departamento 00:09:54
pues esta ya no haría falta, esta está de más 00:09:57
porque ya teniendo 00:10:00
que esta propiedad aquí no haría falta 00:10:03
para la aplicación, esta es redundante, sobra 00:10:06
porque nosotros cuando nos dan un departamento 00:10:09
para saber los empleados que trabajan en él 00:10:12
con irnos a los empleados e ir buscando 00:10:14
los que en su propiedad son ese departamento ya lo tendríamos 00:10:17
vale 00:10:20
intentad pensarlo un poco 00:10:22
porque todas estas cosas son las que hacen que luego 00:10:26
podamos hacer las aplicaciones 00:10:28
en la propia 00:10:29
información, a ver, vamos a 00:10:34
quedarnos con 00:10:35
¿estamos hablando con base de datos? 00:10:37
es que es lo mismo 00:10:39
no, estoy hablando para programar 00:10:40
pero recogiendo 00:10:43
¿esos datos dónde los está guardando? 00:10:45
en cada empleado, cada empleado tiene el suyo 00:10:49
Ah, claro, sí 00:10:52
Tu pregunta, tú tendrás tu base 00:10:56
Tu array de empleados 00:10:58
Claro, cada empleado trabaja en un departamento 00:10:59
Y luego tu array de departamentos 00:11:01
¿Vale? Tu array de departamentos 00:11:03
Entonces, en tu 00:11:05
En tu array de empleados 00:11:06
Efectivamente, tú puedes saber 00:11:09
Dado un departamento, quién trabaja en él 00:11:11
No vas a poder saberlo metiéndote aquí 00:11:13
Porque esta propiedad no existe 00:11:15
Pero es que no pasa nada, esta propiedad sobra 00:11:17
Porque si te dicen departamento, ¿quién trabaja? 00:11:18
Pues te vas a array de empleados y vas 00:11:21
Buscando en el array cuáles de ellos tienen 00:11:23
En su propiedad 00:11:25
Departamento, ese departamento 00:11:26
Y ya tienes esa información 00:11:28
Entonces, en una relación de estas no hace falta 00:11:30
Que lo pongamos en los dos extremos 00:11:33
No hace falta porque la información 00:11:35
Es redundante 00:11:37
Pero queda más claro 00:11:40
Si yo lo tengo en los dos lados 00:11:41
Queda más claro 00:11:43
O sea, son diferentes diseños 00:11:44
Una aplicación la puedes diseñar de muchas maneras 00:11:45
y siempre se va a corresponder a un único 00:11:48
modelo de datos, digamos que 00:11:50
primero viene el modelo de tablas 00:11:52
mi información es esta, estos son 00:11:54
mis datos, mis tablas con 00:11:56
sus relaciones, eso es lo primero 00:11:58
y luego yo ya me hago una aplicación, me hago 00:12:00
las clases que reflejan eso 00:12:02
para manejar esos datos y hay un montón 00:12:04
de opciones, vale, entonces 00:12:06
la realidad esa de tablas 00:12:08
tengo un montón de empleados, tengo un montón 00:12:10
de departamentos con una clave ajena que me lleva 00:12:12
de empleado a departamento 00:12:14
Pues esa misma realidad la puedo gestionar 00:12:16
Quitando esta propiedad 00:12:19
Me da lo mismo, porque ya en cada empleado 00:12:20
Tengo que departamento 00:12:23
Trabaja, o quitando esta 00:12:25
Y metiendo aquí el array 00:12:27
Porque ya en cada departamento tengo los empleados 00:12:29
Lo puedo eso ya modelar de muchas maneras 00:12:31
Lo único que importa es que yo modele 00:12:33
Que 00:12:35
Cada empleado está en un departamento 00:12:35
¿Vale? Aquí 00:12:39
Lo hemos puesto en las dos partes 00:12:40
Está como redundante 00:12:42
¿Vale? 00:12:44
Bueno, se entenderá todo mucho mejor el año que viene, pero no tenéis que perder esa perspectiva de que las aplicaciones son datos moviéndose de un lado a otro. 00:12:46
Bueno, pues ya está. Esta es nuestra clase de departamento, nuestra clase empleado. 00:13:00
Vamos a ponerla con, revisamos los métodos y listo. 00:13:08
Y hacemos los constructores. 00:13:14
Perdón, los get y set 00:13:18
Ala 00:13:27
Y aquí al hacer el get y set 00:13:29
Pues 00:13:31
Esto lo tengo que cambiar 00:13:32
A get sueldo 00:13:35
Claro, efectivamente 00:13:36
Esto lo tengo que cambiar a get nombre 00:13:42
Y así nos queda 00:13:45
Pues más profesional la aplicación 00:13:47
Que con el punto sin más 00:13:49
Que eso ya queda raro y 00:13:52
Queda raro y feo 00:13:53
Vale 00:13:57
A ver, aquí tenemos 00:13:58
.get 00:14:00
Departamento 00:14:02
.get 00:14:04
Nombre 00:14:11
Y p. 00:14:12
Vale, aquí si hubieras 00:14:21
Puesto un toString en empleado 00:14:29
Pues te queda mejor 00:14:31
La aplicación 00:14:32
vale, vamos a cambiarla 00:14:33
para subirla con el toString que va a quedar más bonita 00:14:36
entonces, aquí a la hora de mostrar el empleado 00:14:37
ponemos el p ahí 00:14:40
alegremente, el p minúscula 00:14:41
y entonces 00:14:44
en empleado vamos a poner un método 00:14:46
toString para que el system.out cuando 00:14:48
llame a toString del objeto p 00:14:50
saque algo con sentido 00:14:51
pues venga, empleado 00:14:52
ponemos aquí un método toString 00:14:55
vale, nombre, sueldo y nif 00:14:58
Pero quitamos que muestre el objeto departamento 00:15:03
Porque el objeto departamento 00:15:05
Pues ya es mucha información 00:15:07
Tiene el array, no 00:15:08
El toString de empleado que muestre solo nombre, sueldo y NIF 00:15:09
Desactivamos esto 00:15:13
Ala, ya tenemos un toString 00:15:15
Y en departamento 00:15:18
Pues ya lo último que 00:15:21
Nos falta es director.getNombre 00:15:23
Vale, ya tenemos las dos clases 00:15:27
Con propiedades 00:15:36
Get y set, constructores 00:15:38
A falta de los métodos 00:15:39
De las cosas que haga la aplicación 00:15:41
Entonces, ¿qué cosas hace la aplicación? 00:15:43
Constructores, clase empleado 00:15:47
Mostrar el nombre del jefe 00:15:49
Subir el sueldo en porcentaje 00:15:50
Pasar por parámetro 00:15:51
Esto, muy fácil, ¿no? 00:15:52
Esto, muy fácil 00:15:54
¿Qué se puede hacer con los empleados? 00:15:55
Pues con los empleados 00:15:58
Lo que se puede hacer relativo a los empleados 00:15:59
Que sea 00:16:01
Mostrar quién le manda 00:16:02
Pues ya está 00:16:05
De su objeto departamento 00:16:08
sacamos su director 00:16:09
¿vale? 00:16:11
¿y qué más? 00:16:14
subirle a ese empleado 00:16:16
un porcentaje 00:16:17
ese porcentaje 00:16:18
es una variable 00:16:20
que cambiará 00:16:22
cada vez que yo llame 00:16:22
a subir sueldo 00:16:23
le puedo subir 00:16:24
un porcentaje distinto 00:16:25
luego eso es un parámetro 00:16:26
que se le da 00:16:27
desde fuera al método 00:16:28
entonces lo tengo que pasar 00:16:29
desde aquí 00:16:30
nada de de repente 00:16:31
ponerlo aquí arriba 00:16:32
ni hacer cosas raras 00:16:34
ni meterlo aquí 00:16:35
y leerlo con escáner 00:16:37
es un parámetro 00:16:40
Que recibe el método 00:16:40
Y ese porcentaje ya llegará de donde sea 00:16:41
Pues al sueldo 00:16:44
Se le incrementa 00:16:46
Esto de aquí 00:16:47
¿Vale? Porcentaje entre 100 00:16:49
Vale 00:16:51
Cuidado si hacéis la división 00:16:53
Antes de la multiplicación 00:16:56
Porque entonces os va a quedar 00:16:57
Cero, como habláis de enteros 00:16:58
Y al multiplicar por cero, la subida de sueldo va a ser cero siempre 00:17:01
Entonces así se hace primero 00:17:03
La multiplicación, que ya va a quedar 00:17:05
Mayor que 100 00:17:07
Y luego ya esto 00:17:09
pues ya está, los métodos de empleo 00:17:10
ya está, la casa de empleo está completa 00:17:17
no tiene nada, eso más o menos 00:17:19
lo habíamos hecho 00:17:21
¿qué se puede hacer relativo a los departamentos? 00:17:22
relativo a los departamentos 00:17:28
se puede hacer la media de lo que cobra 00:17:29
cada uno de los que trabaja ahí 00:17:31
cambiarle el director 00:17:33
porque uno se ha ido 00:17:35
y ya está, eso es todo lo que 00:17:37
la aplicación va a hacer relativo a los departamentos 00:17:39
Pues vámonos a la clase de departamento 00:17:41
Mostrar la media 00:17:45
Pues lo que hemos hecho toda la vida 00:17:48
Todo el rato, hacer una suma acumulativa 00:17:50
Sobre todas 00:17:52
Las propiedades sueldo de estos de aquí 00:17:54
Pues venga 00:17:56
Pues ya está, vamos recorriendo 00:18:00
La raya empleados 00:18:04
Sumamos el sueldo de cada empleado 00:18:05
Y una vez que hemos sumado el sueldo 00:18:08
Pues 00:18:10
Dividimos entre el total de empleados 00:18:10
Pues nada, lo mismo de siempre 00:18:13
¿Vale? 00:18:17
No ha hecho falta pasarle nada por parámetro 00:18:19
Porque toda la información que necesita es 00:18:21
Los empleados que trabaja, que los hemos puesto ahí 00:18:22
Si hubiéramos hecho una 00:18:25
Un diseño de clases 00:18:26
En los cuales 00:18:28
Meto en el empleado el departamento en el que trabaja 00:18:29
Y en departamento no meto nada 00:18:33
Ya cuando quiero buscar 00:18:34
Los empleados en un departamento, ya me voy a todos los empleados 00:18:37
para ver, pues si lo hubiera hecho así 00:18:39
este método 00:18:41
aquí no habría podido ir 00:18:43
no habría podido ir 00:18:45
tendríamos que haberlo metido en otra clase 00:18:47
haber hecho otro diseño 00:18:49
¿vale? pero aquí como hemos metido 00:18:51
dentro del departamento todos los empleados 00:18:54
pues ya está 00:18:56
claro 00:18:56
sí, sí, sí, claro 00:18:59
vale, y cambiar director 00:19:00
pues verificando 00:19:03
que trabaje, ¿no? 00:19:05
que el empleado pasado 00:19:08
Pues entonces, cambiar director, le pasas un nombre, Pepito, vamos a asegurarnos que el empleado trabaja en ese departamento. 00:19:09
Entonces, aquí, ¿por qué el libro has puesto de Abel? Es que lleva una letra, ¿vale? 00:19:21
Hombre, algún papel tendrás 00:19:41
y seguro que tiene letras 00:19:45
Claro 00:19:46
Pues el NIE tiene letras también, ¿no? 00:19:47
Sí, sí 00:19:51
Vale, pero vosotros por qué tenéis NIE 00:19:52
¿Pero no habéis nacido aquí? 00:19:55
Yo, yo sí 00:19:56
Habréis nacido aquí, sois muy críos 00:19:57
Tú no has nacido aquí 00:20:00
Ah, vale, yo pensaba que habríais 00:20:03
nacido aquí todos, hasta este que se las da de 00:20:06
bogoteño 00:20:08
¿No has nacido aquí? 00:20:09
Bueno, pero a ver 00:20:11
Es que 00:20:27
Le provocáis 00:20:27
Vale 00:20:30
Le estáis provocando 00:20:38
Voy a cambiar todos los dabels del NIF 00:20:40
Por stream 00:20:43
Vale, ya hemos cambiado 00:20:44
Stream por 00:20:55
Me falta aquí 00:20:57
Stream 00:21:01
Vale, empleado 00:21:02
Vale, entonces 00:21:08
A ver 00:21:10
Vale, dijimos el otro día, o sea, ayer, de nuevo, ligando con las bases de datos, que una base de datos bien diseñada en todas las tablas tendría que haber una clave primaria, ¿verdad? 00:21:11
no es que sea obligatorio, pero tiene que haber una clave primaria 00:21:33
pues cuando uno hace un buen diseño 00:21:35
de clases, igual 00:21:37
debería haber un campo 00:21:39
no es que sea obligatorio, pero debería haber un campo 00:21:40
que identificara de forma unívoca 00:21:43
los objetos 00:21:45
entonces aquí el NIF 00:21:46
identifica de forma unívoca 00:21:49
los empleados más que el nombre, ¿verdad? 00:21:51
se pueden llamar todos igual, pero el NIF 00:21:52
nadie lo tiene igual, ni el NIE, ni esas cosas raras 00:21:55
que tenéis vosotros 00:21:57
entonces 00:21:58
A ver, que ninguno somos de aquí, en última instancia. 00:22:00
Perdona, NIE es un papel, eso no es un sin papeles. 00:22:14
Venga, a ver, entonces, el NIE tiene mucho más sentido para identificar a alguien. 00:22:24
Entonces, ¿cambiar director? 00:22:29
Vamos a pasar el NIF porque se me dicen 00:22:31
Oye, voy a cambiar el director del departamento 00:22:33
¿Quién va a ser el nuevo director? 00:22:35
Juanito López, pues si es que hay tres Juanitos 00:22:37
No eres tú 00:22:39
¿Y qué hacemos? 00:22:40
Hay dos Juanitos López, pues tenemos un problema 00:22:45
Pero si vamos a cambiar el director 00:22:47
Del departamento, pero el director 00:22:49
¿Qué NIF tiene? O NIE, bla bla bla 00:22:50
Ahí no habrá duda, ya tenemos claro quién va a ser el nuevo director 00:22:53
Pues entonces, este método 00:22:55
Mejor pasarle el NIF que el nombre 00:22:57
cambia el director 00:22:58
y por favor que sea el director 00:23:01
con este nif, vale 00:23:03
vamos a buscarlo en nuestro array 00:23:04
buscamos en el array de trabajadores 00:23:06
con get nif 00:23:09
en este caso 00:23:11
no hombre no, esto es muy 00:23:12
vale, buscamos a ver si encontramos 00:23:16
un trabajador dentro del array 00:23:19
de empleados del departamento 00:23:21
cuyo nif sea igual a este, en cuanto lo encontremos 00:23:23
ya está, pues igual ahí 00:23:25
Vale, aquí siempre 00:23:27
Pues vendría bien lo de poner el boolean 00:23:30
Para si ya lo he encontrado 00:23:31
O si no hacemos una trampa 00:23:33
Pues igual ahí, siempre podemos hacer esta trampa 00:23:36
Igual a empleados.len 00:23:38
Y el for se acabó, no se ejecuta más, ¿verdad? 00:23:40
Esta trampita 00:23:42
Es fea, porque es 00:23:43
Es como un 00:23:45
Un quiero, un break y no me atrevo 00:23:47
Pues es lo más parecido a quiero 00:23:49
Pero no me atrevo 00:23:52
Poner el i 00:23:53
en la última, entonces el for 00:23:56
ya fuerza hasta que nunca más entre 00:23:58
vale 00:23:59
vale, y ahora ya 00:24:00
y ahora ya 00:24:04
si este empleado 00:24:11
get departamento nombre 00:24:12
equals 00:24:15
dis.nombre 00:24:16
pero 00:24:18
ah, y que 00:24:20
sea del departamento también 00:24:23
vale, no, pero ya está 00:24:25
claro, pero es que ya lo has verificado 00:24:27
antes 00:24:31
claro, ya 00:24:31
si no, no habría entrado en el array 00:24:34
entonces yo aquí pondría 00:24:36
si pos es diferente 00:24:38
de menos uno, simplemente 00:24:40
si pos es diferente 00:24:42
de menos uno, es que has 00:24:44
encontrado al empleado, ¿verdad? 00:24:46
y entonces 00:24:49
que sea este, director cambiado y si no 00:24:50
vale, este método 00:24:52
de cambiar al director, todo el mundo lo ha 00:24:54
entendido y lo tiene claro 00:24:56
a ver, porque ella ha inicializado 00:24:57
esta variable a menos uno 00:25:03
y luego se ha puesto a buscar en el array 00:25:04
hasta que ha encontrado un empleado 00:25:06
cuyo nif es el que le han dado 00:25:08
imagínate que no lo hubiera encontrado nunca 00:25:10
y, perdón, pos seguiría 00:25:12
siendo menos uno 00:25:15
y si lo ha encontrado, y será 0, 1, 2, el que sea 00:25:15
entonces por eso lo verifica 00:25:19
¿lo he encontrado porque pos ya no es 00:25:20
menos uno? pues ya tengo un nuevo director 00:25:22
que es este empleado que he encontrado 00:25:24
en el array 00:25:26
con ese NIF 00:25:27
que no 00:25:29
pues dejo el que estaba porque ese empleado 00:25:30
no pertenece al departamento y luego no puede ser el jefe 00:25:33
y ya se han acabado 00:25:35
los métodos 00:25:38
ah ya, ya se han acabado los métodos 00:25:39
de las clases 00:25:44
ahora tenemos ya 00:25:45
la clase principal que usa estos métodos 00:25:47
para gestionar cosas 00:25:50
ya, a ver bueno 00:25:51
pero estas dos entidades están claras hasta para 00:25:54
¿A ti que no me estás haciendo ni caso? 00:25:58
Te veo pensando en tus cosas. 00:26:02
¿Que estás más perdido qué? 00:26:10
El chavo del ocho del día del padre. 00:26:14
¿Pero y quién era ese? 00:26:19
¿No te acuerdas del chavo del ocho? 00:26:20
El chavo del ocho yo no lo he conocido. 00:26:21
¿Y el chapulín colorado? 00:26:28
Tampoco 00:26:31
¿Chispitos? 00:26:32
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
14
Fecha:
13 de diciembre de 2024 - 18:09
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
26′ 35″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
112.53 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid