Clase 9-02-24 - 1 | Mediateca de EducaMadrid

Tengo la esta congelada, o a las manos. 00:00:00

Ahora, vale. 00:00:08

Vale, pues... 00:00:10

Este ejercicio está muy pautado en el sentido de que especifica exactamente 00:00:14

qué clases hay que hacer, qué métodos cada una, etc. 00:00:19

Está muy pautadito. 00:00:23

En general ya os he dicho muchas veces que precisamente la problemática no es esta, 00:00:25

Sino la anterior 00:00:29

Es tomar la decisión de que clases me interesan 00:00:30

Verás que si Daniel Gallego 00:00:33

Vale 00:00:35

Bueno pues entonces vamos a hacer las tres primeras 00:00:39

Por si alguien 00:00:41

Hay alguna cosa que le 00:00:42

Que le haya dejado medio atascado 00:00:44

Empleado está clara 00:00:46

Al empleado le caracteriza su nombre, su salario 00:00:48

Y una fecha de contratación 00:00:51

Pues hay poco que pensar en empleado 00:00:52

Entonces empleado 00:00:54

Habréis hecho algo 00:00:56

que me distraéis 00:00:58

algo como esto 00:01:01

una clase empleado 00:01:03

con sus tres atributos 00:01:04

aquí que es interesante incorporar 00:01:06

desde ya 00:01:08

pues efectivamente 00:01:09

hay propiedades 00:01:11

en muchísimas clases 00:01:13

que son fechas, que está claro, fechas de nacimiento 00:01:16

fecha de contrato, fecha de cierre 00:01:18

hay muchas propiedades que son fechas 00:01:20

entonces guardarlo en variable string 00:01:21

es un rollo para manejarlas 00:01:23

porque con las fechas a veces que se hace 00:01:26

Pues comparar si una fecha es posterior a otra 00:01:28

Comparar el tiempo que ha transcurrido 00:01:30

Entre una fecha y otra 00:01:32

Cuando has guardado las fechas en stream 00:01:33

Hacer esas funcionalidades se complica mucho 00:01:35

¿Cómo detectas tú que una fecha 00:01:37

Es por detrás de otra cuando lo has guardado 00:01:40

Como 9 de octubre de no sé qué 00:01:42

Es una locura 00:01:44

Entonces, por eso la 00:01:44

JDK, la máquina virtual 00:01:47

JRE, incorpora una clase 00:01:49

Para manejar fácilmente 00:01:52

Objetos fecha 00:01:54

No una, muchas 00:01:56

esta es la de toda la vida 00:01:58

la que está en el paquete java útil 00:02:00

pero hay muchas más 00:02:03

clases que sirven 00:02:06

para guardar fechas 00:02:07

y cuál es la ventaja de tener una fecha guardada 00:02:09

como objeto 00:02:12

y no como string 00:02:13

pues que esa clase date incorpora 00:02:14

ya un montón de métodos para hacer cosas 00:02:17

pues comparar dos objetos date a ver cuál es posterior a otro 00:02:19

obtener el tiempo pasado entre una fecha y otra 00:02:22

un montón de cosas 00:02:26

esa es la ventaja de guardar 00:02:26

una fecha 00:02:29

en un objeto date 00:02:32

en lugar de en un string 00:02:33

que puedo entonces operar fácilmente para hacer 00:02:35

cosas relacionadas con fechas 00:02:37

bueno, pues nada, aquí simplemente 00:02:39

mencionar eso y podemos 00:02:41

incorporar esta que es la de toda la vida 00:02:43

la más sencilla, pero hay muchas, mucho más actualizadas 00:02:45

que hacen más virguerías 00:02:48

pero eso es lo de siempre, que uno quiere una clase fecha 00:02:49

muy super guay para hacer cosas, pues se la 00:02:51

busca la documentación, ah mira esta que bien 00:02:53

que tiene unos métodos para hacer cosas estupendas 00:02:55

con la fecha, pues la planto y ya está 00:02:57

si ahora ya se trata de 00:02:59

buscar documentación para ver cómo funciona cada clase 00:03:00

y poco más 00:03:03

bueno, pues entonces, las tres propiedades 00:03:04

que habréis hecho son esas 00:03:07

y si seguimos las pautas habituales de programación 00:03:08

pues bueno, tres propiedades privadas 00:03:11

constructor, parámetros 00:03:13

sin parámetros, get y set 00:03:15

bueno, nunca está de más 00:03:17

como ya dijimos, hacer un toString 00:03:19

para que si uno 00:03:21

quiere mostrar por consola 00:03:23

este objeto, pues 00:03:24

en lugar de mostrarme el 00:03:26

toString de object que me hacía cosas tan raras 00:03:28

me muestre algo más bonito 00:03:30

y nunca hasta además tampoco hacer el 00:03:32

equals, lo que pasa es que aquí todavía no 00:03:34

incorporo, yo no lo he incorporado 00:03:36

porque bueno, esta aplicación 00:03:38

no lo va a utilizar y para qué aumentar 00:03:40

la complejidad, va a ser imprescindible cuando 00:03:42

lo trabajemos con colecciones, pero 00:03:44

ahora todavía no lo es 00:03:46

pues nada, habréis hecho empleado 00:03:49

y ya está, y en gerente pues tampoco 00:03:50

os habréis vuelto locos porque 00:03:52

Porque no había mucho que hacer. Gerente hereda de empleado, con lo cual tiene su nombre, su salario y su ficha de contratación, pero además los gerentes tienen un bonus. Bueno, pues ya está. Lo único que añade un gerente a un empleado normal es un bonus. 00:03:54

eso hace que el constructor 00:04:09

cambia, hay que hacerlo específicamente 00:04:11

porque ya sabéis que los constructores nos heredan 00:04:13

pues lo hacemos específicamente 00:04:15

además apoyándonos en el superior 00:04:17

con super, apoyándonos en el superior 00:04:19

hacemos además 00:04:21

unos imparámetros que siempre vienen muy bien 00:04:23

y como los get y set ya los 00:04:25

tenemos heredados de arriba aunque no los veamos 00:04:27

pues añadimos solo 00:04:29

el get y set específico de la 00:04:31

propiedad específica 00:04:33

y gerente pues por ahora se podría quedar así 00:04:34

ahora ya, la siguiente clase 00:04:37

pues venga, departamento 00:04:39

departamento hemos dicho que se caracteriza 00:04:41

por un nombre 00:04:44

y todos los empleados que tenga 00:04:45

pues ya está, un nombre y todos los empleados 00:04:47

que tenga 00:04:50

entonces por comodidad 00:04:50

y por evitar errores de ejecución 00:04:53

es relativo 00:04:55

se puede incorporar 00:05:00

la inicialización 00:05:01

de las propiedades que sean de tipo 00:05:04

colección de cosas, en este caso es un array 00:05:06

¿vale? pero más adelante pues será un conjunto 00:05:09

será una lista, será un mapa, será cualquier otra cosa que sea 00:05:12

colección de cosas, bueno pues 00:05:15

recordad, estoy repitiendo otra vez 00:05:18

cosas de siempre, si uno no la inicializa 00:05:21

y esto lo deja así vacío 00:05:24

esa propiedad cuando el objeto 00:05:27

se crea, se queda inicializada como null 00:05:30

¿verdad? como null, ¿vale? no pasa nada 00:05:33

se queda como null, pero cuidado 00:05:36

con los objetos null que hay por ahí 00:05:38

que si luego en el momento de usarlos 00:05:40

yo no los instancio 00:05:41

me va a dar el famoso 00:05:43

null pointer exception 00:05:46

me va a dar el famoso null pointer exception 00:05:47

entonces hay una diferencia 00:05:49

entre hacer esta inicialización y no hacerla 00:05:51

si yo la hago 00:05:54

inicializo ese array 00:05:55

a un array sin posiciones, vacío 00:05:57

porque todavía no hay empleados, pero ya no es null 00:06:00

ya no es null 00:06:02

es un array sin posiciones 00:06:03

y si yo hago empleados.led 00:06:05

me saldrá cero 00:06:07

porque no tiene posiciones 00:06:09

y en empleados.a empleados no lo puedo recorrer 00:06:10

porque es que no tiene posiciones 00:06:13

no se le puede recorrer, no se puede hacer nada 00:06:15

porque no tiene posiciones 00:06:16

pero al menos no es null 00:06:18

entonces al no ser null 00:06:20

si en algún sitio a alguien 00:06:23

se le ocurriera hacer 00:06:25

empleados.led 00:06:26

ya no le saldría null pointer exception 00:06:28

no cascaría la aplicación ni nada 00:06:30

simplemente le daría cero y ya está 00:06:32

pero si no lo hemos inicializado 00:06:34

y a alguien por ahí que nos usa 00:06:37

se le ocurre hacer empleados.length 00:06:38

para ver cuantos empleados tenemos 00:06:41

le va a salir null pointer exception 00:06:42

y ahí sí que va a cascar la aplicación 00:06:44

¿vale? 00:06:46

bueno, pues entonces 00:06:48

por eso no es mala práctica 00:06:49

las propiedades que sean 00:06:51

conjuntos de datos 00:06:54

como es el array 00:06:55

inicializarlas a vacío 00:06:57

sin posiciones, pero al menos ya no son null 00:07:00

lo que pasa es que no tienen posiciones 00:07:02

es decir, un departamento cuando se crea 00:07:03

por ahora no tiene empleados 00:07:06

bueno, en esta clase entonces 00:07:07

ya con estas dos propiedades privadas 00:07:10

pues lo de siempre, subconstructor 00:07:12

uno con parámetros, habitual 00:07:14

otro sin parámetros 00:07:16

los get y los set de las dos propiedades 00:07:18

y luego me decía el enunciado 00:07:22

haz dos métodos 00:07:25

uno para añadir un objeto empleado 00:07:26

a ese departamento 00:07:29

Y otro para devolver el sueldo que se les paga a todos los empleados. 00:07:31

Vale, vamos con el primero. 00:07:39

Añadir un empleado al departamento. 00:07:41

Bueno, pues nada, seleccionamos el nombre. 00:07:44

De nuevo, este objeto, ¿qué necesita para trabajar? 00:07:48

El nuevo empleado que le llega de fuera para meterlo en su array de arriba. 00:07:51

El nuevo empleado que le llega de fuera. 00:07:56

Luego necesitará ese objeto. 00:07:58

un nuevo empleado que me llega de fuera 00:08:01

para incorporarlo al array de arriba. 00:08:02

El array de arriba no hay que pasárselo 00:08:05

porque es el suyo propio, es el que aporta él. 00:08:07

El objeto departamento, cuando llame a este método, 00:08:10

cuando tengamos un departamento que llame a este método, 00:08:14

como por ejemplo en este main, 00:08:17

cuando tengamos un departamento que llama al método, 00:08:19

ese objeto departamento ya incluirá su array de empleados dentro 00:08:22

y por tanto no hay que pasárselo. 00:08:26

¿Verdad? Entonces este método recibe este objeto empleado e incorpora ese objeto empleado que yo le paso de fuera, aquí por ejemplo, que yo le paso de fuera, en este main que estoy haciendo en paralelo para verificar, pues este objeto empleado lo incorporará a la RAI de empleados de este departamento que he creado. 00:08:28

bueno, está claro, ¿no? 00:08:52

entonces, no va a devolver nada 00:08:55

porque el efecto del método 00:08:57

es simplemente modificar 00:08:59

una variable suya que tiene dentro 00:09:01

entonces ya el método tiene un efecto 00:09:03

que es dejar modificada 00:09:05

la propiedad empleados 00:09:07

del objeto que lo llame 00:09:09

entonces no hay ninguna información que devolver 00:09:10

ya el efecto queda reflejado ahí 00:09:13

bueno, pues entendido ya 00:09:15

los parámetros que necesita 00:09:17

lo que devuelve, etcétera 00:09:19

Pues ya es hacerlo de siempre, tendré que coger este array, empleados, extenderlo en una posición y ya está, en la posición en la que lo he extendido, guardar. 00:09:22

bueno pues es lo que hemos hecho aquí 00:09:34

lo extendemos en una posición 00:09:37

copiamos 00:09:39

las posiciones que tenía 00:09:42

y en la extendida que es esta 00:09:44

en la extendida guardamos el nuevo 00:09:46

y sobre escribimos 00:09:48

el viejo con el nuevo 00:09:50

pues ya está de empleado ya está 00:09:52

entonces pues si uno se va haciendo 00:09:53

un main en paralelo 00:09:56

para ver si los métodos que está haciendo funcionan bien 00:09:57

pues podría ya hacer 00:10:00

esto primero de aquí 00:10:02

¿No? 00:10:04

Creamos un objeto departamento 00:10:06

Le fijo el nombre 00:10:08

Le fijo el nombre 00:10:10

Y ahora ya le voy a añadir 00:10:12

Dos empleados 00:10:14

¿Vale? Bueno, dos empleados 00:10:15

Primero le voy a añadir 00:10:18

Un gerente 00:10:20

A ver, estoy haciendo un main 00:10:21

Para probar los métodos que he hecho solamente 00:10:26

Es un main que lo estoy haciendo en paralelo 00:10:28

Para probar que esos métodos que hago funcionan 00:10:29

¿Vale? 00:10:32

Entonces, vamos a ver si este adempleado de aquí funciona. 00:10:34

Entonces, este adempleado puede recibir cualquier cosa que sea de la clase empleado, cualquiera. 00:10:40

¿Y qué es de la clase empleado? 00:10:46

Los objetos de la propia clase empleado y los objetos de cualquier clase que lo herede. 00:10:48

Luego yo, adempleado, le puedo añadir objetos empleado y objetos gerente. 00:10:54

Es todo lo que le puedo añadir, empleados y gerentes, 00:10:58

porque como gerentes heredan de empleado 00:11:01

pues caen aquí, caben ahí también 00:11:03

en esa referencia E 00:11:05

caben objetos empleado 00:11:07

y objetos de cualquiera de las herederas 00:11:09

luego caben también 00:11:11

gerentes 00:11:13

bueno pues es lo que yo he probado aquí en el main 00:11:13

para ver si funciona, me da errores 00:11:16

pues he 00:11:19

agregado un gerente 00:11:20

y he agregado 00:11:22

un empleado y los dos los he podido 00:11:25

agregar mediante A de empleado 00:11:27

entonces la fecha de contratación 00:11:29

por comodidad 00:11:31

la he instanciado directamente así 00:11:33

con el constructor de date 00:11:35

por comodidad 00:11:36

la clase date, si la habéis indagado 00:11:38

y estudiado, pues a ver, podemos 00:11:41

ahora rápidamente si queréis hacer un objeto date 00:11:43

para una fecha específica, pasada por teclado 00:11:45

pero si tú instancias 00:11:47

una date con su constructor 00:11:49

sin parámetros, lo que te da es 00:11:51

un objeto date con la fecha de ese momento actual 00:11:53

el momento en el que se instanció 00:11:55

el objeto, entonces bueno 00:11:57

yo aquí para hacer la prueba 00:11:59

he creado un gerente, he creado 00:12:00

un empleado con fecha de contratación 00:12:03

la del instante actual, porque new date 00:12:04

te instancia un objeto date 00:12:07

¿con qué fecha? 00:12:09

con la fecha del momento, tiene el 00:12:10

reloj del sistema accesible obviamente 00:12:13

cualquier proceso 00:12:14

cualquier proceso que se ejecuta, entre ellos un proceso 00:12:16

de Java que se está ejecutando 00:12:18

tiene acceso al reloj del sistema 00:12:20

y el reloj del sistema te dice la fecha 00:12:22

bueno, pues new date 00:12:23

mira el reloj del sistema y te genera 00:12:26

un objeto date con la fecha actual 00:12:28

vale, entonces para hacer la prueba 00:12:30

pues ya está 00:12:33

pues venga, si ejecutamos esto 00:12:34

errores de ejecución efectivamente no me van a salir 00:12:39

luego bueno 00:12:41

tiene toda la pinta de que esto funciona 00:12:43

aunque 00:12:45

para verificar si los ha agregado 00:12:46

no estaría mal añadir en la clase 00:12:48

empleado, perdón 00:12:50

en la clase departamento 00:12:52

un método que me muestre sus empleados 00:12:53

para así ver los que tiene 00:12:56

que esto no tardamos nada en hacerlo 00:12:58

no estaría de más 00:13:00

mostrar los empleados que tiene un departamento 00:13:01

para ver si los ha añadido bien, etc 00:13:04

y esto sería simplemente 00:13:06

pues vamos a recorrer 00:13:09

el array de empleados 00:13:11

como es para consultar solo 00:13:12

vamos a usar un for each 00:13:15

para cada empleado 00:13:16

en el array 00:13:23

de empleados 00:13:27

vale, pues vamos a mostrar el nombre 00:13:28

.getNombre 00:13:31

bueno, esto mostraría 00:13:34

los empleados del 00:13:36

departamento, aquí de nuevo 00:13:37

esto ya es 00:13:40

costumbre, hábito 00:13:41

omitimos 00:13:43

el dis, no lo omitimos 00:13:46

en este caso de nuevo 00:13:47

da exactamente igual 00:13:49

si pongo dis, sabéis que se refiere 00:13:50

el objeto que llame al método, que esté 00:13:53

llamando al método en cada momento 00:13:55

lo que le estoy llamando, o su propiedad 00:13:57

de empleado. Pero es que como no hay más cosas 00:13:59

que se llaman empleado, si yo quito el disk 00:14:01

me referiría a ese array, no a más cosas. 00:14:03

Entonces, lo ponéis, 00:14:05

no lo ponéis, según os sea más cómodo 00:14:07

para entender lo que estáis haciendo. 00:14:09

Lo habitual es, pues, 00:14:11

no ponerlo. Si no hace falta, no ponedlo. Pero bueno. 00:14:13

Como veis aquí, bueno, 00:14:17

nada. Venga, pues vamos a probar 00:14:19

acá, vamos a volver a hacer este main, llamando 00:14:21

a mostrar empleados, a ver si los ha añadido de verdad. 00:14:23

no vaya a ser que no esté dando error de ejecución 00:14:25

pero no esté funcionando la aplicación 00:14:28

porque una cosa es dar error de ejecución 00:14:31

que ahí ya obviamente la hemos fastidiado 00:14:33

pero bueno, ahí ya sé que algo falla 00:14:36

entonces me pondría a buscar 00:14:38

y otra cosa es que no dé error de ejecución 00:14:39

pero no esté haciendo lo que tenga que hacer 00:14:41

eso es lo peligroso 00:14:43

porque yo estoy vendiendo una aplicación 00:14:44

que creo que funciona 00:14:46

pero hace otras cosas diferentes 00:14:47

para las que se concibió 00:14:49

Vamos a mirar a ver si este ha agregado 00:14:51

Los dos empleados Pepe y Pepe 00:14:55

Bueno, vamos a cambiarles 00:14:57

Que no se llamen igual 00:14:59

Porque 00:15:01

Bueno, pues sí 00:15:02

Ha de empleado, parece que funciona 00:15:07

Lo hemos hecho bien y ya está 00:15:10

Venga, pues vámonos a 00:15:11

Obtener el sueldo 00:15:14

que aquí 00:15:18

es donde hay una cosa curiosa 00:15:21

vamos a ver 00:15:24

de hecho esto 00:15:25

lo voy a 00:15:26

esto lo voy a borrar 00:15:28

y esto lo voy a 00:15:31

hacer así 00:15:35

vale 00:15:35

bueno pues que se os 00:15:37

puede haber ocurrido a vosotros 00:15:40

que es lo que habréis hecho supongo cuando habéis 00:15:42

arrancado get sueldo total del departamento 00:15:44

primero la pregunta que se hace uno de siempre es 00:15:46

para obtener el sueldo total 00:15:49

que paga ese departamento 00:15:51

a sus empleados 00:15:53

¿necesito alguna información externa desde fuera? 00:15:54

pues me pregunto 00:15:59

vamos a ver, ¿dónde está la información 00:16:00

del sueldo de los empleados? 00:16:01

la tienen los propios objetos 00:16:04

empleados dentro, la tienen dentro 00:16:05

¿y dónde están los 00:16:07

empleados del departamento? 00:16:09

los empleados del departamento están aquí 00:16:12

arriba, dentro de la propia 00:16:14

clase, entonces dentro 00:16:15

de la propia clase están los empleados 00:16:18

y a su vez los empleados tienen dentro 00:16:19

su sueldo, luego no 00:16:22

necesito pasarle al método 00:16:24

este 00:16:26

no necesito 00:16:26

¿dónde está el método? aquí 00:16:29

no necesito pasarle nada 00:16:31

no necesito pasarle nada ahí, porque el sueldo 00:16:32

de los empleados está dentro 00:16:36

del empleado 00:16:37

y el empleado está dentro 00:16:39

de la RAI de la clase departamento 00:16:41

luego ahí no hace falta pasarle nada 00:16:43

Vale, el método que tiene que hacer, pues sumar salarios y devolver el valor, los salarios como los hemos guardado como dable, pues se va de retorno dable, vale, y ahora ya es cuando entra un ratito en el que aquí ya sí que tenemos que hacer programación básica de toda la vida en este ratito, que es, yo tengo un montón de empleados y tengo que recorrerlos e ir sumando el sueldo de cada uno, pues eso es lo de siempre, pues una variable suma que inicializo a cero y ahora ya se pone a recorrer 00:16:45

los elementos 00:17:15

y en ese recorrido 00:17:16

va sumando cada vez 00:17:18

un nuevo salario 00:17:21

por lo de siempre 00:17:22

pues venga 00:17:24

nuestra variable suma que se inicializa a cero 00:17:25

que 00:17:28

sumando se incorpora a la suma 00:17:30

el sueldo de los empleados que están en la RAI 00:17:32

pues venga, vamos a recorrer la RAI de empleados 00:17:34

de nuevo lo estoy recorriendo 00:17:37

con un for each por vaguería de escribir 00:17:38

y porque solo estamos consultando 00:17:40

vale 00:17:44

Si estuviéramos haciendo, modificando valores, cambiando, entonces nos olvidamos porque es muy probable que obtengamos errores de concurrencia, etc. 00:17:44

Vale, pues, entonces, por cada empleado, entonces os podríais haber planteado aquí, a ver, esto fuera, ahí, esto podría tener sentido, ¿no? 00:17:55

es decir, vamos a ver 00:18:09

el problema que nos encontramos con cada empleado 00:18:11

del array es que por esto 00:18:14

por esto de la herencia 00:18:16

cada empleado 00:18:18

del array, cada E 00:18:20

cada empleado del array puede que sea 00:18:21

empleado o puede que sea gerente 00:18:24

no sabemos como se habrá instanciado 00:18:26

no sabemos 00:18:28

cada E del array se puede ver instanciado 00:18:29

como empleado o gerente, por ejemplo 00:18:32

en este main concreto por ejemplo 00:18:34

el que hicimos las pruebas 00:18:36

el primer elemento del array tiene un gerente 00:18:37

pero el segundo elemento del array 00:18:39

tiene un empleado 00:18:42

en este concreto en el que hicimos las pruebas 00:18:42

y en un departamento cualquiera 00:18:45

en un departamento cualquiera 00:18:48

en este array 00:18:50

ya sabemos que en cada posición 00:18:51

puede haber o un objeto 00:18:54

que se instanció como new gerente 00:18:55

o un objeto que se instanció como new empleado 00:18:57

cualquiera de los dos cabe en el array 00:18:59

pues entonces 00:19:01

cuando habéis hecho 00:19:03

este for each habéis dicho 00:19:06

pues vaya 00:19:07

como para cada E 00:19:09

como obtengo yo el sueldo 00:19:12

depende 00:19:14

si es un gerente el sueldo será 00:19:14

su salario más el bonos 00:19:17

pero si es un empleado normal 00:19:19

será su salario 00:19:22

solo, entonces no nos queda más remedio 00:19:24

que distinguir, a ver ese objeto 00:19:25

E que es, ese objeto E 00:19:27

como se instancia, a ver ese objeto E 00:19:29

que es, vale pues una vez 00:19:31

uno ha llegado a esa conclusión 00:19:33

de que lo que se sume 00:19:35

a la variable suma 00:19:37

depende de si es empleado a secas 00:19:38

o si es empleado 00:19:41

además gerente, 00:19:42

pues entonces ahí tendremos que hacer un if 00:19:45

para distinguir cómo se instanció ese objeto. 00:19:47

Bueno, pues una vez que me he llegado 00:19:50

a esa conclusión diréis, vale, 00:19:51

¿cómo puedo saber yo, 00:19:53

dado una instancia cualquiera, 00:19:54

si se instanció de una clase 00:19:57

o de otra? ¿Cómo puedo saberlo? 00:19:59

Con este operador 00:20:02

que vimos el otro día, ¿no? 00:20:03

Entonces, podríais haber construido algo así. 00:20:05

Si el objeto E, en el que estoy yo en ese momento del array, 00:20:07

se instanció como empleado, 00:20:10

entonces a la variable suma le aporta solo su salario. 00:20:14

Ya está, le aporta su salario. 00:20:18

¿Vale? Está claro. 00:20:20

Y si no, 00:20:21

si no, entonces sería que se instanció como gerente. 00:20:23

¿Vale? Porque en el array ese de empleados 00:20:27

solamente caben o empleados o gerentes, 00:20:29

no pueden caber más cosas. 00:20:31

porque está declarado como array de tipo empleado 00:20:32

y si no 00:20:35

pues entonces le sumo el salario 00:20:36

pero además le tengo que sumar el bonus 00:20:38

¿verdad? 00:20:41

le sumo el salario y además le tengo que sumar el bonus 00:20:43

y aquí es donde habréis encontrado 00:20:45

el problema, pues si uno más o menos 00:20:47

ha trabajado así 00:20:49

habréis encontrado el problema de 00:20:50

¡uh! el salario estupendo 00:20:52

pero el bonus 00:20:55

no puedo sacarlo de él 00:20:56

claro, ya lo sabemos, es con lo que hemos estado 00:20:58

trabajando estos días 00:21:01

el compilador 00:21:01

no mira como se instanció ese objeto 00:21:03

porque ni siquiera lo sabe 00:21:06

porque aquí todavía no hay ningún programa ejecutándose 00:21:07

aquí hay variables declaradas 00:21:10

y el compilador lo único que mira es 00:21:11

oye, perdona, que 00:21:14

está declarado como empleado 00:21:15

que luego tú cuando lo instancias metes un gerente 00:21:17

genial, puedes meter lo que te dé la gana 00:21:20

pero está declarado como empleado 00:21:21

y la clase empleado 00:21:24

si yo me voy a mirarla 00:21:25

lo siento mucho pero en la clase empleado no hay un get bonus 00:21:27

no lo hay, solo lo hay en la clase gerente 00:21:30

¿vale? así es como funciona 00:21:33

el compilador, como ya sabemos, lo hemos repetido 00:21:35

varias veces, él va mirando 00:21:37

si todo casa y cuadra según 00:21:39

lo que hay declarado y escrito 00:21:41

¿vale? pero eso ya sabemos 00:21:42

cómo solucionarlo, es decir, ya, pero es que yo sé 00:21:45

que se ha instanciado como 00:21:47

gerente, porque estoy en esta rama 00:21:49

no estoy en la rama de que se ha instanciado como empleado 00:21:50

sino en la otra, entonces como sé que 00:21:53

se ha instanciado como gerente, le hago 00:21:55

el casting y ya, si ya le he hecho 00:21:57

el casting, el compilador 00:21:59

entonces ya se va a mirar la clase gerente 00:22:01

y ahí sí que va a ver que hay un get bonus, entonces ya se callará 00:22:03

vale, pues le hacemos 00:22:05

el casting 00:22:07

vale, se lo vamos a poner a mano 00:22:08

para no tirar tanto de... 00:22:13

y entonces 00:22:17

si le hacemos el casting a 00:22:18

gerente 00:22:21

recordad que el casting es por entre paréntesis 00:22:24

el tipo al que yo hago el casting 00:22:27

pues si le hago el casting a gerente 00:22:29

todo este objeto ya 00:22:31

con el casting hecho 00:22:33

todo ese objeto con el casting hecho 00:22:34

ya, al ser de la clase gerente 00:22:37

el compilador dice, ah, fenomenal 00:22:39

esto es de la clase gerente 00:22:41

porque has hecho el casting, voy a mirar en la declaración de gerente 00:22:43

efectivamente en la declaración 00:22:45

de la clase gerente hay un 00:22:48

método getBonus 00:22:49

magnífico 00:22:51

vale, pues entonces 00:22:52

una vez que ya he terminado el for 00:22:55

he sumado todo, pues devuelvo la suma 00:22:57

y se acabó 00:23:00

bueno, le habéis sentido a este método, ¿no? 00:23:01

es una suma acumulativa 00:23:03

que recorre todo el array 00:23:05

y para cada elemento del array 00:23:06

ese empleado solo aporta su salario 00:23:08

no 00:23:11

con lo cual gerente, porque son dos alternativas 00:23:12

dos empleados, gerente, no caben más cosas en empleado 00:23:15

no caben más 00:23:17

pues entonces le sumo el salario más el bonus 00:23:17

para el cual he tenido que hacer el casting 00:23:21

para que el compilador me deje 00:23:22

¿vale? 00:23:24

Bueno, ya habéis sentido el método, ¿no? 00:23:27

Sí, sí, sí. 00:23:30

¿Vale? 00:23:32

Pero a esto que he hecho yo lo habéis sentido, ¿no? 00:23:32

Vale. 00:23:34

Bueno, vamos a ejecutarlo. 00:23:35

Vale. 00:23:37

Entonces, yo ahora voy a meter numeritos para que sea fácil. 00:23:40

Voy a meter un gerente que tiene sueldo 10 y bonus otros 10. 00:23:46

y luego un empleado 00:23:54

que tiene sueldo 10 00:23:56

con lo cual cuando yo llame al sueldo total 00:23:58

de departamento y lo muestre 00:24:00

me deberá salir 30 00:24:02

¿verdad? los 20 00:24:04

del PP1 y los 10 del este 00:24:06

30 me debería salir 00:24:08

vale 00:24:09

pues vamos a ejecutarlo 00:24:11

pues no me sale 30 00:24:14

me sale 20 00:24:18

da la sensación de que el bonus del gerente 00:24:19

no lo ha metido 00:24:22

Pues algo pasa 00:24:23

¿Vale? 00:24:28

Vale, entonces 00:24:35

Si lo habéis organizado de otra manera 00:24:37

A lo mejor no os habéis encontrado con esta situación 00:24:41

Pero yo la he provocado a propósito 00:24:43

La he provocado para que entendamos lo que ha pasado 00:24:45

La he provocado a propósito 00:24:48

¿Vale? Entonces 00:24:49

¿Qué ha pasado aquí? 00:24:51

Bueno, pues lo que ocurre es que cuando se instancia 00:24:53

un objeto gerente, fijaos lo que está ocurriendo. 00:24:55

Aquí en nuestro main hemos instanciado un objeto gerente. 00:25:01

Este, ¿vale? 00:25:05

Gerente, cuando se instanció, ¿vale? 00:25:08

Gerente se apoyó en el constructor del de arriba, empleado. 00:25:11

Se apoyó en el constructor del de arriba. 00:25:14

Vale, entonces, ¿qué hace en realidad InstanceOff? 00:25:17

¿Qué está haciendo el InstanceOff este de aquí? 00:25:20

Instance of funciona por dentro de tal manera que está mirando qué constructores se han usado. Me explico. Si yo instancio un objeto gerente con new gerente, ese objeto gerente en realidad pertenece tanto al tipo gerente como al empleado, a los dos. 00:25:23

a los dos 00:25:44

con lo cual el instance off 00:25:45

cuando se ha encontrado un gerente 00:25:48

este ya ha dado true 00:25:49

este ya ha dado true 00:25:51

entonces como este ya ha dado true no se ha ido al else 00:25:53

¿vale? 00:25:55

eso es lo que ha ocurrido 00:25:58

y se da en esta combinación 00:25:59

que yo he provocado a propósito 00:26:02

para que nos demos cuenta de eso 00:26:03

para que lo registremos 00:26:05

si tú tienes una referencia, tú tienes dos clases 00:26:06

animal y gato 00:26:09

¿vale? 00:26:12

y ahora instancia es gato, new gato 00:26:13

y ahora haces el instance of 00:26:15

de esa referencia, te va a dar true 00:26:18

tanto si lo haces para gato como para 00:26:19

animal, te va a dar true porque 00:26:22

pertenece a ambas en realidad 00:26:24

el instance of te detecta que pertenece a las dos 00:26:25

te va a dar true en ambas 00:26:28

sin embargo si lo has instanciado 00:26:30

como animal solamente, solo te va a dar true 00:26:32

en animal, en gato no 00:26:34

pero si lo has instanciado como la subclase 00:26:35

el instance of te va a dar true 00:26:37

en ambas, entonces eso 00:26:39

en función de cómo lo hayas programado tú 00:26:42

pues te puede dar situaciones 00:26:44

que en este caso 00:26:46

es fácil de detectar porque estamos haciendo esta prueba en concreto 00:26:48

pero entra una aplicación enorme 00:26:50

donde ese resultado luego se encadena 00:26:52

y se pasa a otro y luego a otro y luego a otro 00:26:54

vete a saber 00:26:56

cómo averiguas tú que el resultado final 00:26:57

¿por qué no es el que es? 00:27:00

bueno pues a lo mejor es que en algún 00:27:03

momento de tu cadena de miles de llamadas 00:27:04

se te ha colado algo de esto 00:27:07

y es 00:27:08

que cuando un objeto, un segundito, termino la frase 00:27:10

que cuando un objeto está instanciado 00:27:12

como una subclase 00:27:15

el instance of te da true 00:27:16

si lo pruebas para esa subclase 00:27:19

y para las superclases 00:27:21

o lo que es lo mismo, cualquier objeto 00:27:22

si le hacéis un instance of the object 00:27:24

va a dar true también 00:27:26

¿vale? entonces 00:27:27

esto simplemente si lo habéis 00:27:30

hecho de casualidad o como sea 00:27:32

en otro orden, pues no os habréis encontrado 00:27:34

con esto, imaginaos que yo lo he hecho al revés 00:27:36

y he dicho, si está instanciado como gerente 00:27:38

entonces hago lo de abajo 00:27:41

y si no está instanciado 00:27:44

como gerente, entonces hago esto 00:27:51

si yo lo he hecho así 00:27:53

ya está, esto ya va a estar perfecto 00:27:56

si está instanciado 00:27:57

como gerente, suma todo 00:27:59

y si es un empleado 00:28:01

suelto, este va a ser falso 00:28:04

obviamente, porque es de la super clase 00:28:05

Entonces si es un empleado suelto 00:28:07

Entonces ya 00:28:10

Si que se meterá aquí 00:28:11

Si lo habéis hecho en este orden 00:28:12

Esto ya si que va a funcionar 00:28:15

Vamos a comprobarlo 00:28:16

Y ahora me dices lo que 00:28:18

Vale 00:28:19

Entonces si yo ahora ejecuto esto 00:28:22

Pues este ya si 00:28:24

Este ya si, este ya me da 30 00:28:29

Vale 00:28:31

Este ya si 00:28:33

¿vale? 00:28:34

entonces hombre, pues 00:28:41

si uno 00:28:42

es consciente 00:28:45

de eso, pues mejor 00:28:47

para que no sea de casualidad 00:28:49

que lo ha hecho bien, sino que además sea consciente 00:28:51

no vaya a ser que en algún momento lo haga de otra manera 00:28:53

y les haga errores por ahí 00:28:55

¿vale? 00:28:56

entonces, ¿entendéis eso, no? 00:28:59

que si un objeto está 00:29:02

instanciado de una clase 00:29:03

y usáis instance of para algo 00:29:04

porque lo necesitáis 00:29:06

ese instance of va a dar true 00:29:07

tanto si lo probáis con esa clase 00:29:09

como cualquiera de las superclases 00:29:11

va a dar true en todas 00:29:13

es que ya no va a entrar en el safe 00:29:14

porque if, el safe 00:29:21

esa sentencia de decisión 00:29:23

si ya te ha entrado en una rama 00:29:26

ya no entran las otras, ya no las comprueba 00:29:27

sería true en ambas 00:29:29

pero es que a la segunda no se plantea entrar ya 00:29:31

son excluyentes 00:29:32

si no lo haces en un if-else-if 00:29:34

entonces sí, imagínate, haces 00:29:38

if este que es salario, y luego haces otra vez 00:29:39

y no sé qué, le sumas el bonus 00:29:42

entonces ya sí, pero porque lo hagas en ramas 00:29:43

separadas, entonces fuerzas a que compruebe todas las condiciones 00:29:46

no sé si me explico 00:29:48

claro, entonces sí, pero si lo haces 00:29:50

en un if-else-if, o te hace una, o te hace la otra 00:29:52

porque son excluyentes 00:29:54

¿vale? 00:29:55

entonces imagino que, bueno, habréis hecho algo así 00:29:57

o que otra cosa 00:30:00

a lo mejor os habéis planteado hacer cambiando el diseño 00:30:02

que podéis hacer lo que os dé la gana. 00:30:04

Pues os podéis haber empleado, o habéis planteado 00:30:06

justo el instance of, es un rollo, esto 00:30:08

tendrá que hacer un casting, pues os habéis planteado 00:30:10

hombre, voy a hacer un método en la clase 00:30:12

empleado, que me devuelva el sueldo total 00:30:14

y ya lo sobrescribo 00:30:16

en el gerente. 00:30:18

Entonces, se queda 00:30:20

esto más bonito. 00:30:22

¿No? Pero claro, tiene que tener uno 00:30:24

la opción de modificar las clases. 00:30:26

Si uno tiene la opción de modificar las clases, 00:30:28

pues se hace aquí su método 00:30:30

get sueldo total 00:30:32

¿vale? 00:30:43

entonces para empleado 00:30:45

el sueldo total de empleado 00:30:46

pues va a ser el salario 00:30:47

es que esto va a ser como el get en realidad 00:30:49

pero claro 00:30:51

lo tengo que poner para luego sobre escribirlo 00:30:54

en la otra 00:30:56

vale entonces este será 00:30:56

simplemente return para el empleado 00:31:00

normal, devolvemos el salario 00:31:01

y ya está, pero 00:31:04

lo podemos sobreescribir en gestor 00:31:05

perdón, en gerente 00:31:07

este mismo lo sobreescribimos en gerente 00:31:08

lo sobreescribimos 00:31:12

aquí 00:31:15

y aquí que me dé esto 00:31:16

y aquí 00:31:25

como es privada 00:31:26

si tuviera protected 00:31:27

podría haber accedido directamente 00:31:30

pero como no tengo protected sino privada 00:31:31

solo puedo acceder a salario 00:31:34

al estar escrito en la super clase 00:31:35

solo puedo acceder a salario con el get 00:31:37

a menos que le ponga el protected, repito 00:31:39

vale, pues ya está 00:31:42

con este 00:31:43

get sueldo total, este método 00:31:45

que nos hemos inventado aquí 00:31:47

porque hemos podido modificar las clases 00:31:49

pues 00:31:51

el método departamento 00:31:53

de get sueldo total de departamento 00:31:55

pues esta parte de aquí 00:31:57

en lugar de hacerla con este instant off 00:32:00

y todo este rollo 00:32:03

pues 00:32:03

quedaría más bonita 00:32:06

si ponemos 00:32:08

suma más igual 00:32:10

punto get sueldo total 00:32:12

y ahora ya gracias al 00:32:14

gracias al polimorfismo 00:32:18

cuando esto se ejecute 00:32:20

la máquina virtual dirá, a ver tú que eres 00:32:22

eres gerente 00:32:24

pues llamo a get sueldo total de gerente 00:32:26

perfecto, ¿qué eres empleado? 00:32:28

pues llamo a getSoldOtal 00:32:31

empleado 00:32:32

esta es la ventaja del polimorfismo 00:32:32

el getSoldOtal que se va a ejecutar 00:32:36

es el de gerente, es el de empleado 00:32:39

dependiendo de lo que sea este objeto 00:32:40

para nosotros en el momento de hacer la clase es que nos da igual 00:32:42

nos da lo mismo 00:32:44

cuidado siempre con las sobrescrituras 00:32:45

para que todo esto case y funcione 00:32:51

este método 00:32:52

tiene que estar sobrescribiendo 00:32:54

el de arriba 00:32:56

y sobreescribirlo significa que su cabecera sea idéntica 00:32:57

no me vaya a ver yo confundido 00:33:01

y la mejor manera de asegurarnos de que su cabecera es idéntica 00:33:02

y yo no me he confundido 00:33:06

es poner esta anotación 00:33:07

pero bueno, ya son cosas un poquito más 00:33:13

que podéis hasta olvidar como si no lo hubiera dicho 00:33:15

lo importante es que para que un método 00:33:18

esté sobreescribiendo y pisando el de arriba 00:33:21

la cabecera tiene que ser idéntica 00:33:23

vale 00:33:26

entonces esta anotación verifica 00:33:28

que la cabecera, que hay un método 00:33:33

arriba con una cabecera igual que esa 00:33:35

lo verifica, bueno pues entonces 00:33:36

ahora ya, hecho así este 00:33:39

con esta 00:33:41

variante, con este método 00:33:43

esto queda mejor, queda más bonito 00:33:44

queda más 00:33:47

y esto debería darme 30 otra vez 00:33:48

si lo hemos hecho bien 00:33:51

y efectivamente nos da 30 00:33:52

vale 00:33:54

Vale, a ver 00:33:55

Del resto de las clases 00:33:58

¿Habéis ido avanzando? 00:34:00

¿Estáis en ello? 00:34:04

¿Seguís por vuestra cuenta? 00:34:07

¿Otro rato? 00:34:09

¿Decís algo o no decís nada? 00:34:12

¿Que continúe yo? 00:34:16

De verdad, ¿eh? 00:34:19

¿Por qué lo tenemos que hacer siempre todos nosotras? 00:34:20

En fin 00:34:22

Bueno, vale 00:34:23

vale, vale, seguimos 00:34:24

si, si, si me parece bien 00:34:29

yo lo que no quiero es que 00:34:31

os olvidéis del cerebro 00:34:34

vuestro 00:34:36

venga, a ver que 00:34:36

a ver que cosas raras hay por aquí 00:34:45

venga, empleado y departamento 00:34:48

ya tenemos su arquitectura, es una jerarquía 00:34:52

con empleado 00:34:54

gerente y luego un departamento 00:34:57

esto pues en base de datos 00:34:59

hay unas tablas, tabla de departamento 00:35:01

tabla, no sé cómo mapeáis 00:35:02

los temas de herencia en modelo relacional 00:35:04

bueno, da igual 00:35:06

vale, pues venga 00:35:07

seguimos con clases 00:35:12

empresa, tiene nombre 00:35:13

y los departamentos, pues ya está 00:35:16

empresa 00:35:18

yo aquí, aunque esto es feo 00:35:20

para ahora subirlo al aula virtual 00:35:22

todos juntos, los que vayamos corrigiendo 00:35:24

en clase, pues en un único proyecto 00:35:26

ejercicio herencia estoy metiendo 00:35:28

en un paquete todas las clases enteras 00:35:30

pero normal es que se vayan separando 00:35:33

por modelo, patatín, pero bueno 00:35:34

entonces, vámonos 00:35:36

a empresa 00:35:40

ahí 00:35:42

empresa, pues venga, una clase nueva 00:35:48

Empresa no hereda de nadie 00:35:52

Luego hereda de object 00:35:56

Y empresa pues teníamos 00:35:57

Dicho sus propiedades, nombre 00:36:00

Y conjunto de departamentos 00:36:01

A ver 00:36:03

Prida 00:36:08

Ala 00:36:09

Los departamentos de la empresa 00:36:17

Departamentos 00:36:19

Lo mismo, vámonos ahorrando por si acaso Null Pointer Exception, poniendo aquí un array de tamaño 0. 00:36:21

A ver 00:36:36

Relax 00:36:39

Vale, pues nada 00:36:43

Constructor sin parámetros 00:36:51

Constructor con parámetros 00:36:53

Get y set 00:36:56

vale 00:37:06

una cosita, fijaos que aquí 00:37:17

hay un empleado 00:37:20

que hemos puesto el toString para decir 00:37:20

bueno, pues no está mal, por si alguna vez 00:37:23

queremos mostrar un empleado de golpe 00:37:26

así en el system.out.println 00:37:28

pues nos podríamos haber aprovechado 00:37:29

de él, que me he olvidado 00:37:32

en el método mostrar empleados 00:37:32

el método mostrar empleados 00:37:35

que está en departamento 00:37:37

yo he mostrado el nombre 00:37:40

porque me había olvidado 00:37:43

de que había hecho un toString en empleado 00:37:45

si no me olvido de que hay un toString en empleado 00:37:47

muestro el objeto empleado 00:37:49

directamente, muestro 00:37:51

recordáis que hacía System.out.println 00:37:53

este método, lo dijimos el otro día 00:37:56

pues coge lo que le pasemos aquí 00:37:57

y llama toString 00:37:59

Claro, pero si yo quiero mostrarlo todo 00:38:00

Bueno ya, a ver, depende de lo que quiera hacer 00:38:06

Pero me refiero que 00:38:09

Gracias a que tenemos un toString, este método 00:38:10

Te lo puede mostrar todo 00:38:12

¿No? Entonces si volvemos a hacer este main 00:38:14

Pues mira, aquí tenemos 00:38:18

Este es el toString tan estupendo que habíamos hecho 00:38:21

Tu nombre, tu contrato 00:38:23

Tu fecha, efectivamente 9 de febrero 00:38:25

Cuando lo instanciamos a las 13 y 26 00:38:27

¿Vale? 00:38:29

Entonces si no tuviéramos el toString 00:38:31

Aquí nos saldría una cosa muy rara 00:38:33

Que es el toString de object 00:38:35

Pero como tenemos nuestro toString 00:38:36

Que este toString no nos gusta 00:38:39

Porque en empleado 00:38:41

Porque cuando me muestra el empleado 00:38:43

Quiero que me muestre, no quiero que me muestre la fecha 00:38:44

O quiero que me lo muestre de otra manera 00:38:48

O no quiero que me muestre esto de aquí 00:38:49

Porque es muy feo 00:38:51

Pues ya lo toqueteo y lo modifico 00:38:52

Oye 00:38:55

¡Hala! Así más bonito 00:38:55

Por ejemplo 00:39:01

¿No? 00:39:02

Toqueteo el toString para adaptarlo a lo que yo quiero 00:39:05

Ahora ya, ¡hala! Ya los tengo 00:39:07

Salario, fecha, patatín 00:39:12

¿Vale? Entonces el toString es cómodo en eso 00:39:14

Porque si queremos pasar 00:39:19

Al system.out.println para mostrar un objeto 00:39:21

pues ya no tengo que preocuparme 00:39:24

yo de ahí construir la cadena que quiero 00:39:26

con los get 00:39:28

yo le paso el objeto 00:39:29

y ya en el toString se extrae 00:39:31

la información que yo quiera 00:39:34

bueno 00:39:35

pero estábamos ahora con la empresa 00:39:37

la empresa 00:39:40

tiene sus get, sus set y constructores 00:39:42

que ya los tengo hechos 00:39:44

y le podríamos poner también 00:39:45

un toString si es que vamos a listar empresas 00:39:48

pero bueno 00:39:50

Andoni 00:39:51

Cállate 00:39:54

Vale, ¿qué métodos tiene que tener la clase empresa? 00:39:55

Pues nada 00:40:03

Calcular todo lo que paga la empresa 00:40:03

Todo el mundo 00:40:06

Todo lo que paga 00:40:07

Pues bueno 00:40:08

Calcular todo lo que paga 00:40:11

Va a ser una suma de salarios 00:40:14

Luego un double 00:40:18

Pues get 00:40:19

Sueldo total 00:40:21

empresa. 00:40:23

Sueldo total de la empresa. 00:40:26

Lo de siempre. 00:40:28

¿Necesitamos pasar alguna información desde fuera? 00:40:29

No. 00:40:31

Porque lo que paga la empresa, 00:40:32

¿dónde está recogido? 00:40:34

Pues está recogido dentro de los sueldos 00:40:37

de los empleados. 00:40:39

¿Y los empleados dónde están? 00:40:40

Dentro de los departamentos. 00:40:42

Luego, dentro de este array, 00:40:44

dentro de ese array, 00:40:46

está toda la información que necesito. 00:40:48

Dentro de ese array están los empleados. 00:40:51

Perdón, dentro de esa raíz están los departamentos 00:40:52

Y dentro de cada departamento 00:40:54

Están los empleados 00:40:56

Y dentro de los empleados está el sueldo 00:40:57

Luego lo tengo todo ahí, no hay que pasarle nada 00:40:59

Fuera 00:41:02

Ala 00:41:02

Pues 00:41:11

Tendremos lo de siempre 00:41:15

Una suma de sueldos 00:41:17

y ahora que hay que recorrer 00:41:19

pues hay que recorrer mi array de departamentos 00:41:24

porque ahí es donde están 00:41:26

los sueldos, departamento 00:41:27

por cada departamento de 00:41:29

y ahora como 00:41:31

tenemos la suerte 00:41:36

estupenda de que en departamento teníamos 00:41:38

un método que me saca 00:41:40

todo lo que paga ese departamento 00:41:42

no tengo que a su vez 00:41:43

hacer un for aquí anidado 00:41:45

para dentro del departamento recorrer los empleados 00:41:47

y sumar, no tengo que hacerlo 00:41:49

porque tengo un método 00:41:51

estupendo 00:41:53

en departamento 00:41:55

que me devuelve el sueldo total 00:41:56

entonces, este sueldo 00:41:59

perdón, este método ya dentro 00:42:03

de él, a su vez, hace un for 00:42:07

que recorre los empleados del 00:42:09

objeto de, los va sumando 00:42:11

me lo devuelve, pues eso yo ahora 00:42:13

lo sumo a este y así paso 00:42:15

al siguiente departamento, etc 00:42:17

el objeto es cada uno 00:42:19

de los departamentos 00:42:25

de mi array de departamentos 00:42:27

es como llamarlo yo dentro del foricha 00:42:29

bueno, pues ya está 00:42:31

este ya estaría 00:42:35

se apoyan unos sobre otros 00:42:39

y aquí devolveríamos 00:42:40

Este 00:42:44

Y se acabó 00:42:47

Que es sueldal de la empresa 00:42:49

Pues ya está 00:42:51

Sumamos los sueldos de todos los departamentos 00:42:52

Andoni 00:42:55

A la siguiente te muevo aquí delante 00:42:59

Bueno 00:43:14

Vale, vamos a hacerle rápidamente un añadir departamento a empresa, aunque no lo tenga, para luego en los main probarlo rápidamente. 00:43:14

Porque yo en este main de aquí, como no tenía añadir departamento, os dije, le metéis cuatro departamentos a tiro fijo. 00:43:24

Pero bueno, podemos hacer esta aplicación, se puede hacer más general, si le metemos un método añadir departamento a la empresa. 00:43:30

que va a ser como añadir empleado al departamento 00:43:39

entonces aquí 00:43:41

estamos espabilados y copiamos 00:43:42

y pegamos este y lo modificamos 00:43:45

nos ahorramos un montón de trabajo 00:43:47

copio este de añadir empleado 00:43:48

a departamento a la empresa 00:43:51

copio este 00:43:53

y cambio 00:43:55

al departamento 00:43:59

que tenemos que añadir aquí 00:44:04

Un departamento, un departamento de, vale, ahora, departamento es el tipo que sustituye a empleado, vale, 00:44:07

y ahora a empleados lo sustituye departamentos, departamentos, lo demás es todo igual, a empleados lo sustituye departamentos, este, este, este y este es D, el parámetro D. 00:44:33

bueno, he hecho un añadir departamento rápido 00:44:58

para luego cuando en el main 00:45:01

hagamos la prueba, pues podré añadir 00:45:03

departamento según nos vaya dando la gana 00:45:05

una empresa, pero es lo mismo 00:45:07

de siempre, cojo la raíz de departamento 00:45:09

lo extiendo en una posición 00:45:11

copio el viejo 00:45:12

en el nuevo, en la posición extendida 00:45:15

del nuevo, paso el 00:45:17

de y sobre escribo 00:45:19

añadir departamento 00:45:21

por comodidad solamente 00:45:22

vale, la empresa no tiene más métodos 00:45:25

bueno, ahora que nos dicen por aquí 00:45:26

pues la empresa 00:45:29

ha decidido que 00:45:31

empieza a contratar temporales 00:45:32

porque le viene bien 00:45:35

pues bueno, entonces esta aplicación 00:45:37

ahora tiene que escalarse, tiene que mantenerse 00:45:39

tiene que ampliarse para poder tener en cuenta 00:45:41

empleados temporales 00:45:43

pues entonces 00:45:44

si la hemos diseñado bien 00:45:46

esta 00:45:48

ampliación será sencilla 00:45:51

si la hemos diseñado mal 00:45:53

esta ampliación será un bipostio, la tiraremos a la basura 00:45:55

y el que la hizo pues le echaremos 00:45:57

entonces, la hemos diseñado 00:45:58

bien porque ya en su momento 00:46:01

decidimos trabajar 00:46:03

por separado con empleados y gerentes 00:46:05

y hacer una relación de herencia entre ellos 00:46:07

si hubiéramos decidido un empleado 00:46:08

solamente una clase empleado y en esa clase 00:46:11

empleado tener un bonus que a veces lo tenemos en cuenta 00:46:13

y a veces no 00:46:15

entonces ya empezaría a quedar feo 00:46:16

porque entonces le tendría que meter otro parámetro para el temporal 00:46:18

pero ya se queda una clase con mil parámetros 00:46:21

pero que algunos solo afectan a un otro 00:46:23

a otros, no, eso ya empieza 00:46:25

los parches empiezan ahí 00:46:27

a dar guerra y se lían 00:46:29

pero hemos tenido la suerte que hemos hecho de partida 00:46:31

un buen diseño, que es no 00:46:33

una clase de empleados solo con lo común 00:46:35

a todos los empleados 00:46:37

y ahora ya si vienen más tipos 00:46:38

ya los iré incorporando 00:46:41

de partida había un gerente, vale 00:46:42

pero es que ahora han llegado los temporales 00:46:44

no pasa nada, me hago yo mi clase temporal 00:46:46

y la heredo de la otra 00:46:48

pues maravilloso 00:46:51

Es más fácil ampliarlo ahora 00:46:52

Porque el diseño inicial era bueno 00:46:54

Pues venga, vamos a hacernos nuestra clase 00:46:56

Empleado temporal 00:46:58

Hay que ver que a gusto 00:46:59

Me voy a quedar ahora 00:47:08

No me lo voy a creer 00:47:09

Vale, empleado temporal 00:47:12

Es un empleado más de la empresa 00:47:16

Os espera Estefano aquí el lunes 00:47:18

bueno 00:47:20

empleado temporal 00:47:27

afortunadamente tenemos ese buen diseño 00:47:29

una clase empleado ya hecha 00:47:31

pues ala, magnífico, empleado temporal 00:47:33

hereda de empleado 00:47:35

muy bien 00:47:37

entonces ya no tengo que ponerle 00:47:38

ni el nombre, ni el salario 00:47:42

ni la fecha de contratación, no tengo que ponérsela 00:47:43

es un empleado como todos, eso ya lo tiene 00:47:46

Lo único que añade es 00:47:48

El pobre, pues una fecha de fin 00:47:50

Es lo único que añade 00:47:52

¿Verdad? 00:47:53

Sí 00:47:57

El temporal añade eso 00:47:57

Bueno, pues nada, ponemos lo que añade 00:48:00

Ya está 00:48:02

Entonces 00:48:02

Añade una fecha de fin 00:48:05

Eh 00:48:07

Fin 00:48:09

Contrato 00:48:15

añade esta fecha 00:48:17

y seleccionamos la clase date 00:48:23

porque es la que le pega 00:48:29

pues nada 00:48:31

lo demás ya es 00:48:32

le damos a la manivela 00:48:33

para constructores get y set 00:48:35

pero le damos a la manivela con criterio 00:48:37

si no es lo que estamos haciendo 00:48:39

pues le damos ya 00:48:40

a esto 00:48:47

el get y el set 00:48:48

y ahora 00:48:58

gracias a que hicimos este diseño 00:49:01

con herencia 00:49:04

mi aplicación principal 00:49:05

que hace las cosas, que ahora mismo era un main 00:49:07

con tres cosas para probar, 00:49:09

pero que en condiciones normales 00:49:11

será una aplicación con una interfaz gráfica 00:49:13

y la leche. 00:49:15

Pues gracias a que ya iniciamos 00:49:16

un diseño con herencia, 00:49:18

mi aplicación principal 00:49:20

no tiene que cambiar de principio a fin, 00:49:22

porque mi aplicación principal decía, 00:49:24

oye, mis datos están en, 00:49:26

perdón, 00:49:30

mi aplicación principal decía, 00:49:31

mi departamento tiene empleados 00:49:34

que son del tipo empleado. 00:49:36

Digo, genial, 00:49:37

no tienes que cambiar departamento para nada, tienes que cambiarlo 00:49:38

los empleados temporales que han llegado 00:49:40

van a caer aquí también 00:49:42

sin ningún problema, van a caer aquí también 00:49:44

no tienes que tocar departamento 00:49:46

pero si hubieras hecho otro diseño 00:49:48

en el cual no habría herencia 00:49:50

pues habría que meterse en departamento 00:49:52

hacerle aquí otro array 00:49:54

para meter sus temporales 00:49:56

porque no cabría en el array de arriba, porque el de arriba 00:49:58

está pensado para los que fueran 00:50:00

y entonces eso ya sería una locura 00:50:02

¿vale? pues como no 00:50:04

como está incorporada la herencia 00:50:06

el departamento ni se entera 00:50:08

que me has metido empleados temporales 00:50:10

a mi que más me da, a mi en mi array cae lo que 00:50:12

quieras, siempre y cuando herede 00:50:14

¿vale? siempre y cuando herede 00:50:16

luego 00:50:18

la herencia tiene una motivación 00:50:20

y hacer una 00:50:23

aplicación sin herencia 00:50:26

es inabordable 00:50:28

no tiene ningún sentido 00:50:31

bueno pues entonces 00:50:32

ahora, nuestra 00:50:36

la clase temporal esta, ¿qué tenía que hacer? 00:50:37

la clase temporal 00:50:42

empleado, añada 00:50:43

fin de contrato, constructores 00:50:46

pues ya está, ya lo hemos hecho 00:50:48

ya está, ya se ha acabado 00:50:49

vale, pues vamos a hacer ahora un main nosotros 00:50:51

haciendo estas cosas 00:50:53

creamos un objeto empresa 00:50:55

en lugar de con cuatro departamentos 00:50:57

bueno, sí, con cuatro se los añadimos con ad 00:50:59

pues venga, vamos a hacernos un main 00:51:01

vale 00:51:03

venga, este main 00:51:06

yo hice esto para las pruebas 00:51:09

lo voy a dejar 00:51:12

comentado aquí 00:51:14

todo esto que hice para las pruebas 00:51:15

de los métodos anteriores 00:51:18

lo voy a dejar 00:51:19

comentado aquí 00:51:21

vale 00:51:23

voy a incorporar a mi proyecto 00:51:25

este 00:51:28

el jar ese 00:51:28

para leer por teclado 00:51:31

así rápidamente 00:51:34

meto en el classpad 00:51:36

un jar externo que tengo en el escritorio 00:51:40

ahí 00:51:42

vale 00:51:44

y me acuerdo de no tener el módule info 00:51:48

porque como tenga el módule info 00:51:50

no puedo agregarlo al classpad 00:51:52

de esta manera, pero eso ya son cosas que exceden 00:51:54

ahora mismo de nuestras 00:51:57

de nuestra 00:51:59

De nuestros conocimientos 00:52:00

Así que por ahora lo único que digo es 00:52:03

Cuidado cuando añadáis hard no tengáis un módulo info por ahí 00:52:05

Por si acaso 00:52:07

Vale, pues venga 00:52:09

Ahora vamos a hacer nuestro main 00:52:11

Que es crear un objeto empresa 00:52:13

Pues venga, vamos a crear una empresa 00:52:14

Esta es mi empresa 00:52:16

Esta empresa 00:52:19

Venga, vamos a hacerlo tan bonito 00:52:30

como para meter el nombre de la empresa 00:52:32

por teclado. 00:52:34

Nombre empresa. 00:52:38

Nombre empresa. 00:52:42

Pues bueno, nombre empresa. 00:52:43

Este. 00:52:47

Ya está. 00:52:48

¡Hala! 00:52:51

Ya tenemos una empresa. 00:52:51

Ahí con su nombrecito. 00:52:54

Bueno, no, no la tengo. 00:52:57

Es que me emperro. 00:52:58

No tengo constructor solo con el nombre. 00:52:58

Entonces la tengo que crear sin parámetros 00:53:00

Y ahora ya hacerle el set 00:53:02

Empresa.set 00:53:03

Nombre 00:53:07

Y ahora ya sí que leo el nombre 00:53:08

¡Hala! Tenemos una empresa con un nombre que me han dado 00:53:11

La aplicación ha arrancado 00:53:18

Mi empresa se llama 00:53:20

Vale, pues ya está 00:53:21

¿Qué más cosas me dicen que haga mi aplicación? 00:53:23

Ya hemos hecho esta primera parte 00:53:27

Aquí me dice con 4 departamentos 00:53:28

Por ahora sin empleados 00:53:30

Venga vamos a meterle 4 departamentos 00:53:31

Se los voy a meter con el método 00:53:33

AddDepartamento que hice en empresa 00:53:35

Que es muy cómodo 00:53:37

Por ahora sin empleados 00:53:39

Pues 00:53:40

Como tengo el constructor 00:53:41

El problema es que 00:53:46

En departamento tengo un constructor 00:53:48

Sin parámetros 00:53:50

Y otro con parámetros 00:53:53

Que me obliga a meter el array 00:53:54

Y yo no quiero 00:53:56

Entonces aquí es bastante interesante 00:53:57

Hacer un constructor 00:53:59

Solo con el nombre 00:54:01

Es bastante interesante 00:54:02

Para ahorrarnos líneas luego en el main 00:54:04

Vamos a hacer un constructor 00:54:06

Para hacer un departamento 00:54:09

Solo con el nombre 00:54:11

Sí, pero es que como lo quiero 00:54:12

Pasar directamente 00:54:18

Luego el new departamento 00:54:20

Al método add 00:54:22

Pues en el momento en el que se lo paso 00:54:23

a las departamento quiero hacer ya el new 00:54:26

ahora lo vemos 00:54:28

entonces me ahorro así una línea 00:54:30

entonces este dis.nombre 00:54:32

que lo que dices tú 00:54:35

implica que yo cree la referencia antes 00:54:37

y luego ya se la pase al método 00:54:39

entonces la quiero directamente pasar 00:54:40

dis.nombre igual a nombre 00:54:42

venga 00:54:44

me hago un constructor que me va a crear 00:54:47

como lo tengo aquí inicializado 00:54:49

me va a crear el array de empleados 00:54:50

lo va a inicializar vacío, sin nada 00:54:53

Y al nombre le va a dar un valor 00:54:55

Vale, bueno, pues para qué he hecho este constructor 00:54:56

Pues porque soy muy vaga 00:55:00

Entonces yo ahora quiero hacer 00:55:01

A empresa, vamos a añadirle un departamento 00:55:02

Y le voy a añadir un departamento 00:55:05

Que voy a crear en este momento 00:55:08

Departamento 00:55:09

Pues personal 00:55:10

Ala, ya está 00:55:13

Ya tengo un departamento ahí creado 00:55:15

Porque si no tendría que crearlo antes 00:55:17

Con el set y ahora pasárselo aquí dentro 00:55:21

Venga 00:55:22

Y voy a, como me dice enunciado 00:55:26

Que le haga cuatro, pues le voy a hacer cuatro 00:55:28

Departamento personal 00:55:30

Departamento informática 00:55:37

Departamento sanitario 00:55:40

Departamento 00:55:46

Educación física 00:55:49

Ya tenemos una empresa 00:55:53

Con cuatro departamentos 00:55:59

Por ahora ninguno de ellos tiene empleados 00:56:00

Ninguno de ellos tiene empleados 00:56:05

Y ahora 00:56:09

¿Qué más me dicen que haga por aquí? 00:56:10

Pues ahora ya la aplicación de gestión 00:56:13

Te tiene que permitir 00:56:15

Meterle empleados al departamento 00:56:16

Mostrar salario de la empresa 00:56:19

Y mostrar departamento que más salario paga 00:56:22

Pues ahora ya sí que sí 00:56:24

Tengo que hacer un menú 00:56:29

Y esto pues siempre lo hacemos de esta manera 00:56:30

Incorporar un empleado 00:56:32

y este menú, esta aplicación 00:56:49

ya podría hacerse enorme, con mil 00:56:52

funcionalidades 00:56:53

mostrar sueldo del 00:56:54

empleado dado su nombre 00:56:58

dado dos nombres, pues 00:56:59

dado un nombre, decir si es gerente o no lo es 00:57:01

o sea, esta aplicación ya podría incorporarse 00:57:04

millones de funcionalidades para hacer cosas 00:57:06

con estos datos, que son datos sencillos 00:57:07

una empresa que tiene departamentos 00:57:10

y un departamento que tiene empleados 00:57:11

pues con ese modelo de datos bien hecho 00:57:13

ahora ya la aplicación puede gestionar 00:57:16

de todo lo que necesites 00:57:17

pues dados dos empleados 00:57:19

ver cuál de ellos se incorporó antes 00:57:22

mirando la fecha 00:57:24

de todo, cualquier cosa que se nos ocurra 00:57:26

se podría incorporar en este menú 00:57:28

cualquier cosa que se nos ocurra 00:57:29

se podría incorporar 00:57:31

mostrar, esto es mostrar 00:57:33

el salario 00:57:35

el sueldo que paga la empresa 00:57:36

Y ahora aquí 00:57:40

Pues 00:57:54

Esta va para hacer un máximo 00:57:55

Que es el departamento 00:58:00

Que más salario paga 00:58:02

Pues para empezar a quitarle empleados 00:58:03

O para lo que sea 00:58:08

y ahora la opción de salir 00:58:09

por si uno quiere ampliarlo y hacer aquí ya 00:58:22

tropecientas mil gestiones 00:58:25

que se pueden hacer tropecientas mil 00:58:26

pues la ponemos en cero 00:58:28

y esta ya es la historia de siempre 00:58:29

esta es la opción en la que vamos a guardar 00:58:35

el menú 00:58:38

y ahora 00:58:39

la opción la leemos con 00:58:42

leer entero de aquí 00:58:44

vale 00:58:46

y ahora ya lo de siempre 00:58:49

Vale, vamos a poner todos los casos, el 1, el 2, el 3 y el 0, el 0 será salir. 00:59:05

Y el default será opción incorrecta. 00:59:35

Y aquí acaba el while y el while será quédate en este bucle una y otra vez, una y otra vez, 00:59:39

mientras la opción que se haya introducido sea diferente de la correspondiente a salir 00:59:59

que es la c. 01:00:03

Pues ya, la estructura ya está. 01:00:06

Ahora es, ¿qué hacemos en cada caso? 01:00:08

Añadir un nuevo 01:00:12

departamento a la empresa. 01:00:14

La empresa es en... 01:00:16

No, perdón. Añadir 01:00:18

un nuevo empleado al departamento. ¿Verdad? 01:00:19

Incorporar empleado al departamento. 01:00:21

Entonces, aquí hay que pedir un montón de cosas. 01:00:24

Hay que pedir, ¿vale? ¿A qué 01:00:26

departamento? ¿El departamento por qué 01:00:27

se caracteriza por el nombre? 01:00:29

Pues habrá que decir, primero 01:00:31

qué departamento quieres 01:00:32

para meterlo en él, en su array 01:00:34

y luego qué tipo de empleado 01:00:36

porque en función de si es gerente, empleado normal o temporal 01:00:38

el new que hay que hacer es diferente 01:00:41

¿no? entonces habrá que hacer 01:00:42

dos preguntas 01:00:45

¿vale? habrá que hacer dos preguntas 01:00:45

bueno, varias 01:00:48

entonces, pero primero es 01:00:51

¿a qué departamento? para que este main 01:00:52

pueda trabajar 01:00:54

entonces, bueno, aunque se nos alargue 01:00:55

un poquito, un poquito el este 01:00:58

no vamos a estar todo el rato tirando de métodos 01:01:00

métodos, vamos a escribirlo aquí 01:01:03

primero le decimos al usuario 01:01:04

a ver, vale, quieres que te incorpore un empleado 01:01:07

pues 01:01:09

nombre del departamento al que lo vas a incorporar 01:01:10

no hay otra 01:01:13

dime el nombre 01:01:14

y entonces yo, pues decido 01:01:18

que te incorporo al empleado de ese departamento 01:01:20

dime el nombre 01:01:22

vale, pues entonces, el nombre 01:01:23

lo vamos a dejar aquí guardadito 01:01:26

para luego 01:01:28

usarlo 01:01:29

para instanciar el objeto departamento 01:01:31

añadir. El nombre lo dejamos 01:01:33

aquí guardadito. 01:01:35

¡Hala! 01:01:42

¿Pero qué más necesitamos 01:01:43

para 01:01:45

añadir el empleado? 01:01:46

Pues los datos del empleado. 01:01:52

¿Ya tenemos a qué departamento va? 01:01:53

Muy bien. 01:01:55

¿Ya tenemos a qué departamento? Y tenemos dentro de 01:01:56

departamento, una de empleado, para añadir 01:01:59

ese empleado en concreto. 01:02:01

Pero hay que crear el empleado. 01:02:03

Pues es que tenemos tres tipos 01:02:05

de empleados. Habrá que decir primero 01:02:07

¿qué empleado quieres? 01:02:09

Bueno, los datos comunes 01:02:12

los podemos pedir antes de preguntar. 01:02:13

Los comunes son nombre, salario 01:02:15

y fecha de inicio. Pues podemos 01:02:17

pedirle ya esos 01:02:19

tres datos. 01:02:20

Vamos a pedirle esos 01:02:24

tres datos. 01:02:25

nombre del empleado 01:02:25

y ahora el nombre del empleado 01:02:29

va aquí 01:02:35

claro, pero hace empleado 01:02:36

necesita ya tener 01:02:45

construido el objeto 01:02:47

entonces previamente pido los datos para construirlo 01:02:48

vale, entonces nombre del empleado 01:02:51

¿Qué más datos comunes tendrían todos? 01:02:55

El salario 01:02:57

Pues el salario 01:02:58

¿Perdón? 01:03:00

Ahora, no lo he pedido todavía 01:03:07

Ahora lo leemos 01:03:08

Ahora lo leemos 01:03:11

Vale, entonces, nombre del empleado 01:03:12

Aquí, nombre del empleado 01:03:16

Sueldo 01:03:17

Pues esto se va a guardar en un dabble 01:03:18

Un dabble, así, un dabble, lo dejo ahí guardadito, leer, decimal, creo que se llamaba el método. 01:03:25

Lo dejamos ahí guardadito, tenemos ya el nombre y el sueldo para instanciarlo cuando toque. 01:03:39

Pero había otro dato común que tienen todos los empleados y que necesitamos, que es la fecha. 01:03:45

aquí es donde nos toca 01:03:50

indagar y buscar en la documentación 01:03:52

de date y decir, vamos a ver 01:03:55

¿cómo construyo un objeto 01:03:56

fecha a partir de 01:03:59

un string que me digan 01:04:01

3 de abril, ¿cómo lo hago? 01:04:03

pues no pasa nada, uno hace 01:04:05

lo que tiene que hacer en este caso 01:04:07

pues se abre 01:04:09

su Google 01:04:10

evita preguntarle a chat GPT 01:04:11

y lo busca en los foros 01:04:15

o directamente en la documentación de Oracle 01:04:17

directamente 01:04:19

entonces 01:04:20

hace una búsqueda correcta 01:04:22

buscando a ver que quiero yo instanciar 01:04:25

adiós 01:04:28

objeto date 01:04:30

java 01:04:31

stream porque me lo va 01:04:32

yo lo voy a leer con una calle en un stream 01:04:35

hace una búsqueda porque 01:04:37

hay que aprender 01:04:39

a solucionar problemas 01:04:41

haciendo búsquedas aquí 01:04:43

porque ese es el 30% de vuestro 01:04:45

trabajo y cuidado 01:04:47

con el chat GPT 01:04:49

porque bueno, todavía en estas cosas 01:04:50

tan básicas vale, pero en cuanto 01:04:53

te sales un poquito de lo básico 01:04:55

no te dice más que gilipolleces, y cuando se lo recuerdas 01:04:57

te dice, uy, perdona, es verdad 01:04:59

y de ahí no sales 01:05:01

vale, ¿cómo convertir 01:05:03

un de stream para date 01:05:06

en java? uy, esto tiene toda la pinta 01:05:07

crear un date a partir de un stream, ah, pues mira 01:05:09

tiene pinta de que esto es justo lo que queremos hacer 01:05:11

a partir de un stream que hemos leído del teclado 01:05:13

crear un date, tiene pinta de que 01:05:15

este nos va a resolver 01:05:17

el problema, y yo si tengo internet 01:05:18

vale 01:05:21

entonces me dice 01:05:22

mira, este es tu string, el que tú habrás 01:05:25

leído de la consola 01:05:27

pues lo que tendrás que hacer será 01:05:28

hacerle un parse 01:05:31

mediante un objeto formater 01:05:33

que creas así, al que le dices el formato 01:05:35

de tu string 01:05:37

y ya está, ya lo tienes hecho, ah, magnífico 01:05:38

pues ya está, listo, ya lo tenemos 01:05:42

solucionado 01:05:43

ya lo tenemos, vamos a escribirlo y una vez escrito 01:05:44

¿Vale? 01:05:47

Vale, pues 01:05:54

¿Cómo funciona date? 01:05:54

Pues te dice, ah, te tienes que crear 01:05:58

Un objeto este 01:06:00

Pues venga, lo importamos, ¿vale? 01:06:01

Vale 01:06:07

Y ahora, le dices en el formato 01:06:07

En el que le vas a pedir tú la fecha 01:06:10

En string, nos gusta pedírsela así 01:06:12

Año, mes y día, bueno 01:06:14

esto es muy inglés 01:06:15

vamos a pedirlo en español 01:06:17

perdón 01:06:19

a ver, pero esto es para hacer 01:06:20

el cambio de string a date 01:06:26

tú desde consola solo puedes leer string 01:06:27

entonces el string lo tienes que pasar 01:06:29

a objeto date 01:06:32

y este es el que te hace la conversión 01:06:32

entonces 01:06:34

tú ahora ya 01:06:37

cuando tengas tu cadena leída 01:06:39

vamos a leer la fecha en cadena 01:06:40

La fecha en texto 01:06:42

Pues la fecha en texto 01:06:46

La leeremos, vamos a pedírsela 01:06:48

Vamos a decirle 01:06:50

Introduzca 01:06:51

Introduzca fecha en formato 01:06:53

Y vamos a decirle 01:06:58

El formato 01:07:00

Que yo voy a necesitar 01:07:01

Para hacer la conversión 01:07:04

Le decimos, venga, introduzca fecha 01:07:05

En este formato 01:07:09

vale, la leemos en cadena 01:07:10

porque de la consola solo podemos leer 01:07:13

en formato cadena 01:07:15

ahora tenemos la fecha 01:07:16

en string 01:07:19

pero en string no nos vale 01:07:19

nosotros la queremos así 01:07:23

así la queremos 01:07:25

para pasársela al constructor 01:07:27

vale, pero es que la podemos convertir 01:07:29

mediante este 01:07:31

parser de arriba con el método 01:07:32

parser 01:07:35

y le pasamos el string 01:07:35

y ya está 01:07:38

Vale, ahora quitamos el rojo 01:07:39

No, no, es la excepción 01:07:47

Pero no os da igual, ahora mismo ya lo quitamos 01:07:49

Entonces, esto es una cosa que podemos 01:07:51

Usar habitualmente 01:07:55

Entonces 01:07:57

¿Necesitas un segundo objeto para pasárselo al primero? 01:07:58

Claro, pero este objeto es el conversor 01:08:02

O sea, conviertes 01:08:04

Destina date 01:08:06

y para convertir de string a date 01:08:07

te hace falta un objeto conversor 01:08:09

y el objeto conversor es este 01:08:10

este objeto conversor te hace el parse 01:08:12

de esta fecha cadena 01:08:15

y te la devuelve el objeto date 01:08:16

tú no puedes leer de consola directamente el objeto 01:08:18

o sea string no tiene un parse 01:08:22

para que tú pases automáticamente a date 01:08:27

no lo tiene, tienes que hacer un objeto 01:08:29

que es capaz de 01:08:31

porque string cuando se hizo string 01:08:32

o sea, no tiene por qué ser 01:08:34

string consciente de que hay una clase date 01:08:36

que tú la puedes transformar, no puedes hacer un casting tampoco 01:08:38

no puedes coger el string 01:08:40

este que has leído, aquí 01:08:42

y hacerle un casting a date 01:08:44

ese casting no va a funcionar 01:08:46

¿vale? entonces la clase date 01:08:48

te ofrece un conversor 01:08:50

bueno, no es que te ofrezca un conversor 01:08:52

la clase date va asociada a un conversor 01:08:55

que te dice, oye, si tienes una fecha 01:08:57

en string, que aquí la tenemos 01:08:59

una fecha, pues este 01:09:00

objeto conversor, esa fecha 01:09:02

en string te la transforma en objeto date 01:09:04

porque un casting tal cual 01:09:07

no funciona, ¿vale? 01:09:08

Y string no tiene un método que sea 01:09:10

to date para pasar a date, tampoco lo tiene. 01:09:12

¿Vale? Entonces 01:09:18

eso por un lado, pues 01:09:19

si uno quiere manejar fechas de forma sencilla 01:09:20

leerlas por teclado y guardarlas 01:09:22

como fechas, siempre puede usar esto porque es 01:09:25

la opción más simple. Luego hay objetos 01:09:26

date más raros y más sofisticados que te permiten 01:09:28

hacer más cosas, pero esto es un poco 01:09:30

el sencillo de toda la vida 01:09:32

y segundo 01:09:34

segunda cosa que quiero que 01:09:36

continuamente vais a estar usando 01:09:38

clases y necesitando 01:09:40

indagar sobre recursos que 01:09:42

vais a necesitar, anda necesito hacer esto 01:09:44

¿cómo lo hago? pues tenéis que buscarlo 01:09:46

tenéis que buscarlo y cada vez 01:09:49

acostumbrar, pues irse uno acostumbrando 01:09:50

más a hacer búsquedas 01:09:52

lo más orientadas posible para no ir a 01:09:54

ir identificando pues en qué sitios 01:09:56

normalmente lo que te dicen 01:09:59

tiene sentido, que en esta cover flow suele ser 01:10:00

casi siempre, suele tener sentido lo que 01:10:03

dicen, ¿vale? 01:10:05

Porque obviamente, uno no puede 01:10:06

saberse todas las clases de memoria y todos los 01:10:08

métodos, es imposible, de parte se van incorporando 01:10:11

¿Cuál de ellas? 01:10:12

Esta 01:10:14

La he importado de donde me ha ofrecido 01:10:14

que era Javatex 01:10:19

creo que era 01:10:20

¿Vale? 01:10:21

Sí, gente, está útil 01:10:22

porque por ejemplo, está en el 01:10:24

de IT también, es muy útil 01:10:28

Bueno, es otro paquete con utilidades más genéricas asociadas a texto. 01:10:30

Bueno, porque está ahí. 01:10:35

No lo sé, habría que preguntarle al que diseñó el JDK. 01:10:37

Esa clase está ahí. 01:10:44

A lo mejor hay otro parser dentro de Java útil. 01:10:47

Vale, entonces. 01:10:51

este rojito de aquí es 01:10:52

porque esto puede 01:11:00

que te crea una excepción 01:11:02

porque el objeto este te dice 01:11:04

oye, yo estoy confiando 01:11:06

en que ese string que me estás pasando 01:11:08

tenga el formato 01:11:10

para el que yo me he construido 01:11:12

o sea, este formateador 01:11:14

se especializa 01:11:16

en un 01:11:19

formato de fecha 01:11:20

Yo lo he hecho para este formato 01:11:21

Especializar este formato 01:11:23

Si yo luego le paso una cadena que no está en este formato 01:11:24

Se va a volver loco 01:11:28

Entonces 01:11:30

La forma de 01:11:31

Garantizar eso es que esta clase 01:11:33

Está hecha para que te lance una excepción 01:11:35

Es decir, unas letritas rojas 01:11:38

Si 01:11:40

Le pasas la cadena mal 01:11:41

Cuando veamos excepciones ya entenderemos 01:11:43

Este mecanismo en realidad que aporta 01:11:46

Que aporta mucho 01:11:47

A nosotros ahora mismo, efectos prácticos 01:11:48

en lo que se traduce es 01:11:50

que el formater te dice, ojo 01:11:52

que cuando me pases la cadena mal voy a hacer 01:11:54

cosas muy raras, ojo 01:11:57

y te avisa con rojo 01:11:58

entonces para que se calle 01:12:00

lo que hacemos es simplemente 01:12:01

hacer el a throws 01:12:04

esto 01:12:07

en el método mail 01:12:08

hacemos y decimos, vale, no te preocupes 01:12:12

si lo que quieres es que yo avise de que 01:12:15

la puedes cagar con el parse, yo aviso 01:12:16

avisas y el compilador ya se queda tranquilo 01:12:18

vale, ya se ha avisado 01:12:21

ahora mismo se traduce en esto 01:12:23

para nosotros, luego ya entenderemos un poco 01:12:25

esto que aporta y que 01:12:27

porque nos es útil 01:12:29

pero ahora como tenemos que seguir trabajando 01:12:30

pues para que el compilador se calle 01:12:32

me obliga a avisar de que, ojo, cuidado 01:12:35

que ese objeto que hace el parse 01:12:37

puede que te haga algo raro, como le metas mal 01:12:39

la cadena, vale, pues ya está, si yo aviso 01:12:41

no pasa nada, si es por eso 01:12:43

si, podríamos poner también un try catch 01:12:44

lo que pasa es que no quiero complicar el código 01:12:49

porque ya en el case ya es muy largo 01:12:51

entonces es más cómodo 01:12:52

siempre tienes las dos opciones 01:12:54

siempre tienes las dos 01:12:55

yo es que cuando hicimos la clase 01:12:57

esta sería la de pasarle el problema al de arriba 01:13:00

y el otro sería 01:13:05

ocuparte tú de él 01:13:06

el try catch es, cuidado, si hay un error yo me ocupo 01:13:07

y en el catch te digo lo que voy a hacer, yo me ocupo 01:13:10

y este sería 01:13:12

si hay un problema, para afuera 01:13:13

el que me haya llamado 01:13:16

que ya se ocupe, yo no me ocupe 01:13:18

¿vale? entonces, ahora 01:13:20

para no hacer el código largo 01:13:22

pues opto por esa opción 01:13:24

que es más cómoda 01:13:26

que es más cómoda 01:13:28

como todavía no estamos metidos en excepciones 01:13:29

ni las hemos estudiado 01:13:32

¿vale? bueno, pues entonces 01:13:33

ala, ya tengo 01:13:36

leídos los tres parámetros 01:13:38

comunes 01:13:40

el nombre del empleado 01:13:41

Sueldo y fecha. Y ahora ya, si es gestor, tengo que pedir el bonus. Y si es empleado temporal, tengo que pedir la fecha de fin de contrato. 01:13:43

Entonces, eso ya como os guste más. Podemos hacerle una pregunta, decir, ¿es gestor? Y que nos lo diga con sí o no. 01:13:57

Sí o no 01:14:07

Vale, y ahora vamos a leer 01:14:09

Uy, perdón 01:14:14

Gerente 01:14:16

Es gerente 01:14:17

Que me lo diga con sí o no 01:14:21

Entonces leemos 01:14:23

De esta manera 01:14:24

Si teclado 01:14:28

Punto leer cadena 01:14:30

leer cadena 01:14:37

punto equals 01:14:40

ahora que ya sabemos todo lo del equals 01:14:42

y del string y de todo 01:14:44

es igual a S 01:14:46

vamos a confiar que me va a meter siempre S o N 01:14:47

porque como tenemos que verificar 01:14:50

que me mete Z o J ya 01:14:52

hacemos aquí un código larguísimo 01:14:54

¿que lo es? ¿que me ha dicho que sí? 01:14:55

pues entonces voy a tener que pedir el bonus 01:14:59

vale 01:15:00

entonces le decimos aquí 01:15:03

Que meta el bonus 01:15:05

Y lo leemos 01:15:07

Y ya de paso 01:15:11

Ya de paso 01:15:13

Creamos aquí mismo en este if 01:15:15

El gerente y lo metemos 01:15:17

Bueno no, no lo creamos aquí porque 01:15:18

Voy a doblar código a lo tonto 01:15:20

Pues venga, el bonus que es un dabble también 01:15:24

vale, pues ya está 01:15:35

si me ha dicho que sí, leo el bonus 01:15:37

en el ELSE aquí no hace falta ELSE 01:15:39

si me ha dicho que no, no tengo más que hacer 01:15:41

ahora 01:15:43

le puedo preguntar otra vez 01:15:44

¿es empleado temporal? 01:15:49

lo que pasa es 01:15:52

lo puedo meter en un ELSE, sí 01:15:53

porque así 01:15:55

si es gerente ya no pregunto si es empleado temporal 01:15:56

¿no? 01:15:59

lo puedo meter en un ELSE 01:16:02

entonces si no es gerente 01:16:04

si no es gerente, le pregunto 01:16:05

¿es temporal? 01:16:07

Sí, pero si no me 01:16:20

si no es ni este ni este 01:16:21

no tengo nada que hacer porque es un empleado 01:16:23

normal y ya con lo de arriba ya he terminado 01:16:25

entonces aquí estoy añadiendo 01:16:27

solo si está en alguno de los otros 01:16:29

dos casos particulares, porque si está el empleado 01:16:31

aquí ya habría acabado 01:16:33

Entonces, esto es lo común, lo de si es empleado. Entonces, ahora, si es gerente, le leemos el bonus y si es empleado temporal, lo pregunto, es empleado temporal aquí, ¿vale? De nuevo, S, N. 01:16:35

Vale, si es empleado temporal 01:17:05

Entonces lo mismo puedo hacer 01:17:06

La lectura 01:17:08

Punto equals 01:17:08

¿Sí? 01:17:16

¿Sí me ha dicho que sí? 01:17:20

Equals sí 01:17:25

Pues entonces le digo 01:17:26

Vale, mete la fecha de fin 01:17:29

¿Vale? 01:17:35

Y para meter la fecha de fin 01:17:39

¿Vale? 01:17:41

Estaría bien que en la clase teclado 01:17:43

Metiéramos el método leer fecha 01:17:44

Y así ya vamos a leer fecha 01:17:46

Y nos ahorramos 01:17:49

Todo este rollo 01:17:50

De aquí 01:17:52

¿Vale? 01:17:53

De hecho lo vamos a incorporar el próximo día 01:17:56

Bueno, no hace falta 01:17:58

Este objeto ya lo tengo 01:18:03

no hace falta que lo vuelva a declarar 01:18:04

me leo la fecha 01:18:06

texto otra vez y ahora 01:18:08

fecha de fin 01:18:10

la fecha de fin, convierto 01:18:11

la fecha texto que me he leído 01:18:14

fecha fin 01:18:16

vale, entonces aquí 01:18:17

de alguna manera hemos 01:18:21

leído todos los datos que necesitamos 01:18:24

pero ahí hay que organizar esto 01:18:26

hay que organizar esto porque ahora hay que 01:18:28

buscar dentro de la raíz de departamentos 01:18:30

el departamento que sea 01:18:33

y a ese departamento llamarle a de empleado. 01:18:34

Entonces, ahora hay que meter aquí 01:18:38

la instanciación del objeto correcto. 01:18:39

Hay que meter aquí la instanciación del objeto correcto. 01:18:43

Ahora ya se trata de instanciar el objeto correcto 01:18:45

y añadírselo al departamento que sea. 01:18:49

Entonces, ¿dónde va a ser lo más cómodo? 01:18:53

Pues lo más cómodo va a ser 01:18:56

si es gerente, 01:18:58

Aquí mismo ya directamente 01:19:00

Instanciar el objeto gerente 01:19:03

Y añadirlo al departamento 01:19:05

Si no es gerente y es empleado 01:19:06

Aquí mismo ya 01:19:09

Dentro de este if 01:19:11

Instanciar el objeto empleado 01:19:13

Temporal 01:19:15

Y añadirlo al departamento 01:19:16

Y si no 01:19:18

Pues 01:19:20

Vale 01:19:20

Buscamos entonces 01:19:24

Aquí que sería interesante 01:19:26

primero vamos a localizar el departamento 01:19:29

al que hay que añadirlo, ¿verdad? 01:19:32

el departamento al que hay que añadirlo 01:19:34

por ejemplo, nos vamos aquí, una vez que teníamos el nombre 01:19:35

vamos a localizar el departamento 01:19:38

primero, localizamos 01:19:39

el departamento 01:19:42

al que hay que añadir 01:19:45

este 01:19:46

sí 01:19:47

por ahora es una variable que voy a usar 01:19:49

para instanciar el empleado temporal. 01:19:58

O sea, empleado temporal va a necesitar 01:20:00

el fecha que tenía la de inicio, 01:20:01

la común para todas, más fecha fin. 01:20:05

Claro, esta va a ser para inicializar esa. 01:20:14

Es el dato de entrada, 01:20:18

pero todavía no he construido el objeto. 01:20:19

Lo voy a usar para cuando construya el objeto. 01:20:21

Vale, pues vamos a localizar el departamento. 01:20:23

Entonces, para localizar el departamento, 01:20:25

Pues aquí simplemente podemos hacer 01:20:27

El departamento al que hay que añadir 01:20:30

Departamento 01:20:32

Al que hay que añadir de 01:20:33

Vamos a localizarlo 01:20:35

Y podríamos hacer 01:20:38

Si 01:20:40

Un for 01:20:40

Mientras si sea menor que 01:20:42

Empresa.get 01:20:48

Departamentos 01:20:51

Punto length 01:20:52

y ahora incrementando i 01:20:54

pues ahora 01:20:58

si 01:21:03

de 01:21:03

en .get 01:21:05

departamentos 01:21:09

de i 01:21:10

.get 01:21:12

nombre 01:21:16

es igual al que me han dado 01:21:17

Al nombre de este de aquí 01:21:24

¿Qué hay aquí con la letra tan grande? 01:21:34

Pues entonces ya he encontrado 01:21:36

A ver 01:21:38

Ahí 01:21:40

Entonces ya he encontrado 01:21:41

El departamento al que hay que añadir 01:21:47

Que es este, de igual a 01:21:49

Em, getDepartamentos, de ahí 01:21:51

vale, entonces este primer 01:21:54

esto primero de aquí 01:22:01

esto primero de aquí 01:22:03

primero hemos localizado 01:22:07

el departamento dentro de la raíz 01:22:09

de departamentos al que hay que añadirle 01:22:11

el empleado 01:22:14

vale, hemos recorrido la raíz de departamentos 01:22:15

de la empresa, que es este 01:22:19

la raíz de departamentos 01:22:21

lo hemos recorrido con este for 01:22:23

hemos visto cuál de todos 01:22:25

esos departamentos de la red de departamentos 01:22:28

su nombre es este que me han pasado 01:22:30

por teclado 01:22:32

y cuando lo haya encontrado lo guardo ahí 01:22:33

vale, para tener en esta referencia 01:22:36

ahí ya, en esa referencia más cómoda 01:22:38

en esa referencia 01:22:41

tengo ya 01:22:42

mi departamento 01:22:43

y ahora ya a ese departamento le tengo que añadir 01:22:45

el nuevo empleado que toco 01:22:49

con los datos de abajo 01:22:50

vale, pues a ver 01:22:52

ahora, ¿qué es lo que hemos 01:23:02

hecho después? leer los datos 01:23:04

entonces 01:23:06

si es 01:23:11

si me han dicho que es gerente 01:23:13

si me han dicho que es gerente 01:23:16

he entrado por aquí, aquí ya puedo 01:23:18

añadir a ese un nuevo 01:23:20

adempleado 01:23:22

gerente ya directamente porque tengo 01:23:24

todos los datos, new gerente 01:23:26

y gerente necesita 01:23:28

el nombre que lo acabo de leer 01:23:29

nom 01:23:32

emp 01:23:34

el sueldo que lo acabo de leer 01:23:35

la fecha de comienzo 01:23:39

que la he leído ahí en fecha 01:23:42

y el bonus 01:23:44

que lo acabo de leer 01:23:47

y cierro 01:23:48

vale 01:23:52

pues si es gerente 01:23:52

estoy en el if de gerente 01:23:54

si es gerente 01:23:57

añado al departamento 01:23:58

un empleado gerente 01:24:00

con esos datos 01:24:01

y ya está 01:24:02

vale 01:24:03

en este else de aquí 01:24:05

en este else estaba 01:24:07

si es empleado temporal 01:24:08

entonces cuando yo estoy aquí 01:24:11

en este punto 01:24:13

es porque es empleado temporal 01:24:14

pues entonces 01:24:15

a mi D le añado 01:24:16

una de empleado pero que en este caso 01:24:18

será un new empleado 01:24:21

temporal 01:24:22

al que le doy los datos 01:24:24

que los datos van a ser 01:24:27

el nombre del empleado 01:24:29

el sueldo 01:24:31

la fecha 01:24:33

y la fecha fin 01:24:36

que acabo de leer 01:24:38

y cierro 01:24:40

vale 01:24:45

¿Vale? 01:24:46

Entonces 01:24:55

Me falta colocar aquí 01:24:56

Donde coloco 01:24:57

Si no es ninguno de los anteriores 01:24:59

Entonces esto casi mejor si lo hago como un if 01:25:01

Else if y dejo el else para que sea empleado 01:25:03

¿Verdad? 01:25:06

O sea, si es gerente 01:25:08

Ya está 01:25:10

Else if 01:25:11

sería 01:25:13

a ver 01:25:17

es que no quiero complicar el código 01:25:19

pero entendéis lo que estoy, ya lo he complicado mucho 01:25:22

claro, por no sacar a métodos 01:25:24

este es el problema, si no sacas a métodos 01:25:26

pero a ver, estáis entendiendo lo que estamos haciendo 01:25:28

si es que estamos haciendo lo mismo de una otra vez 01:25:30

lo que pasa es que son muchas líneas, pero es hacer lo mismo 01:25:32

todo el rato 01:25:34

entonces aquí lo único que estoy mirando es 01:25:35

donde colocar, para que no quede demasiado feo 01:25:38

la instanciación del empleado 01:25:40

Porque aquí si es gerente ya he terminado 01:25:43

Lo de alzaría 01:25:47

¿Vale? 01:25:49

Si no es gerente 01:25:51

Pregunto 01:25:52

Y ahora este if 01:25:54

Aquí, sería aquí 01:25:57

¿Vale? Pues lo podría poner aquí mismo 01:25:59

¿Por qué? Esto me dice 01:26:02

Que es 01:26:04

Sí, sí, sí 01:26:05

Seguramente 01:26:11

que sí, que sí 01:26:12

efectivamente, que sí 01:26:14

¿qué nos enseña eso? 01:26:19

que siempre es mucho mejor 01:26:21

hacerse, antes de empezar a escribir código 01:26:22

siempre un diseñito 01:26:25

previo, ya no solo de tu aplicación 01:26:27

con las claves, que eso está claro 01:26:29

sino cuando quieres hacer un código 01:26:30

claro, claro, cuando quieres 01:26:32

hacer un código, siempre, siempre 01:26:35

es deseable, hacerte antes un diseño 01:26:37

previo de cómo lo vas a organizar 01:26:39

porque aquí, ¿qué estamos haciendo? 01:26:40

directamente estamos escribiendo, 01:26:42

quiero hacer esto, lo voy haciendo. 01:26:44

Y cada vez lo vamos resolviendo. 01:26:46

Pero el resultado final que nos queda, 01:26:47

pues puede no gustarnos. 01:26:49

Entonces, lo evitamos si antes uno se coge un papel 01:26:51

y dice, a ver, yo tengo que leer estos datos, 01:26:55

con esto construir esto, si hace esto, esto. 01:26:57

¿Cómo lo voy a organizar? 01:26:59

Una vez que tengamos el juego de organizarlo, 01:27:01

te pones a escribir código. 01:27:03

Porque lo que hemos hecho ahora es, 01:27:04

ponernos a escribir código para resolver esto sobre la marcha. 01:27:06

Podemos resolverlo porque sabemos hacerlo, 01:27:08

pero es verdad que luego a lo mejor 01:27:10

nos sale más enrevesado de lo que nos saldría 01:27:11

si hubiéramos hecho un papelito 01:27:13

el enunciado te dice 01:27:16

que crees un empleado y lo añades al departamento 01:27:18

estamos haciendo lo que te dice el enunciado 01:27:20

pues eso 01:27:21

que estamos haciendo lo que te dice el enunciado 01:27:23

a ver, claro 01:27:26

obviamente, pero la idea es complicar 01:27:30

la vida y porque uno 01:27:32

ve si tiene soltura o tiene que hacer muchas 01:27:34

cosas raras, claro 01:27:36

Pero a ver, que esto ya es meterlo en el ELSE y ya hemos terminado, ¿no? 01:27:37

Si en realidad no es tanto, es, leemos el nombre del departamento y lo localizamos, ¿vale? 01:27:43

Esa es la primera parte, leer nombre del departamento y localizado. 01:27:49

Ahora, leemos los datos del empleado, los comunes, que son estos, y los específicos. 01:27:52

Y ahora ya, en el ELSE que toque, añado el departamento que sea. 01:27:59

En realidad son tres partes las que hemos hecho. 01:28:04

localizar departamento, pedir datos 01:28:05

y añadir 01:28:08

en cada una de las tres opciones 01:28:10

el empleado, entonces 01:28:12

¿qué es gerente? añade el empleado 01:28:14

gerente, que no, ¿es empleado 01:28:16

temporal? añado el temporal 01:28:19

¿que tampoco? es porque es empleado 01:28:21

normal, pues ya está, entonces lo añado 01:28:22

a de empleado 01:28:25

new, empleado 01:28:26

con los datos que son 01:28:29

que son, nombre de empleado 01:28:30

sueldo 01:28:33

sueldo y fecha 01:28:34

y ya está 01:28:37

vale, son muchas líneas 01:28:39

pero es que son tres partes, conceptualmente 01:28:45

son tres partes 01:28:47

pedir datos del departamento y localizarlo en el array 01:28:48

eso es que hay que hacerlo sí o sí, no se puede hacer de otra manera 01:28:51

luego, pedir los datos 01:28:53

hay que pedirlo sí o sí, no se puede 01:28:55

hacer de otra manera, convertir la fecha 01:28:57

hay que convertirla sí o sí 01:28:59

otra cosa es que lo saquemos a métodos, que aquí 01:29:00

habría estado bien cambiar teclado 01:29:03

y ponerle un leer fecha. 01:29:05

Y que dentro de leer fecha te lea el string, te lo convierte 01:29:06

y te devuelva el date. Pero como no lo tenemos, 01:29:09

pues tenemos que hacerlo sí o sí. 01:29:11

Y ahora ya, este if, 01:29:13

el save, esto es lo que sí que podemos 01:29:15

remodelar. Pero siempre va a haber 01:29:17

tres ramas igual. 01:29:19

Aquí hay tres ramas. 01:29:20

Al 01:29:21

entero le has añadido además 01:29:22

el llegar departamento. 01:29:25

No estaba en la caleta. 01:29:27

Sin eso cambia mucho también. 01:29:30

A ver, el otro día 01:29:31

Yo lo que añadí fue 01:29:33

El otro día yo lo 01:29:34

Pero eso no tiene nada que ver con esta opción 01:29:36

No, esto es incorporar empleado al departamento 01:29:39

He creado un método 01:29:44

Añadir departamento a la empresa 01:29:48

Que nos ha solucionado mucho la vida 01:29:50

Pero eso nos ha solucionado la vida 01:29:52

Porque eso afectaba a esta primera parte solo 01:29:54

La segunda no tiene nada que ver 01:29:56

Y esta primera parte mira que cómoda ha quedado y que estupenda 01:29:57

ah, que sería más complicado 01:30:00

dices, si yo no hubiera hecho 01:30:04

añadir departamento, claro 01:30:06

sin añadir departamento 01:30:07

sería más complicado, sería más 01:30:09

de nuevo, ahí habría quedado un código más largo 01:30:11

efectivamente, claro 01:30:13

bueno, pues entonces 01:30:15

ya tenemos todo 01:30:22

son tres partes 01:30:23

que es que hay que hacerlas, sí o sí 01:30:25

en métodos aparte o dentro, pero es que no hay otra 01:30:27

localizar el departamento 01:30:29

localizado 01:30:32

pedir los datos, pedidos 01:30:33

y luego ya, tres ramas 01:30:35

eso ya, esas tres ramas 01:30:36

sí que puedo yo decidir cómo las saco 01:30:38

yo lo he hecho con un if, un else 01:30:41

y un if anidado en el else, que es verdad que eso es feo 01:30:42

pues esas tres ramas 01:30:44

uno las hace con un if else if, las hace con un switch case 01:30:46

las hace como sea, pero tres ramas hay 01:30:49

porque lo que hay que hacer es tres cosas 01:30:51

distintas 01:30:53

o bien añadir un new gerente 01:30:54

o bien añadir un new empleado 01:30:56

O bien hay un empleado temporal 01:30:58

Son tres cosas distintas que hay que hacer 01:31:00

¿Vale? 01:31:02

Tres cosas diferentes 01:31:05

Y ya está 01:31:06

¿Vale? Entonces 01:31:08

Esta es 01:31:14

La más liosa 01:31:16

La segunda, es que la segunda es llamar al método 01:31:18

La segunda ya hay un método 01:31:20

Que es 01:31:23

La empresa tiene un método que es 01:31:23

GetSueldoTotal 01:31:27

Pues es que ya está 01:31:28

La opción 2 ya la tengo 01:31:29

Y la opción 3, esta es la bonita 01:31:31

Que es la que vais a hacer el fin de semana 01:31:35

¿Vale? 01:31:37

Porque aquí ya hay que hacer un máximo 01:31:38

Pero bueno 01:31:40

Es para repasar de nuevo lo de los máximos 01:31:42

¿Vale? 01:31:45

Clase 9-02-24 - 1 - Contenido educativo

Del mismo autor…

Un comienzo inolvidable

COnstruye con Nezha una farola programando con MakeCode su sensor de luz.

Crea un sesión en tu ordenador para proteger la información de tu clase.

Vídeo cumpleaños

Vídeo Cumpleaños

Navidad 25-26

Cuentacuentos 25-26