Saltar navegación

Ejercicio Empresa (Herencia) parte1 - 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 24 de enero de 2023 por Stefano C.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Entonces, todo lo que digáis en esta grabación está pensado para que vosotros le deis autorización. 00:00:00
Vale, entonces, estamos haciendo un ejercicio de herencia. 00:00:06
Estamos viendo este ejercicio aquí, el empleado. 00:00:11
Entonces, en la primera clase que vamos a hacer, la clase empleado, que tiene atributos nombre, salario y fecha de contratación. 00:00:13
vale entonces string nombre doble salario y fecha de contratación 00:00:20
si queréis podemos utilizar local date 00:00:35
fecha contratación local date lo tengo que importar vale aquí el java time 00:00:39
entonces me importa una clase que ya existe en java por lo tanto lo que me 00:00:53
dice además dice tengo que construir a hacer constructores para empleado vale 00:01:00
entonces que constructores le voy a dar empleado por ejemplo public empleado que 00:01:07
reciba string n 00:01:14
doble 00:01:16
e local 00:01:22
date 00:01:24
o sea lo que estoy haciendo es 00:01:28
darme los tres parámetros y con 00:01:33
esto local date mayúsculo 00:01:35
y con estos parámetros pues los pongo 00:01:37
en los atributos 00:01:41
¿vale? del 00:01:44
objeto, dis.nombre 00:01:44
es igual a n 00:01:47
dis.salario 00:01:48
es igual a 00:01:51
dis.fecha 00:01:59
contratación es igual a s 00:02:03
vale, ya está 00:02:05
esto es 00:02:07
básico por ahora 00:02:08
si, puedes hacer 00:02:11
también otros 00:02:13
Constructores 00:02:14
Empleado, por ejemplo un constructor 00:02:19
Donde solo me dan el nombre 00:02:21
Entonces si solo me dan el nombre 00:02:23
Lo que hago es 00:02:28
Dis.n 00:02:29
Es igual a 00:02:32
Dis.nombre es igual a n 00:02:33
Dis.salario 00:02:35
Es igual a 00:02:38
No sé 00:02:40
Mil 00:02:42
Un salario básico 00:02:44
si no me dicen el salario, le doy el salario 00:02:47
mínimo, que no sé cuánto será 00:02:49
y this.fecha 00:02:51
contratación 00:02:54
o le doy null 00:02:56
vale 00:02:57
o intento darle 00:02:59
la fecha de hoy 00:03:01
vale 00:03:04
que no me acuerdo cómo se hace 00:03:04
vamos a buscar 00:03:07
vale, tendré que crear 00:03:08
local date 00:03:11
bueno, puedo hacer así 00:03:13
una opción es 00:03:15
localdate.off 00:03:20
y darle la fecha de hoy 00:03:23
o sea, dará siempre 00:03:25
una fecha concreta 00:03:27
2023 00:03:29
con esto siempre cualquiera que se cree 00:03:36
la fecha de contratación 00:03:41
se dará al 24 de enero 00:03:43
de 2023, siempre 00:03:45
vale, a lo mejor no es 00:03:47
no tiene sentido 00:03:49
si yo me voy aquí 00:03:51
en el 00:03:53
en el array 00:03:55
veis que tenemos un 00:03:57
static local date 00:03:59
esto es lo que devuelve 00:04:01
y este es el método 00:04:07
now 00:04:08
vale, entonces hay un 00:04:09
modo para decir ahora 00:04:12
dame la fecha de ahora 00:04:14
Entonces lo que puedo decirle yo es 00:04:16
Vale, entonces dame 00:04:19
Si no me dices 00:04:21
Cuando 00:04:26
Pues dame la fecha de ahora 00:04:27
Del momento en que se crea el objeto 00:04:29
Esa es la fecha de contratación 00:04:31
¿Sí? 00:04:33
Vale 00:04:37
Y ya está, yo creo que 00:04:37
O sea, un empleado siempre tendrá un nombre 00:04:41
No voy a crear un empleado sin darle un nombre 00:04:42
Si tengo que crear un empleado sabré quién es 00:04:44
Si sé todo de él, le pongo todo 00:04:46
Si no sé todo de él, le doy un salario básico y lo contrato desde hoy, ¿vale? 00:04:48
Sigamos con lo que pide el ejercicio 00:04:58
El ejercicio sigue con 00:05:01
Vale, crear una clase gerente que herede a la clase empleado 00:05:04
Y añade un nuevo atributo que se llama bonus, ¿vale? 00:05:08
Utilizar constructores para inicializar los atributos, ¿vale? 00:05:11
Entonces, además de un empleado normal, yo tengo un gerente, gerente hereda de alumno. ¿Cómo hago que gerente herede de alumno y de alumno de empleado? 00:05:15
Extend 00:05:36
Empleado 00:05:39
En mayúscula 00:05:42
Entonces ya esto me está diciendo 00:05:51
Que todo lo que está aquí en empleado 00:05:53
Más o menos lo puedo utilizar 00:05:55
Desde gerente 00:05:57
Entonces 00:05:58
Me dice que tengo que añadir un nuevo 00:06:00
Atributo 00:06:03
Que es el atributo bonus 00:06:05
Supongo que sea un bonus al 00:06:06
al salario 00:06:08
vale, entonces 00:06:11
doble 00:06:11
bonus 00:06:13
y ahora voy a crear 00:06:15
public 00:06:19
gerente 00:06:21
public gerente 00:06:23
si creo un gerente 00:06:36
lo que hago es 00:06:38
poner que su bonus 00:06:40
es igual 00:06:43
Al bonus que me pasen aquí 00:06:47
Doble 00:06:49
Realmente si yo creo un gerente 00:06:51
Sé que tiene que tener un bonus 00:06:57
Por lo tanto se lo pondré 00:06:59
Aquí hay algo raro 00:07:01
¿Por qué se enfada? 00:07:03
Porque aquí sin haber dicho nada 00:07:10
Yo estoy llamando super 00:07:12
Y como este super 00:07:13
No está definido 00:07:17
En empleado 00:07:19
Porque empleado no tiene empleado sin nada 00:07:20
Pues él se me enfada 00:07:23
Y me dice, no lo puedo llamar 00:07:25
No hay un constructor sin nada 00:07:26
Por lo tanto no lo puedo hacer 00:07:29
Fijaos que si yo me voy a empleado 00:07:31
Y le digo, hay un constructor sin nada 00:07:33
Public empleado 00:07:36
Que no hace nada 00:07:38
¿Vale? 00:07:43
Entonces ahora 00:07:45
Doble 00:07:46
Esto ya no es un problema 00:07:47
Es más, esto ya no es un problema 00:07:50
Da igual ponerlo que no ponerlo 00:07:53
Porque siempre va a utilizar 00:07:56
si uso el constructor por defecto da igual ponerlo que no ponerlo, no ponerlo 00:07:57
es igual a poner super como ahora existe no obstante no haga nada 00:08:03
de hecho este de aquí en realidad tiene una línea de código, que línea de código tiene? 00:08:12
que habría escrito aquí? que haya escrito aquí que no veo? super y quién 00:08:16
es este super 00:08:32
object 00:08:33
en este caso, esto está llamando 00:08:35
el constructor por defecto de arriba 00:08:40
que es este constructor de aquí 00:08:42
que llama el constructor por defecto de arriba 00:08:44
que es el constructor de object 00:08:46
entonces me crea un objeto al que no le añade 00:08:48
nada, porque aquí no le añade nada 00:08:51
al que le añade, le añade este de aquí 00:08:52
bueno, en realidad 00:08:55
aquí si le añade estos tres 00:08:58
pero no lo 00:09:00
Como se dice, no los inicializa 00:09:02
Entonces esto sería feo 00:09:05
Pero yo esto no lo quiero 00:09:09
Hemos dicho porque un empleado como mínimo 00:09:11
Tiene que tener un nombre 00:09:12
Entonces esto se enfada 00:09:14
A menos que yo no diga 00:09:16
Cuando creo un nombre, un gerente 00:09:18
Como mínimo tendrá que tener un nombre 00:09:20
Y su sueldo 00:09:22
Su bonus 00:09:26
Entonces aquí lo que llamo es 00:09:28
SuperDN 00:09:31
Que eso si existe 00:09:32
Estoy llamando el constructor 00:09:34
De mi superclase 00:09:36
Que reciba solo 00:09:38
Nombre 00:09:40
Estoy llamando este constructor de aquí 00:09:41
Se ejecuta este constructor de aquí 00:09:44
Bueno, aquí se ejecuta el constructor 00:09:46
De object, luego se ejecuta 00:09:49
Este código de aquí 00:09:51
Luego volvemos aquí y ejecutamos también 00:09:52
Este código de aquí 00:09:54
Y también 00:09:56
Tengo otro 00:09:59
Otro constructor 00:10:02
Public 00:10:04
Diferente 00:10:05
Que pilla todo 00:10:07
String n 00:10:09
Que era 00:10:11
Doble s 00:10:14
Local 00:10:16
Date 00:10:18
Coma doble 00:10:23
Y lo que hace este señor 00:10:26
Super 00:10:32
De que 00:10:34
N, S y F 00:10:36
Lo he llamado F o lo he llamado L 00:10:45
Llama el super 00:10:46
Constructor 00:10:52
Que utiliza 00:10:54
N, S y F 00:10:56
Es decir, esto 00:10:58
Y una vez que haya ejecutado esto 00:10:59
Hace lo que tiene que hacer 00:11:05
Esta clase 00:11:06
O sea, this.bonus 00:11:07
Es igual a B 00:11:09
dudas por qué lo utilizó local de itamaki no lo ha importado entonces tengo 00:11:11
que acordarme de importarlo aquí también si no no sabe dónde la cuenta porque él 00:11:30
buscará local de ita en el package no la encuentro entonces está esta clase no 00:11:37
está definida yo tengo que decirle hoy a mí tienes que importar esta local de 00:11:42
de aquí, la local data del 00:11:46
package java.time 00:11:48
dudas? 00:11:49
vale, y esto también 00:11:57
el gerente está hecho, más o 00:11:59
menos, ¿vale? por como lo pide aquí, veis que son 00:12:01
ejercicios bastante sencillos 00:12:03
para empezar, ¿vale? 00:12:05
voy ahora 00:12:08
porque 00:12:09
quiero dar la posibilidad 00:12:16
a quien crea algo 00:12:18
de tener varias opciones 00:12:19
imagínate que yo 00:12:21
te tengo aquí, te tengo que contratar 00:12:22
te contrato como empleado 00:12:25
y tú has venido de otra empresa 00:12:26
y me has dicho, oye mira, por menos de 1500 euros 00:12:29
no voy, pues yo te hago un contrato 00:12:31
con 1500 euros y te contrato 00:12:33
desde el final del mes 00:12:35
¿vale? entonces tengo que utilizar 00:12:37
esto 00:12:39
para poder hacerlo 00:12:40
sin embargo, si yo sé que 00:12:43
tú te incorporas hoy, es tu primer trabajo 00:12:45
y entonces ganas el mínimo 00:12:47
y cosas por el estilo, pues puedo utilizar esto 00:12:49
O si simplemente yo soy de recursos humanos 00:12:51
Pero no me han dicho 00:12:54
Me han dicho el nombre 00:12:55
Pero todavía no me han dicho 00:12:56
Las características de tu contrato 00:12:57
Pues entonces uso este de aquí 00:13:00
Que te crea en la base de datos 00:13:02
Y luego ya, pues, veremos que hago 00:13:04
¿Sí? 00:13:06
O sea, el constructor 00:13:09
Es una forma 00:13:10
Dar varios constructores 00:13:13
Es una forma que tienes tú 00:13:14
Para dar flexibilidad 00:13:16
Cuando se crea un 00:13:18
Un objeto 00:13:20
Dar flexibilidad a quien lo está creando 00:13:23
Para crearlo de distintas formas 00:13:25
Mírate por ejemplo 00:13:27
El API Java de String 00:13:29
String 00:13:31
Tiene todos estos constructores de aquí 00:13:34
Todos estos son constructores 00:13:37
Tú puedes construir 00:13:39
Un String sin nada 00:13:40
Le puedes pasar 00:13:43
Un array de byte que él considera 00:13:45
Cada byte lo interpretará como un carácter 00:13:47
y lo utilizará como una cosa 00:13:49
un array de bytes 00:13:51
pero diciéndole cual es el 00:13:54
el chart set 00:13:56
el conjunto de caracteres que estás 00:13:57
utilizando, le puedes decir 00:14:00
un byte en 00:14:02
ascii y luego 00:14:04
este es deprecated 00:14:05
para afuera, o sea, hay distintas 00:14:08
formas de crear una 00:14:10
string, vale, y porque hay todas estas 00:14:11
porque hay en algunos casos 00:14:14
en que esto te puede ser útil, por ejemplo 00:14:16
Si tú estás leyendo desde un fichero 00:14:17
Y la forma con que lo estás leyendo 00:14:20
Es de byte en byte 00:14:22
Y sabes que es un fichero de texto 00:14:23
Cuando has leído todos los bytes 00:14:25
En un array de bytes 00:14:27
Pues se lo pasas a un 00:14:28
Constructor de string que 00:14:31
Interprete estos bytes como 00:14:32
Carácteres y ya tienes tu string leída 00:14:34
Vale, ya lo veremos cuando 00:14:36
Haremos acceso a ficheros 00:14:39
Vale 00:14:41
Entonces, siga adelante 00:14:43
La tercera pasa 00:14:46
El punto 3 y 4 00:14:48
Son menos, tienen menos a que ver con 00:14:51
Herencia, vale, pero 00:14:53
Nosotros haremos alguna cosa para ver que 00:14:54
Que algo tenga que ver, vale 00:14:57
Entonces voy a crear 00:14:59
La tercera que es departamento 00:15:01
Creo una clase 00:15:03
Departamento 00:15:08
¿Qué hace la clase departamento? 00:15:10
Contiene un array 00:15:17
De objetos empleados, vale 00:15:18
Y tiene un modo para calcular el salario total del departamento 00:15:20
Vale, vamos a ver 00:15:24
¿Cómo lo hacemos esto? 00:15:25
Un array de empleados 00:15:30
¿Vale? 00:15:33
Entonces, empleado 00:15:33
Array 00:15:35
Empleados 00:15:38
Estos son los empleados de este departamento 00:15:39
¿Sí? 00:15:44
¿Cómo creo un departamento? 00:15:47
¿Cómo creo un departamento? 00:15:57
¿Qué tengo que hacer? 00:15:59
Constructor 00:16:00
¿Cómo creamos este constructor? 00:16:02
Primer constructor, public 00:16:04
Departamento 00:16:05
¿Qué recibe? 00:16:07
Empleado 00:16:17
Si me pasas un array de empleado 00:16:18
Que ya has creado tú 00:16:23
Yo simplemente lo que voy a hacer 00:16:24
Es que 00:16:27
Empleados 00:16:28
Dis.empleados 00:16:30
Es igual a lo que me ha pasado 00:16:32
Quiero usar 00:16:37
Otros constructores 00:16:40
Quiero hacer un departamento vacío 00:16:42
Otra opción 00:16:45
Podría ser que yo crea un departamento vacío 00:16:50
Y luego empiezo a rellenarlo 00:16:52
Añadiendo 00:16:55
Empleados 00:16:55
Es esto 00:16:58
El departamento tiene 00:17:03
Una red de empleados 00:17:07
Y me pasas una red de empleados 00:17:08
Y yo lo pongo allí 00:17:11
¿Vale? 00:17:12
Otra opción sería que me pasas 00:17:14
Un alumno 00:17:16
Un empleado solo 00:17:18
Un objeto empleado 00:17:20
Para decir que para hacer un departamento 00:17:21
Necesita al menos un empleado 00:17:23
Si el departamento no tiene empleados 00:17:25
No lo puedo construir 00:17:26
Y yo creo un array con solo ese empleado ahí dentro 00:17:27
Así, ¿eh? 00:17:32
Para public 00:17:33
Departamento 00:17:35
me pasas 00:17:39
solo un empleado 00:17:42
y yo lo que hago 00:17:45
es que this.empleado 00:17:48
es igual 00:17:51
a new 00:17:54
empleado 00:17:59
de uno 00:18:02
me crea un array 00:18:03
de una posición 00:18:06
empleados 00:18:09
De 0 00:18:10
Es igual a 00:18:13
Entonces hay dos formas 00:18:14
De crear un departamento 00:18:19
O me pasas la lista de los empleados 00:18:21
En un array 00:18:23
O me pasas el primer empleado 00:18:24
De ese departamento 00:18:27
Y yo ya lo pongo ahí dentro 00:18:28
Ya veremos que hacemos 00:18:31
¿Sí? 00:18:34
¿Dudas? 00:18:38
¿Dudas? 00:18:42
Esto no hereda de nadie 00:18:43
En realidad hereda de alguien 00:18:50
¿De qué hereda? 00:18:52
¿Cómo? 00:18:55
¿Por qué departamento debería heredar de empleado? 00:18:57
¿Departamento es un empleado? 00:19:04
Por lo tanto no hereda 00:19:08
¿Vale? 00:19:09
Acordaos que cuando heredáis 00:19:10
Le estáis dando una 00:19:12
Relación de is a 00:19:13
Es un 00:19:17
Entonces si yo hago departamento está en de empleado 00:19:17
Estoy diciendo que el departamento es un empleado 00:19:20
¿No es verdad? 00:19:22
¿Sí? 00:19:25
Por lo tanto, esto no hereda de nada 00:19:26
Y en automático hereda de obvio 00:19:28
Sí, vale 00:19:29
Entonces, tened en cuenta también que 00:19:32
Aquí dentro tengo empleado, ¿vale? 00:19:34
Puedo poner empleado y aquí le paso un empleado 00:19:36
En realidad, aquí le puedo pasar 00:19:38
O un empleado, o 00:19:41
No se oigo 00:19:42
O un 00:19:49
Pero puedo pasarle o un empleado 00:19:51
O un array de empleados 00:19:54
O un gerente 00:19:55
O un array de 00:19:58
Gerentes 00:19:58
O un array mezclado de gerentes empleados 00:20:01
¿Vale? Ahora ya veremos que le pasamos 00:20:04
¿Sí? 00:20:06
Entonces 00:20:09
Ahora me dice 00:20:10
Sigo con lo básico 00:20:11
Luego después lo mejoramos si queremos 00:20:13
Me dice 00:20:15
Tengo un método para calcular 00:20:16
el salario total del departamento 00:20:20
entonces 00:20:22
public 00:20:24
doble 00:20:25
salario 00:20:28
dept 00:20:30
como calculo 00:20:31
doble 00:20:36
salario 00:20:41
departamento 00:20:43
return 00:20:44
salario departamento 00:20:47
como calculo 00:20:49
el salario del departamento 00:20:53
con un for 00:20:54
int i es igual a 0 00:20:58
i menor que que 00:21:04
empleados.lang 00:21:08
justo 00:21:13
voy recorriendo esto 00:21:16
independientemente que tenga miles o tenga uno 00:21:20
pues lo que voy a hacer es intentar así 00:21:24
pregunta para vosotros 00:21:27
¿podría ser que esto sea nul? 00:21:28
Podría ser que empleado sea null 00:21:30
¿Cuándo? 00:21:41
Si yo aquí le paso null 00:21:48
Pues eso será null 00:21:50
Si yo cuando lo creo 00:21:52
Lo creo con 00:21:55
Departamento de 00:21:56
Es igual a 00:21:58
New departamento 00:22:00
De null 00:22:03
Esto me lo crea 00:22:05
Quiero que pueda ser así 00:22:11
Pues entonces podría ser que cuando uno me pasa 00:22:19
Aquí podría pasar 00:22:25
Cuidado 00:22:26
Empleados no sería null 00:22:29
Podría ser que el empleado dentro de empleados sea null 00:22:32
Si me pasa null aquí 00:22:35
Si yo quiero evitar estas cosas puedo comprobarlo aquí dentro 00:22:37
Por ejemplo, hagamos que si me pasan un null aquí 00:22:43
Hago algo, ¿vale? 00:22:46
Entonces la pregunta es 00:22:48
Es not null 00:22:53
Entonces 00:22:55
No tengo problemas 00:22:58
Y si no 00:23:00
Me han pasado null 00:23:02
Entonces que hago con empleados 00:23:08
Y como creo 00:23:10
Que hago 00:23:14
Empleado 00:23:30
Array 00:23:33
Os gusta así 00:23:35
Creo una posición vacía 00:23:42
Con dentro que 00:23:46
Y por ejemplo 00:23:50
Si vosotros quisierais saber 00:23:58
Cuantos empleados hay en este departamento 00:23:59
Que haríais 00:24:01
Yo se me lo pillaría así 00:24:02
Técnicamente me has dado nul 00:24:22
Entonces me estás diciendo que no hay 00:24:32
No hay ningún 00:24:34
Empleado 00:24:35
Vale, entonces yo te creo 00:24:38
Una red de empleados con cero 00:24:40
Y si esto me funciona 00:24:41
Ahora cuantos 00:24:44
Como hago para saber cuantos empleados hay 00:24:45
Empleados.length 00:24:48
Claramente por algún lado tendré que tener 00:24:52
Un método add que me añada 00:24:57
Empleado, pero eso de 00:24:59
Añadir elementos a un array 00:25:01
Ya lo hemos hecho 00:25:03
Hemos hecho el viernes pasado 00:25:04
Entonces, por ahora 00:25:06
Dejamos así, veamos si no explota 00:25:09
Aquí hacemos algo parecido 00:25:10
Es decir, perdón, aquí 00:25:12
Si me pasan un empleado E 00:25:14
Que no es null 00:25:17
Vale, fenomenal 00:25:18
If E is not null 00:25:19
Hace esto 00:25:22
Y estamos todos felices 00:25:25
Y si no 00:25:26
Pues si me has creado un departamento 00:25:28
Que no es nada 00:25:43
Y yo admito esto 00:25:44
Pues hago lo mismo 00:25:45
Como me has pasado un empleado 00:25:46
Que no existe 00:25:50
Pues igualmente creo el departamento 00:25:50
Con su 00:25:53
Array de empleados 00:25:54
Pero el array de empleados no tiene nada dentro 00:25:58
Porque al fin y al cabo me ha pasado null 00:26:01
No me ha pasado un empleado 00:26:03
Me ha pasado una cosa vacía 00:26:04
Entonces aquí os estoy admitiendo 00:26:06
La posibilidad de que haya 00:26:09
Departamentos vacíos 00:26:10
A lo mejor hay departamentos 00:26:12
Que son sólo 00:26:14
Para la organización 00:26:16
De mi empresa 00:26:19
Que son útiles que los tenga allí 00:26:21
Para que cuando le hago 00:26:22
No sé, calculo el presupuesto 00:26:23
Cosa por estilo, si tengo que asignar 00:26:27
Dinero a ellos también 00:26:28
Pero que no tienen empleados 00:26:30
Concretamente allí dentro 00:26:32
A lo mejor son externalizados 00:26:33
Y por lo tanto no son empleados míos 00:26:36
Pero existe el departamento 00:26:37
Estoy dando como programador 00:26:39
Esta posibilidad, si no quiero 00:26:44
Darla, pues tengo que hacer algo aquí 00:26:45
Entonces, ahora 00:26:47
Como he hecho esta cosa de aquí 00:26:58
Puede ser que esto sea null 00:27:00
Ahora ya no 00:27:02
Pase lo que pase 00:27:04
Siempre lo he 00:27:06
Estanciado a un nuevo array 00:27:07
O me lo han pasado ellos 00:27:09
Aquí me lo han pasado ellos 00:27:11
Y no es null, por lo tanto está bien 00:27:13
Aquí me lo han pasado ellos 00:27:15
Pero es null 00:27:18
Y lo he creado yo 00:27:19
Aquí me han pasado solo un empleado 00:27:20
Y lo he creado yo 00:27:23
Y lo he metido el empleado dentro 00:27:25
Y aquí me han pasado un empleado 00:27:26
Pero el empleado es null 00:27:28
Y yo he creado el empleado 00:27:29
Entonces, en cualquier caso 00:27:31
Si yo creo un departamento 00:27:33
Empleados no es null 00:27:34
Es algo 00:27:37
¿Vale? 00:27:39
Por lo tanto lo puedo utilizar tranquilamente 00:27:40
Sin problemas 00:27:42
Sin tener miedo a que esto explote 00:27:43
¿Sí? 00:27:46
Cuidado 00:27:49
Si no fuera así 00:27:50
Y empleados podría ser null 00:27:51
Pues aquí quizás debería hacerme un 00:27:53
If empleados 00:27:56
No es null 00:27:57
Entonces 00:28:00
Haz lo que sea, porque si yo 00:28:03
Intento hacer, por ejemplo 00:28:05
Empleados.length 00:28:06
Y empleados es null, ¿qué pasa? 00:28:08
Null pointer exception 00:28:12
Vale 00:28:14
Sigo, y más más 00:28:17
Entonces 00:28:19
Esto me está 00:28:22
Cuidado, y si este señor de aquí 00:28:24
Es esto 00:28:26
¿Qué pasa en este for? 00:28:28
Que ni empieza 00:28:32
Vale, pone i igual a cero 00:28:33
Y cero no es menor que cero 00:28:35
Y por lo tanto es falso, por lo tanto es niento 00:28:38
¿Sí? 00:28:41
Y entonces devolvería que este departamento me costa cero 00:28:45
¿Sí? 00:28:48
Vale 00:28:53
Entonces, ¿qué hago ahora? 00:28:54
Es igual a qué 00:29:07
Sd igual a más 00:29:08
O más igual, vale 00:29:11
Esto es igual a decir más igual 00:29:12
Empleados 00:29:16
De ahí 00:29:20
Punto 00:29:22
Salar 00:29:23
Y habría que añadir otra cosa 00:29:24
Que 00:29:30
Si fuera gerente 00:29:31
If, a ver, estamos todos de acuerdo 00:29:36
Esto es 00:29:38
Más igual quiere decir 00:29:40
SD es igual a SD más 00:29:42
¿Vale? 00:29:45
Es la forma más rápida de escribir 00:29:46
Empleados de i.salario 00:29:48
Vete al empleado que estamos mirando ahora 00:29:50
Cede a su salario y píllalo 00:29:52
Si yo esto fuera privado por alguna razón 00:29:54
Pues pondría aquí getSalario 00:29:56
O algo que me pueda dar su salario 00:29:58
¿Vale? 00:30:01
Podría esconder todo esto 00:30:01
en un método de 00:30:04
dame tu coste 00:30:06
¿vale? y hacer que aquí simplemente 00:30:08
escribe el salario, mientras en gerente 00:30:11
escribe el salario más el bonus 00:30:12
y entonces evitaría 00:30:14
de hacer cosas raras aquí 00:30:16
¿vale? si queréis lo hacemos antes desde aquí 00:30:18
y luego lo hacemos desde allá 00:30:20
¿eh? entonces 00:30:21
esto ha asomado 00:30:23
el salario de todos ¿vale? pero 00:30:26
ahora hay algunos empleados especiales 00:30:28
que además de 00:30:31
costarme el salario me costan el bonus 00:30:32
Entonces, ¿cómo lo hago este aquí? 00:30:34
¿Cómo hago desde aquí a saber si 00:30:37
Este empleado que estoy mirando 00:30:39
Que es un empleado 00:30:41
Es un gerente 00:30:42
Empleados 00:30:48
De ahí 00:30:56
Si el que estoy mirando ahora 00:30:58
Estoy siempre en el mismo ciclo de for 00:31:00
Instanche of 00:31:01
Gerente 00:31:07
Instan 00:31:11
Si el elemento que estoy mirando ahora es también una instancia de gerente 00:31:14
Entonces esto sería true 00:31:23
Entonces quiere decir que yo puedo intentar 00:31:24
Que yo lo puedo tratar como gerente e intentar acceder a su bonus 00:31:29
¿Cómo lo hago? 00:31:32
SD más igual 00:31:34
SD más igual, vuelvo a sumar a SD al sueldo total 00:31:35
¿Qué? 00:31:40
¿El bonus? 00:31:42
Sí, ¿cómo lo hago? 00:31:43
empleados 00:31:46
de ahí, punto, bonus 00:31:47
cuidado, pero no lo está haciendo 00:31:50
está dando un error, te está diciendo 00:32:04
oye, mira, que no lo puedo resolver 00:32:06
si yo me voy a empleado 00:32:08
y ese es un empleado, aquí no hay de ningún lado 00:32:09
el bonus 00:32:12
tú me estás diciendo que es un empleado 00:32:13
ese empleado es un empleado 00:32:17
este es un empleado 00:32:18
Es como se lo digo 00:32:20
Que lo trate como gerente 00:32:23
Píllame este señor 00:32:24
Tráctamelo como un gerente 00:32:35
Y accede 00:32:37
A su bonus 00:32:39
¿Esto lo puede hacer? 00:32:40
¿Qué es que me permite 00:32:44
Hacer esto? 00:32:45
El hecho es que haya comprobado que 00:32:47
Él es un gerente 00:32:51
Cuidado que si lo hago 00:32:55
Directamente sin esto 00:32:57
Esto me lo trata bien 00:32:58
me dice, sí, sí, no hay errores 00:33:03
pero la primera vez que intente calcularlo 00:33:04
y el elemento que está aquí dentro 00:33:07
no es un gerente, sino es un 00:33:09
empleado, va a explotar 00:33:11
no a tiempo de 00:33:13
compilación, porque a tiempo de compilación 00:33:15
esta es una cosa que puede hacer, sino a 00:33:17
tiempo de ejecución 00:33:19
¿vale? cuando lo 00:33:20
ejecuto, llega un momento en que 00:33:23
este empleado lo intento tratar como un 00:33:25
gerente y no es un gerente 00:33:27
y me explota, ahora lo vamos 00:33:28
a ver, lo vamos a hacer 00:33:31
Y vemos que pasa 00:33:32
¿Vale? 00:33:33
Esta es una forma de hacerlo 00:33:37
¿Vale? 00:33:40
Por ahora lo dejamos así 00:33:42
Y luego, bueno 00:33:43
Hagamos la versión 2 00:33:44
Return SD 00:33:48
Creamos 00:33:49
Sí, creamos otro método 00:33:51
Para no 00:33:56
Imaginémonos que tengo 00:33:57
Salario departamento 2 00:33:59
Otra forma de calcularlo 00:34:01
¿Vale? 00:34:03
Y quiero que en vez de hacer estas cosas por aquí 00:34:03
Lo que voy a modificar es empleado y gerente 00:34:08
Entonces me voy a empleado y le digo 00:34:12
Mira empleado, tú tienes public doble coste 00:34:15
Que me calcula cuánto costa este empleado 00:34:21
Como eres un empleado, return salario 00:34:27
Ahora, cuando voy a gerente 00:34:31
Gerente ya ha importado este método de aquí 00:34:40
Ya lo tiene 00:34:46
Pero lo que puedo hacer yo es 00:34:47
Oye 00:34:50
Hagamos una cosa interesante 00:34:51
Sobrescribamoslo 00:34:55
Entonces, cuando tú lo llamas 00:35:00
Sobre un empleado 00:35:05
Será esto, mas si lo llamas 00:35:06
Sobre un gerente 00:35:08
Será 00:35:09
Esto 00:35:10
Mi coste no es solo el salario 00:35:14
Es bonus más salario 00:35:21
Podría ser 00:35:22
Esto 00:35:27
Mi coste es el bonus sumado a 00:35:32
Lo que sea el coste 00:35:41
Porque pongamos que 00:35:43
Si su sueldo es 1000 pero a mi no me costa 1000 00:35:44
A mi como empresario 00:35:47
Me costa más de 1000 00:35:49
A mi me costa 1000 por 00:35:50
1.5 00:35:53
No lo sé 00:35:56
Esto preguntárselo a Foll 00:35:59
¿Vale? 00:36:00
¿Cuánto? 00:36:02
¿Hace falta poner el supercoste? 00:36:04
¿No podría poner más salario? 00:36:08
Sí, sí, sí 00:36:09
Lo que he hecho antes 00:36:10
Pero cuidado 00:36:12
Que si 00:36:13
Si este método de aquí 00:36:14
En vez de retorno salario 00:36:16
Hace 1400 cosas 00:36:17
Y calcula la nómina 00:36:19
Y le añade la cosa así 00:36:20
Pues ahora todo este código 00:36:22
Lo tienes que poner al otro lado 00:36:23
En vez de tú 00:36:24
Ya lo tienes 00:36:25
Le dices 00:36:26
Oye, mira, hazte los cálculos 00:36:27
Que hace que esta es materia de fall 00:36:29
Para saber cuánto cuesta un empleado 00:36:31
Y a eso le sumas el bonus 00:36:33
Más todos los cálculos 00:36:34
Sobre el bonus que se podrían hacer aquí 00:36:39
¿Vale? ¿Me entendéis lo que quiero decir? 00:36:41
O sea, si yo hago así 00:36:44
A mí me funciona porque 00:36:44
Esta es una extrema simplificación 00:36:47
Porque este método de aquí 00:36:49
Al fin y al cabo tiene solo salario 00:36:51
¿Vale? Entonces, ¿qué me importa a mí 00:36:52
Escribirlo otra vez aquí? 00:36:55
Pero vosotros habéis hecho ya la práctica 00:36:57
De calcular la nómina 00:37:00
Haréis 00:37:01
Y no es así 00:37:04
¿Vale? No se calcula así 00:37:05
Mil euros, va, mil, ahí, ya está 00:37:07
¿Vale? Entonces aquí 00:37:09
Hay un algoritmo que te calcula 00:37:11
Para seguir de su salario 00:37:13
El precio, cuánto paga la empresa 00:37:15
La prestación, no sé qué, no sé cuánto 00:37:17
¿Vale? Entonces si lo ha hecho ya todo aquí 00:37:20
Que simula en este fantástico 00:37:22
1.5 00:37:24
Pues entonces, aquí lo que puede hacer 00:37:25
Es simplemente utilizar eso 00:37:28
Vete a mi padre 00:37:30
Utiliza el coste de mi padre 00:37:32
Sacará lo que sea y luego le añado 00:37:33
El bonus actual, el coste aquí 00:37:36
¿Sí? 00:37:38
¿Se entiende un poco eso de sobre escribir? 00:37:41
Vale 00:37:44
Entonces, ahora si lo he hecho así 00:37:44
Desde aquí 00:37:47
En la versión 2 00:37:49
¿Vale? 00:37:51
En vez de hacer esto 00:37:52
Que hacía antes 00:37:55
Lo único que tengo que hacer es 00:37:57
Y además 00:37:59
La cosa bonita es que 00:38:09
Aquí si entra 00:38:11
¿Cómo se llama? 00:38:14
El concepto que 00:38:16
Java se da cuenta 00:38:18
Si tú eres un empleado 00:38:20
O tú eres un gerente 00:38:22
Es esta cosa de aquí 00:38:24
¿Dónde está? 00:38:26
Esto 00:38:29
¿Os acordáis? 00:38:30
Que cuando llamo un método 00:38:34
No obstante lo llame sobre personas, sobre alumnos, lo que me da la gana 00:38:36
Lo que voy a utilizar es la instancia 00:38:40
Y va a utilizar el método de esa instancia 00:38:43
Entonces, no obstante yo haya metido todo en un array de empleados 00:38:46
Esta cosa de aquí me funciona con el de empleados en empleados 00:38:51
Y con el de gerente en los gerentes 00:38:57
Lo que cuenta es la instancia que hay 00:38:59
Entonces, fijaos que 00:39:01
Con esta opción de aquí 00:39:03
El diseño 00:39:05
De mi programa 00:39:08
Se simplifica mucho 00:39:11
Tengo 00:39:13
Todo lo que tiene que ver 00:39:15
Con empleado en empleado 00:39:17
Entonces, como se calcula su coste, lo tengo en empleado 00:39:19
Como se calcula el coste del gerente 00:39:21
Lo tengo en gerente 00:39:23
Y aquí, desde fuera 00:39:24
Solo lo único que tengo que hacer 00:39:26
Es calcular su coste 00:39:28
Very nice 00:39:30
¿Sí? 00:39:34
Pero esto 00:39:39
Oficialmente todavía no lo hemos hecho 00:39:40
¿Veis? 00:39:43
Os lo estoy metiendo yo allí 00:39:45
De vez en cuando 00:39:47
Para que cuando luego lo haremos la próxima semana 00:39:48
Diréis, ah sí, pero esto lo hemos hecho 00:39:50
Ya lo hemos entendido 00:39:52
¿Vale? 00:39:53
Pero oficialmente que es esta cosa aquí 00:39:54
Y por qué funciona 00:39:57
No lo hemos todavía dicho 00:39:58
¿Sí? 00:39:59
Por lo tanto nosotros lo haríamos así 00:40:00
Todavía también se tiene el concepto 00:40:02
De que 00:40:09
Yo tengo la posibilidad de hacer las dos cosas 00:40:10
¿Vale? 00:40:13
Son decisiones de programación 00:40:14
Que hago yo 00:40:16
Entonces tendré que pensar 00:40:17
Cuál es la opción mejor 00:40:20
Y diseñar la cosa 00:40:21
Está claro que si yo estoy utilizando una clase empleado 00:40:23
Que la ha hecho otro 00:40:26
Departamento 00:40:27
Y el otro departamento esto no me lo ha puesto 00:40:30
Entonces 00:40:32
No puedo utilizar esto 00:40:34
Tengo que utilizar lo que tengo 00:40:36
Otro departamento 00:40:38
A mi me dará un interfaz 00:40:41
Me dará una idea de cual es la clase 00:40:42
Y los métodos que puedo utilizar 00:40:45
Si no hay un método así 00:40:46
No puedo utilizar 00:40:48
Puedo decir, si luego lo harán 00:40:49
Porque ellos están haciendo su trabajo 00:40:52
Tendrás que hacer una reunión con tu jefe 00:40:54
Jefe de proyecto, decirle 00:40:56
Mira, estaría bien esto 00:40:57
Y a lo mejor el jefe de proyecto decide cambiarlo 00:40:58
A lo mejor esta parte aquí de empleado 00:41:01
Es de un programa que ya está funcionando 00:41:03
Y que no se puede tocar 00:41:06
O es un programa del que no tenemos el código 00:41:07
Porque es de otra opción 00:41:09
Tenemos solo el class, no podemos modificarlo 00:41:11
¿Sí? 00:41:13
Entonces, todo puede ser 00:41:17
Si es todo mío, pues entonces estaría bien 00:41:19
Haberlo hecho así 00:41:22
¿Dudas? 00:41:23
Gracias. 00:41:30
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
11
Fecha:
24 de enero de 2023 - 14:14
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
41′ 36″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
347.99 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid