1
00:00:00,000 --> 00:00:03,859
Tengo la esta congelada, o a las manos.

2
00:00:08,480 --> 00:00:09,700
Ahora, vale.

3
00:00:10,980 --> 00:00:13,000
Vale, pues...

4
00:00:14,460 --> 00:00:19,059
Este ejercicio está muy pautado en el sentido de que especifica exactamente

5
00:00:19,059 --> 00:00:22,660
qué clases hay que hacer, qué métodos cada una, etc.

6
00:00:23,039 --> 00:00:24,379
Está muy pautadito.

7
00:00:25,300 --> 00:00:29,480
En general ya os he dicho muchas veces que precisamente la problemática no es esta,

8
00:00:29,480 --> 00:00:30,480
Sino la anterior

9
00:00:30,480 --> 00:00:33,359
Es tomar la decisión de que clases me interesan

10
00:00:33,359 --> 00:00:35,840
Verás que si Daniel Gallego

11
00:00:35,840 --> 00:00:39,039
Vale

12
00:00:39,039 --> 00:00:41,679
Bueno pues entonces vamos a hacer las tres primeras

13
00:00:41,679 --> 00:00:42,640
Por si alguien

14
00:00:42,640 --> 00:00:44,260
Hay alguna cosa que le

15
00:00:44,260 --> 00:00:46,960
Que le haya dejado medio atascado

16
00:00:46,960 --> 00:00:48,600
Empleado está clara

17
00:00:48,600 --> 00:00:51,340
Al empleado le caracteriza su nombre, su salario

18
00:00:51,340 --> 00:00:52,480
Y una fecha de contratación

19
00:00:52,480 --> 00:00:54,700
Pues hay poco que pensar en empleado

20
00:00:54,700 --> 00:00:56,500
Entonces empleado

21
00:00:56,500 --> 00:00:58,480
Habréis hecho algo

22
00:00:58,480 --> 00:01:01,420
que me distraéis

23
00:01:01,420 --> 00:01:03,280
algo como esto

24
00:01:03,280 --> 00:01:04,859
una clase empleado

25
00:01:04,859 --> 00:01:06,120
con sus tres atributos

26
00:01:06,120 --> 00:01:08,840
aquí que es interesante incorporar

27
00:01:08,840 --> 00:01:09,380
desde ya

28
00:01:09,380 --> 00:01:11,380
pues efectivamente

29
00:01:11,380 --> 00:01:13,380
hay propiedades

30
00:01:13,380 --> 00:01:16,560
en muchísimas clases

31
00:01:16,560 --> 00:01:18,520
que son fechas, que está claro, fechas de nacimiento

32
00:01:18,520 --> 00:01:20,040
fecha de contrato, fecha de cierre

33
00:01:20,040 --> 00:01:21,439
hay muchas propiedades que son fechas

34
00:01:21,439 --> 00:01:23,500
entonces guardarlo en variable string

35
00:01:23,500 --> 00:01:26,420
es un rollo para manejarlas

36
00:01:26,420 --> 00:01:28,100
porque con las fechas a veces que se hace

37
00:01:28,100 --> 00:01:30,280
Pues comparar si una fecha es posterior a otra

38
00:01:30,280 --> 00:01:32,200
Comparar el tiempo que ha transcurrido

39
00:01:32,200 --> 00:01:33,180
Entre una fecha y otra

40
00:01:33,180 --> 00:01:35,520
Cuando has guardado las fechas en stream

41
00:01:35,520 --> 00:01:37,940
Hacer esas funcionalidades se complica mucho

42
00:01:37,940 --> 00:01:40,300
¿Cómo detectas tú que una fecha

43
00:01:40,300 --> 00:01:42,300
Es por detrás de otra cuando lo has guardado

44
00:01:42,300 --> 00:01:44,060
Como 9 de octubre de no sé qué

45
00:01:44,060 --> 00:01:44,680
Es una locura

46
00:01:44,680 --> 00:01:47,520
Entonces, por eso la

47
00:01:47,520 --> 00:01:49,620
JDK, la máquina virtual

48
00:01:49,620 --> 00:01:52,140
JRE, incorpora una clase

49
00:01:52,140 --> 00:01:54,520
Para manejar fácilmente

50
00:01:54,520 --> 00:01:56,060
Objetos fecha

51
00:01:56,060 --> 00:01:58,080
No una, muchas

52
00:01:58,079 --> 00:02:00,620
esta es la de toda la vida

53
00:02:00,620 --> 00:02:03,980
la que está en el paquete java útil

54
00:02:03,980 --> 00:02:06,079
pero hay muchas más

55
00:02:06,079 --> 00:02:07,959
clases que sirven

56
00:02:07,959 --> 00:02:09,259
para guardar fechas

57
00:02:09,259 --> 00:02:12,099
y cuál es la ventaja de tener una fecha guardada

58
00:02:12,099 --> 00:02:13,819
como objeto

59
00:02:13,819 --> 00:02:14,780
y no como string

60
00:02:14,780 --> 00:02:17,699
pues que esa clase date incorpora

61
00:02:17,699 --> 00:02:19,219
ya un montón de métodos para hacer cosas

62
00:02:19,219 --> 00:02:22,139
pues comparar dos objetos date a ver cuál es posterior a otro

63
00:02:22,139 --> 00:02:26,099
obtener el tiempo pasado entre una fecha y otra

64
00:02:26,099 --> 00:02:26,960
un montón de cosas

65
00:02:26,960 --> 00:02:29,900
esa es la ventaja de guardar

66
00:02:29,900 --> 00:02:32,099
una fecha

67
00:02:32,099 --> 00:02:33,580
en un objeto date

68
00:02:33,580 --> 00:02:35,200
en lugar de en un string

69
00:02:35,200 --> 00:02:37,719
que puedo entonces operar fácilmente para hacer

70
00:02:37,719 --> 00:02:39,040
cosas relacionadas con fechas

71
00:02:39,040 --> 00:02:41,560
bueno, pues nada, aquí simplemente

72
00:02:41,560 --> 00:02:43,560
mencionar eso y podemos

73
00:02:43,560 --> 00:02:45,560
incorporar esta que es la de toda la vida

74
00:02:45,560 --> 00:02:48,040
la más sencilla, pero hay muchas, mucho más actualizadas

75
00:02:48,040 --> 00:02:49,040
que hacen más virguerías

76
00:02:49,040 --> 00:02:51,860
pero eso es lo de siempre, que uno quiere una clase fecha

77
00:02:51,860 --> 00:02:53,760
muy super guay para hacer cosas, pues se la

78
00:02:53,760 --> 00:02:55,780
busca la documentación, ah mira esta que bien

79
00:02:55,780 --> 00:02:57,520
que tiene unos métodos para hacer cosas estupendas

80
00:02:57,520 --> 00:02:59,159
con la fecha, pues la planto y ya está

81
00:02:59,159 --> 00:03:00,939
si ahora ya se trata de

82
00:03:00,939 --> 00:03:03,520
buscar documentación para ver cómo funciona cada clase

83
00:03:03,520 --> 00:03:04,099
y poco más

84
00:03:04,099 --> 00:03:07,400
bueno, pues entonces, las tres propiedades

85
00:03:07,400 --> 00:03:08,439
que habréis hecho son esas

86
00:03:08,439 --> 00:03:11,539
y si seguimos las pautas habituales de programación

87
00:03:11,539 --> 00:03:13,360
pues bueno, tres propiedades privadas

88
00:03:13,360 --> 00:03:15,139
constructor, parámetros

89
00:03:15,139 --> 00:03:17,340
sin parámetros, get y set

90
00:03:17,340 --> 00:03:19,420
bueno, nunca está de más

91
00:03:19,420 --> 00:03:21,259
como ya dijimos, hacer un toString

92
00:03:21,259 --> 00:03:23,580
para que si uno

93
00:03:23,580 --> 00:03:24,939
quiere mostrar por consola

94
00:03:24,939 --> 00:03:26,979
este objeto, pues

95
00:03:26,979 --> 00:03:28,840
en lugar de mostrarme el

96
00:03:28,840 --> 00:03:30,919
toString de object que me hacía cosas tan raras

97
00:03:30,919 --> 00:03:32,139
me muestre algo más bonito

98
00:03:32,139 --> 00:03:34,840
y nunca hasta además tampoco hacer el

99
00:03:34,840 --> 00:03:36,819
equals, lo que pasa es que aquí todavía no

100
00:03:36,819 --> 00:03:38,879
incorporo, yo no lo he incorporado

101
00:03:38,879 --> 00:03:40,599
porque bueno, esta aplicación

102
00:03:40,599 --> 00:03:42,979
no lo va a utilizar y para qué aumentar

103
00:03:42,979 --> 00:03:44,939
la complejidad, va a ser imprescindible cuando

104
00:03:44,939 --> 00:03:46,879
lo trabajemos con colecciones, pero

105
00:03:46,879 --> 00:03:49,240
ahora todavía no lo es

106
00:03:49,240 --> 00:03:50,979
pues nada, habréis hecho empleado

107
00:03:50,979 --> 00:03:52,860
y ya está, y en gerente pues tampoco

108
00:03:52,860 --> 00:03:54,180
os habréis vuelto locos porque

109
00:03:54,180 --> 00:04:09,200
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.

110
00:04:09,200 --> 00:04:11,680
eso hace que el constructor

111
00:04:11,680 --> 00:04:13,460
cambia, hay que hacerlo específicamente

112
00:04:13,460 --> 00:04:15,680
porque ya sabéis que los constructores nos heredan

113
00:04:15,680 --> 00:04:17,780
pues lo hacemos específicamente

114
00:04:17,780 --> 00:04:19,640
además apoyándonos en el superior

115
00:04:19,640 --> 00:04:21,920
con super, apoyándonos en el superior

116
00:04:21,920 --> 00:04:23,420
hacemos además

117
00:04:23,420 --> 00:04:25,319
unos imparámetros que siempre vienen muy bien

118
00:04:25,319 --> 00:04:27,540
y como los get y set ya los

119
00:04:27,540 --> 00:04:29,780
tenemos heredados de arriba aunque no los veamos

120
00:04:29,780 --> 00:04:31,200
pues añadimos solo

121
00:04:31,200 --> 00:04:33,439
el get y set específico de la

122
00:04:33,439 --> 00:04:34,759
propiedad específica

123
00:04:34,759 --> 00:04:37,439
y gerente pues por ahora se podría quedar así

124
00:04:37,439 --> 00:04:39,920
ahora ya, la siguiente clase

125
00:04:39,920 --> 00:04:41,819
pues venga, departamento

126
00:04:41,819 --> 00:04:44,600
departamento hemos dicho que se caracteriza

127
00:04:44,600 --> 00:04:45,480
por un nombre

128
00:04:45,480 --> 00:04:47,839
y todos los empleados que tenga

129
00:04:47,839 --> 00:04:50,439
pues ya está, un nombre y todos los empleados

130
00:04:50,439 --> 00:04:50,899
que tenga

131
00:04:50,899 --> 00:04:53,379
entonces por comodidad

132
00:04:53,379 --> 00:04:55,860
y por evitar errores de ejecución

133
00:04:55,860 --> 00:05:00,220
es relativo

134
00:05:00,220 --> 00:05:01,639
se puede incorporar

135
00:05:01,639 --> 00:05:04,159
la inicialización

136
00:05:04,159 --> 00:05:06,199
de las propiedades que sean de tipo

137
00:05:06,199 --> 00:05:09,560
colección de cosas, en este caso es un array

138
00:05:09,560 --> 00:05:12,920
¿vale? pero más adelante pues será un conjunto

139
00:05:12,920 --> 00:05:15,620
será una lista, será un mapa, será cualquier otra cosa que sea

140
00:05:15,620 --> 00:05:18,879
colección de cosas, bueno pues

141
00:05:18,879 --> 00:05:21,860
recordad, estoy repitiendo otra vez

142
00:05:21,860 --> 00:05:24,839
cosas de siempre, si uno no la inicializa

143
00:05:24,839 --> 00:05:27,180
y esto lo deja así vacío

144
00:05:27,180 --> 00:05:30,099
esa propiedad cuando el objeto

145
00:05:30,099 --> 00:05:33,560
se crea, se queda inicializada como null

146
00:05:33,560 --> 00:05:36,159
¿verdad? como null, ¿vale? no pasa nada

147
00:05:36,160 --> 00:05:38,420
se queda como null, pero cuidado

148
00:05:38,420 --> 00:05:40,060
con los objetos null que hay por ahí

149
00:05:40,060 --> 00:05:41,980
que si luego en el momento de usarlos

150
00:05:41,980 --> 00:05:43,840
yo no los instancio

151
00:05:43,840 --> 00:05:46,140
me va a dar el famoso

152
00:05:46,140 --> 00:05:47,260
null pointer exception

153
00:05:47,260 --> 00:05:49,820
me va a dar el famoso null pointer exception

154
00:05:49,820 --> 00:05:51,440
entonces hay una diferencia

155
00:05:51,440 --> 00:05:54,140
entre hacer esta inicialización y no hacerla

156
00:05:54,140 --> 00:05:55,440
si yo la hago

157
00:05:55,440 --> 00:05:57,480
inicializo ese array

158
00:05:57,480 --> 00:06:00,120
a un array sin posiciones, vacío

159
00:06:00,120 --> 00:06:02,420
porque todavía no hay empleados, pero ya no es null

160
00:06:02,420 --> 00:06:03,379
ya no es null

161
00:06:03,379 --> 00:06:05,820
es un array sin posiciones

162
00:06:05,819 --> 00:06:07,959
y si yo hago empleados.led

163
00:06:07,959 --> 00:06:09,379
me saldrá cero

164
00:06:09,379 --> 00:06:10,560
porque no tiene posiciones

165
00:06:10,560 --> 00:06:13,959
y en empleados.a empleados no lo puedo recorrer

166
00:06:13,959 --> 00:06:15,259
porque es que no tiene posiciones

167
00:06:15,259 --> 00:06:16,599
no se le puede recorrer, no se puede hacer nada

168
00:06:16,599 --> 00:06:18,040
porque no tiene posiciones

169
00:06:18,040 --> 00:06:20,139
pero al menos no es null

170
00:06:20,139 --> 00:06:23,259
entonces al no ser null

171
00:06:23,259 --> 00:06:25,159
si en algún sitio a alguien

172
00:06:25,159 --> 00:06:26,680
se le ocurriera hacer

173
00:06:26,680 --> 00:06:28,360
empleados.led

174
00:06:28,360 --> 00:06:30,639
ya no le saldría null pointer exception

175
00:06:30,639 --> 00:06:32,199
no cascaría la aplicación ni nada

176
00:06:32,199 --> 00:06:34,500
simplemente le daría cero y ya está

177
00:06:34,500 --> 00:06:37,319
pero si no lo hemos inicializado

178
00:06:37,319 --> 00:06:38,860
y a alguien por ahí que nos usa

179
00:06:38,860 --> 00:06:41,439
se le ocurre hacer empleados.length

180
00:06:41,439 --> 00:06:42,680
para ver cuantos empleados tenemos

181
00:06:42,680 --> 00:06:44,660
le va a salir null pointer exception

182
00:06:44,660 --> 00:06:46,300
y ahí sí que va a cascar la aplicación

183
00:06:46,300 --> 00:06:47,220
¿vale?

184
00:06:48,480 --> 00:06:49,680
bueno, pues entonces

185
00:06:49,680 --> 00:06:51,779
por eso no es mala práctica

186
00:06:51,779 --> 00:06:54,220
las propiedades que sean

187
00:06:54,220 --> 00:06:55,779
conjuntos de datos

188
00:06:55,779 --> 00:06:57,100
como es el array

189
00:06:57,100 --> 00:07:00,079
inicializarlas a vacío

190
00:07:00,079 --> 00:07:02,319
sin posiciones, pero al menos ya no son null

191
00:07:02,319 --> 00:07:03,660
lo que pasa es que no tienen posiciones

192
00:07:03,660 --> 00:07:06,100
es decir, un departamento cuando se crea

193
00:07:06,100 --> 00:07:07,420
por ahora no tiene empleados

194
00:07:07,420 --> 00:07:10,620
bueno, en esta clase entonces

195
00:07:10,620 --> 00:07:12,400
ya con estas dos propiedades privadas

196
00:07:12,400 --> 00:07:14,060
pues lo de siempre, subconstructor

197
00:07:14,060 --> 00:07:16,340
uno con parámetros, habitual

198
00:07:16,340 --> 00:07:18,920
otro sin parámetros

199
00:07:18,920 --> 00:07:22,420
los get y los set de las dos propiedades

200
00:07:22,420 --> 00:07:25,060
y luego me decía el enunciado

201
00:07:25,060 --> 00:07:26,920
haz dos métodos

202
00:07:26,920 --> 00:07:29,900
uno para añadir un objeto empleado

203
00:07:29,900 --> 00:07:31,180
a ese departamento

204
00:07:31,180 --> 00:07:38,540
Y otro para devolver el sueldo que se les paga a todos los empleados.

205
00:07:39,900 --> 00:07:41,220
Vale, vamos con el primero.

206
00:07:41,480 --> 00:07:42,819
Añadir un empleado al departamento.

207
00:07:44,420 --> 00:07:46,540
Bueno, pues nada, seleccionamos el nombre.

208
00:07:48,300 --> 00:07:51,040
De nuevo, este objeto, ¿qué necesita para trabajar?

209
00:07:51,639 --> 00:07:56,139
El nuevo empleado que le llega de fuera para meterlo en su array de arriba.

210
00:07:56,420 --> 00:07:57,980
El nuevo empleado que le llega de fuera.

211
00:07:58,980 --> 00:08:01,120
Luego necesitará ese objeto.

212
00:08:01,180 --> 00:08:02,780
un nuevo empleado que me llega de fuera

213
00:08:02,780 --> 00:08:04,280
para incorporarlo al array de arriba.

214
00:08:05,360 --> 00:08:07,000
El array de arriba no hay que pasárselo

215
00:08:07,000 --> 00:08:09,259
porque es el suyo propio, es el que aporta él.

216
00:08:10,360 --> 00:08:13,460
El objeto departamento, cuando llame a este método,

217
00:08:14,100 --> 00:08:17,139
cuando tengamos un departamento que llame a este método,

218
00:08:17,139 --> 00:08:18,420
como por ejemplo en este main,

219
00:08:19,160 --> 00:08:21,319
cuando tengamos un departamento que llama al método,

220
00:08:22,199 --> 00:08:26,040
ese objeto departamento ya incluirá su array de empleados dentro

221
00:08:26,040 --> 00:08:28,579
y por tanto no hay que pasárselo.

222
00:08:28,579 --> 00:08:52,579
¿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.

223
00:08:52,580 --> 00:08:54,720
bueno, está claro, ¿no?

224
00:08:55,379 --> 00:08:57,860
entonces, no va a devolver nada

225
00:08:57,860 --> 00:08:59,420
porque el efecto del método

226
00:08:59,420 --> 00:09:01,620
es simplemente modificar

227
00:09:01,620 --> 00:09:03,300
una variable suya que tiene dentro

228
00:09:03,300 --> 00:09:05,700
entonces ya el método tiene un efecto

229
00:09:05,700 --> 00:09:07,620
que es dejar modificada

230
00:09:07,620 --> 00:09:09,620
la propiedad empleados

231
00:09:09,620 --> 00:09:10,620
del objeto que lo llame

232
00:09:10,620 --> 00:09:13,040
entonces no hay ninguna información que devolver

233
00:09:13,040 --> 00:09:15,460
ya el efecto queda reflejado ahí

234
00:09:15,460 --> 00:09:17,500
bueno, pues entendido ya

235
00:09:17,500 --> 00:09:19,920
los parámetros que necesita

236
00:09:19,920 --> 00:09:22,120
lo que devuelve, etcétera

237
00:09:22,120 --> 00:09:34,659
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.

238
00:09:34,659 --> 00:09:37,059
bueno pues es lo que hemos hecho aquí

239
00:09:37,059 --> 00:09:39,120
lo extendemos en una posición

240
00:09:39,120 --> 00:09:42,339
copiamos

241
00:09:42,339 --> 00:09:44,799
las posiciones que tenía

242
00:09:44,799 --> 00:09:46,740
y en la extendida que es esta

243
00:09:46,740 --> 00:09:48,639
en la extendida guardamos el nuevo

244
00:09:48,639 --> 00:09:50,559
y sobre escribimos

245
00:09:50,559 --> 00:09:52,339
el viejo con el nuevo

246
00:09:52,339 --> 00:09:53,980
pues ya está de empleado ya está

247
00:09:53,980 --> 00:09:56,639
entonces pues si uno se va haciendo

248
00:09:56,639 --> 00:09:57,699
un main en paralelo

249
00:09:57,699 --> 00:10:00,720
para ver si los métodos que está haciendo funcionan bien

250
00:10:00,720 --> 00:10:02,759
pues podría ya hacer

251
00:10:02,759 --> 00:10:04,199
esto primero de aquí

252
00:10:04,200 --> 00:10:05,640
¿No?

253
00:10:06,640 --> 00:10:08,520
Creamos un objeto departamento

254
00:10:08,520 --> 00:10:10,720
Le fijo el nombre

255
00:10:10,720 --> 00:10:12,480
Le fijo el nombre

256
00:10:12,480 --> 00:10:14,340
Y ahora ya le voy a añadir

257
00:10:14,340 --> 00:10:15,400
Dos empleados

258
00:10:15,400 --> 00:10:18,440
¿Vale? Bueno, dos empleados

259
00:10:18,440 --> 00:10:20,280
Primero le voy a añadir

260
00:10:20,280 --> 00:10:21,220
Un gerente

261
00:10:21,220 --> 00:10:26,280
A ver, estoy haciendo un main

262
00:10:26,280 --> 00:10:28,000
Para probar los métodos que he hecho solamente

263
00:10:28,000 --> 00:10:29,660
Es un main que lo estoy haciendo en paralelo

264
00:10:29,660 --> 00:10:32,300
Para probar que esos métodos que hago funcionan

265
00:10:32,300 --> 00:10:33,040
¿Vale?

266
00:10:34,200 --> 00:10:39,540
Entonces, vamos a ver si este adempleado de aquí funciona.

267
00:10:40,460 --> 00:10:46,120
Entonces, este adempleado puede recibir cualquier cosa que sea de la clase empleado, cualquiera.

268
00:10:46,860 --> 00:10:48,620
¿Y qué es de la clase empleado?

269
00:10:48,879 --> 00:10:53,660
Los objetos de la propia clase empleado y los objetos de cualquier clase que lo herede.

270
00:10:54,480 --> 00:10:57,980
Luego yo, adempleado, le puedo añadir objetos empleado y objetos gerente.

271
00:10:58,660 --> 00:11:01,259
Es todo lo que le puedo añadir, empleados y gerentes,

272
00:11:01,259 --> 00:11:03,059
porque como gerentes heredan de empleado

273
00:11:03,059 --> 00:11:05,480
pues caen aquí, caben ahí también

274
00:11:05,480 --> 00:11:07,179
en esa referencia E

275
00:11:07,179 --> 00:11:09,240
caben objetos empleado

276
00:11:09,240 --> 00:11:11,500
y objetos de cualquiera de las herederas

277
00:11:11,500 --> 00:11:13,279
luego caben también

278
00:11:13,279 --> 00:11:13,819
gerentes

279
00:11:13,819 --> 00:11:16,679
bueno pues es lo que yo he probado aquí en el main

280
00:11:16,679 --> 00:11:19,399
para ver si funciona, me da errores

281
00:11:19,399 --> 00:11:20,759
pues he

282
00:11:20,759 --> 00:11:22,779
agregado un gerente

283
00:11:22,779 --> 00:11:25,299
y he agregado

284
00:11:25,299 --> 00:11:27,159
un empleado y los dos los he podido

285
00:11:27,159 --> 00:11:29,200
agregar mediante A de empleado

286
00:11:29,200 --> 00:11:31,640
entonces la fecha de contratación

287
00:11:31,640 --> 00:11:33,100
por comodidad

288
00:11:33,100 --> 00:11:35,560
la he instanciado directamente así

289
00:11:35,560 --> 00:11:36,680
con el constructor de date

290
00:11:36,680 --> 00:11:38,520
por comodidad

291
00:11:38,520 --> 00:11:41,400
la clase date, si la habéis indagado

292
00:11:41,400 --> 00:11:43,320
y estudiado, pues a ver, podemos

293
00:11:43,320 --> 00:11:45,420
ahora rápidamente si queréis hacer un objeto date

294
00:11:45,420 --> 00:11:47,780
para una fecha específica, pasada por teclado

295
00:11:47,780 --> 00:11:49,700
pero si tú instancias

296
00:11:49,700 --> 00:11:51,280
una date con su constructor

297
00:11:51,280 --> 00:11:53,360
sin parámetros, lo que te da es

298
00:11:53,360 --> 00:11:55,560
un objeto date con la fecha de ese momento actual

299
00:11:55,560 --> 00:11:57,360
el momento en el que se instanció

300
00:11:57,360 --> 00:11:59,120
el objeto, entonces bueno

301
00:11:59,120 --> 00:12:00,200
yo aquí para hacer la prueba

302
00:12:00,200 --> 00:12:03,060
he creado un gerente, he creado

303
00:12:03,060 --> 00:12:04,860
un empleado con fecha de contratación

304
00:12:04,860 --> 00:12:07,159
la del instante actual, porque new date

305
00:12:07,159 --> 00:12:09,019
te instancia un objeto date

306
00:12:09,019 --> 00:12:10,720
¿con qué fecha?

307
00:12:10,799 --> 00:12:13,000
con la fecha del momento, tiene el

308
00:12:13,000 --> 00:12:14,480
reloj del sistema accesible obviamente

309
00:12:14,480 --> 00:12:16,679
cualquier proceso

310
00:12:16,679 --> 00:12:18,980
cualquier proceso que se ejecuta, entre ellos un proceso

311
00:12:18,980 --> 00:12:20,220
de Java que se está ejecutando

312
00:12:20,220 --> 00:12:22,200
tiene acceso al reloj del sistema

313
00:12:22,200 --> 00:12:23,960
y el reloj del sistema te dice la fecha

314
00:12:23,960 --> 00:12:26,779
bueno, pues new date

315
00:12:26,779 --> 00:12:28,879
mira el reloj del sistema y te genera

316
00:12:28,879 --> 00:12:30,700
un objeto date con la fecha actual

317
00:12:30,700 --> 00:12:33,100
vale, entonces para hacer la prueba

318
00:12:33,100 --> 00:12:34,980
pues ya está

319
00:12:34,980 --> 00:12:39,019
pues venga, si ejecutamos esto

320
00:12:39,019 --> 00:12:41,019
errores de ejecución efectivamente no me van a salir

321
00:12:41,019 --> 00:12:43,080
luego bueno

322
00:12:43,080 --> 00:12:45,259
tiene toda la pinta de que esto funciona

323
00:12:45,259 --> 00:12:46,399
aunque

324
00:12:46,399 --> 00:12:48,600
para verificar si los ha agregado

325
00:12:48,600 --> 00:12:50,620
no estaría mal añadir en la clase

326
00:12:50,620 --> 00:12:52,059
empleado, perdón

327
00:12:52,059 --> 00:12:53,879
en la clase departamento

328
00:12:53,879 --> 00:12:56,559
un método que me muestre sus empleados

329
00:12:56,559 --> 00:12:58,580
para así ver los que tiene

330
00:12:58,580 --> 00:13:00,700
que esto no tardamos nada en hacerlo

331
00:13:00,700 --> 00:13:01,720
no estaría de más

332
00:13:01,720 --> 00:13:04,960
mostrar los empleados que tiene un departamento

333
00:13:04,960 --> 00:13:06,820
para ver si los ha añadido bien, etc

334
00:13:06,820 --> 00:13:09,280
y esto sería simplemente

335
00:13:09,280 --> 00:13:11,460
pues vamos a recorrer

336
00:13:11,460 --> 00:13:12,660
el array de empleados

337
00:13:12,660 --> 00:13:15,200
como es para consultar solo

338
00:13:15,200 --> 00:13:16,440
vamos a usar un for each

339
00:13:16,440 --> 00:13:23,320
para cada empleado

340
00:13:23,320 --> 00:13:27,140
en el array

341
00:13:27,140 --> 00:13:28,040
de empleados

342
00:13:28,039 --> 00:13:31,860
vale, pues vamos a mostrar el nombre

343
00:13:31,860 --> 00:13:34,360
.getNombre

344
00:13:34,360 --> 00:13:36,139
bueno, esto mostraría

345
00:13:36,139 --> 00:13:37,919
los empleados del

346
00:13:37,919 --> 00:13:40,179
departamento, aquí de nuevo

347
00:13:40,179 --> 00:13:41,819
esto ya es

348
00:13:41,819 --> 00:13:43,639
costumbre, hábito

349
00:13:43,639 --> 00:13:46,019
omitimos

350
00:13:46,019 --> 00:13:47,299
el dis, no lo omitimos

351
00:13:47,299 --> 00:13:49,719
en este caso de nuevo

352
00:13:49,719 --> 00:13:50,959
da exactamente igual

353
00:13:50,959 --> 00:13:53,939
si pongo dis, sabéis que se refiere

354
00:13:53,939 --> 00:13:55,759
el objeto que llame al método, que esté

355
00:13:55,759 --> 00:13:57,099
llamando al método en cada momento

356
00:13:57,100 --> 00:13:59,279
lo que le estoy llamando, o su propiedad

357
00:13:59,279 --> 00:14:01,159
de empleado. Pero es que como no hay más cosas

358
00:14:01,159 --> 00:14:03,060
que se llaman empleado, si yo quito el disk

359
00:14:03,060 --> 00:14:04,940
me referiría a ese array, no a más cosas.

360
00:14:05,700 --> 00:14:07,440
Entonces, lo ponéis,

361
00:14:07,519 --> 00:14:09,320
no lo ponéis, según os sea más cómodo

362
00:14:09,320 --> 00:14:10,680
para entender lo que estáis haciendo.

363
00:14:11,600 --> 00:14:13,220
Lo habitual es, pues,

364
00:14:13,259 --> 00:14:15,259
no ponerlo. Si no hace falta, no ponedlo. Pero bueno.

365
00:14:17,139 --> 00:14:19,159
Como veis aquí, bueno,

366
00:14:19,240 --> 00:14:21,279
nada. Venga, pues vamos a probar

367
00:14:21,279 --> 00:14:23,100
acá, vamos a volver a hacer este main, llamando

368
00:14:23,100 --> 00:14:25,220
a mostrar empleados, a ver si los ha añadido de verdad.

369
00:14:25,220 --> 00:14:28,060
no vaya a ser que no esté dando error de ejecución

370
00:14:28,060 --> 00:14:31,440
pero no esté funcionando la aplicación

371
00:14:31,440 --> 00:14:33,779
porque una cosa es dar error de ejecución

372
00:14:33,779 --> 00:14:36,019
que ahí ya obviamente la hemos fastidiado

373
00:14:36,019 --> 00:14:38,720
pero bueno, ahí ya sé que algo falla

374
00:14:38,720 --> 00:14:39,800
entonces me pondría a buscar

375
00:14:39,800 --> 00:14:41,899
y otra cosa es que no dé error de ejecución

376
00:14:41,899 --> 00:14:43,740
pero no esté haciendo lo que tenga que hacer

377
00:14:43,740 --> 00:14:44,980
eso es lo peligroso

378
00:14:44,980 --> 00:14:46,759
porque yo estoy vendiendo una aplicación

379
00:14:46,759 --> 00:14:47,759
que creo que funciona

380
00:14:47,759 --> 00:14:49,420
pero hace otras cosas diferentes

381
00:14:49,420 --> 00:14:51,000
para las que se concibió

382
00:14:51,000 --> 00:14:55,960
Vamos a mirar a ver si este ha agregado

383
00:14:55,960 --> 00:14:57,620
Los dos empleados Pepe y Pepe

384
00:14:57,620 --> 00:14:59,299
Bueno, vamos a cambiarles

385
00:14:59,299 --> 00:15:01,600
Que no se llamen igual

386
00:15:01,600 --> 00:15:02,059
Porque

387
00:15:02,059 --> 00:15:07,980
Bueno, pues sí

388
00:15:07,980 --> 00:15:10,059
Ha de empleado, parece que funciona

389
00:15:10,059 --> 00:15:11,259
Lo hemos hecho bien y ya está

390
00:15:11,259 --> 00:15:14,539
Venga, pues vámonos a

391
00:15:14,539 --> 00:15:18,320
Obtener el sueldo

392
00:15:18,320 --> 00:15:21,140
que aquí

393
00:15:21,140 --> 00:15:24,620
es donde hay una cosa curiosa

394
00:15:24,620 --> 00:15:25,379
vamos a ver

395
00:15:25,379 --> 00:15:26,940
de hecho esto

396
00:15:26,940 --> 00:15:28,720
lo voy a

397
00:15:28,720 --> 00:15:30,940
esto lo voy a borrar

398
00:15:31,620 --> 00:15:35,040
y esto lo voy a

399
00:15:35,040 --> 00:15:35,820
hacer así

400
00:15:35,820 --> 00:15:37,520
vale

401
00:15:37,520 --> 00:15:40,840
bueno pues que se os

402
00:15:40,840 --> 00:15:42,940
puede haber ocurrido a vosotros

403
00:15:42,940 --> 00:15:44,760
que es lo que habréis hecho supongo cuando habéis

404
00:15:44,760 --> 00:15:46,700
arrancado get sueldo total del departamento

405
00:15:46,700 --> 00:15:49,980
primero la pregunta que se hace uno de siempre es

406
00:15:49,980 --> 00:15:51,940
para obtener el sueldo total

407
00:15:51,940 --> 00:15:53,800
que paga ese departamento

408
00:15:53,800 --> 00:15:54,800
a sus empleados

409
00:15:54,800 --> 00:15:58,080
¿necesito alguna información externa desde fuera?

410
00:15:59,259 --> 00:16:00,100
pues me pregunto

411
00:16:00,100 --> 00:16:01,980
vamos a ver, ¿dónde está la información

412
00:16:01,980 --> 00:16:03,640
del sueldo de los empleados?

413
00:16:04,460 --> 00:16:05,940
la tienen los propios objetos

414
00:16:05,940 --> 00:16:07,420
empleados dentro, la tienen dentro

415
00:16:07,420 --> 00:16:09,920
¿y dónde están los

416
00:16:09,920 --> 00:16:11,259
empleados del departamento?

417
00:16:12,060 --> 00:16:14,000
los empleados del departamento están aquí

418
00:16:14,000 --> 00:16:15,980
arriba, dentro de la propia

419
00:16:15,980 --> 00:16:18,000
clase, entonces dentro

420
00:16:18,000 --> 00:16:19,800
de la propia clase están los empleados

421
00:16:19,800 --> 00:16:22,060
y a su vez los empleados tienen dentro

422
00:16:22,060 --> 00:16:24,019
su sueldo, luego no

423
00:16:24,019 --> 00:16:26,200
necesito pasarle al método

424
00:16:26,200 --> 00:16:26,639
este

425
00:16:26,639 --> 00:16:29,300
no necesito

426
00:16:29,300 --> 00:16:31,320
¿dónde está el método? aquí

427
00:16:31,320 --> 00:16:32,920
no necesito pasarle nada

428
00:16:32,920 --> 00:16:36,120
no necesito pasarle nada ahí, porque el sueldo

429
00:16:36,120 --> 00:16:37,759
de los empleados está dentro

430
00:16:37,759 --> 00:16:39,300
del empleado

431
00:16:39,300 --> 00:16:41,960
y el empleado está dentro

432
00:16:41,960 --> 00:16:43,560
de la RAI de la clase departamento

433
00:16:43,560 --> 00:16:45,700
luego ahí no hace falta pasarle nada

434
00:16:45,700 --> 00:17:15,000
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

435
00:17:15,700 --> 00:17:16,860
los elementos

436
00:17:16,860 --> 00:17:18,980
y en ese recorrido

437
00:17:18,980 --> 00:17:21,200
va sumando cada vez

438
00:17:21,200 --> 00:17:22,559
un nuevo salario

439
00:17:22,559 --> 00:17:24,240
por lo de siempre

440
00:17:24,240 --> 00:17:25,559
pues venga

441
00:17:25,559 --> 00:17:28,759
nuestra variable suma que se inicializa a cero

442
00:17:28,759 --> 00:17:30,740
que

443
00:17:30,740 --> 00:17:32,860
sumando se incorpora a la suma

444
00:17:32,860 --> 00:17:34,819
el sueldo de los empleados que están en la RAI

445
00:17:34,819 --> 00:17:37,059
pues venga, vamos a recorrer la RAI de empleados

446
00:17:37,059 --> 00:17:38,900
de nuevo lo estoy recorriendo

447
00:17:38,900 --> 00:17:40,779
con un for each por vaguería de escribir

448
00:17:40,779 --> 00:17:42,680
y porque solo estamos consultando

449
00:17:44,380 --> 00:17:44,860
vale

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

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

452
00:18:09,440 --> 00:18:11,320
es decir, vamos a ver

453
00:18:11,320 --> 00:18:14,600
el problema que nos encontramos con cada empleado

454
00:18:14,600 --> 00:18:16,600
del array es que por esto

455
00:18:16,600 --> 00:18:18,920
por esto de la herencia

456
00:18:18,920 --> 00:18:20,680
cada empleado

457
00:18:20,680 --> 00:18:21,820
del array, cada E

458
00:18:21,820 --> 00:18:24,360
cada empleado del array puede que sea

459
00:18:24,360 --> 00:18:26,480
empleado o puede que sea gerente

460
00:18:26,480 --> 00:18:28,480
no sabemos como se habrá instanciado

461
00:18:28,480 --> 00:18:29,140
no sabemos

462
00:18:29,140 --> 00:18:32,380
cada E del array se puede ver instanciado

463
00:18:32,380 --> 00:18:34,080
como empleado o gerente, por ejemplo

464
00:18:34,080 --> 00:18:36,400
en este main concreto por ejemplo

465
00:18:36,400 --> 00:18:37,420
el que hicimos las pruebas

466
00:18:37,420 --> 00:18:39,960
el primer elemento del array tiene un gerente

467
00:18:39,960 --> 00:18:42,200
pero el segundo elemento del array

468
00:18:42,200 --> 00:18:42,980
tiene un empleado

469
00:18:42,980 --> 00:18:45,420
en este concreto en el que hicimos las pruebas

470
00:18:45,420 --> 00:18:48,039
y en un departamento cualquiera

471
00:18:48,039 --> 00:18:50,580
en un departamento cualquiera

472
00:18:50,580 --> 00:18:51,480
en este array

473
00:18:51,480 --> 00:18:54,000
ya sabemos que en cada posición

474
00:18:54,000 --> 00:18:55,820
puede haber o un objeto

475
00:18:55,820 --> 00:18:57,480
que se instanció como new gerente

476
00:18:57,480 --> 00:18:59,539
o un objeto que se instanció como new empleado

477
00:18:59,539 --> 00:19:01,240
cualquiera de los dos cabe en el array

478
00:19:01,240 --> 00:19:03,380
pues entonces

479
00:19:03,380 --> 00:19:06,080
cuando habéis hecho

480
00:19:06,080 --> 00:19:07,340
este for each habéis dicho

481
00:19:07,339 --> 00:19:09,439
pues vaya

482
00:19:09,439 --> 00:19:12,299
como para cada E

483
00:19:12,299 --> 00:19:14,000
como obtengo yo el sueldo

484
00:19:14,000 --> 00:19:14,439
depende

485
00:19:14,439 --> 00:19:17,740
si es un gerente el sueldo será

486
00:19:17,740 --> 00:19:19,579
su salario más el bonos

487
00:19:19,579 --> 00:19:22,019
pero si es un empleado normal

488
00:19:22,019 --> 00:19:24,139
será su salario

489
00:19:24,139 --> 00:19:25,919
solo, entonces no nos queda más remedio

490
00:19:25,919 --> 00:19:27,939
que distinguir, a ver ese objeto

491
00:19:27,939 --> 00:19:29,819
E que es, ese objeto E

492
00:19:29,819 --> 00:19:31,599
como se instancia, a ver ese objeto E

493
00:19:31,599 --> 00:19:33,899
que es, vale pues una vez

494
00:19:33,899 --> 00:19:35,059
uno ha llegado a esa conclusión

495
00:19:35,059 --> 00:19:37,379
de que lo que se sume

496
00:19:37,379 --> 00:19:38,819
a la variable suma

497
00:19:38,819 --> 00:19:41,240
depende de si es empleado a secas

498
00:19:41,240 --> 00:19:42,460
o si es empleado

499
00:19:42,460 --> 00:19:44,159
además gerente,

500
00:19:45,039 --> 00:19:47,220
pues entonces ahí tendremos que hacer un if

501
00:19:47,220 --> 00:19:49,379
para distinguir cómo se instanció ese objeto.

502
00:19:50,500 --> 00:19:51,339
Bueno, pues una vez que me he llegado

503
00:19:51,339 --> 00:19:52,539
a esa conclusión diréis, vale,

504
00:19:53,079 --> 00:19:54,259
¿cómo puedo saber yo,

505
00:19:54,919 --> 00:19:56,980
dado una instancia cualquiera,

506
00:19:57,899 --> 00:19:59,759
si se instanció de una clase

507
00:19:59,759 --> 00:20:01,659
o de otra? ¿Cómo puedo saberlo?

508
00:20:02,039 --> 00:20:03,119
Con este operador

509
00:20:03,119 --> 00:20:04,480
que vimos el otro día, ¿no?

510
00:20:05,059 --> 00:20:07,179
Entonces, podríais haber construido algo así.

511
00:20:07,879 --> 00:20:10,740
Si el objeto E, en el que estoy yo en ese momento del array,

512
00:20:10,960 --> 00:20:13,119
se instanció como empleado,

513
00:20:14,099 --> 00:20:17,419
entonces a la variable suma le aporta solo su salario.

514
00:20:18,179 --> 00:20:19,460
Ya está, le aporta su salario.

515
00:20:20,159 --> 00:20:20,779
¿Vale? Está claro.

516
00:20:21,679 --> 00:20:22,379
Y si no,

517
00:20:23,679 --> 00:20:26,079
si no, entonces sería que se instanció como gerente.

518
00:20:27,359 --> 00:20:29,579
¿Vale? Porque en el array ese de empleados

519
00:20:29,579 --> 00:20:31,200
solamente caben o empleados o gerentes,

520
00:20:31,279 --> 00:20:32,099
no pueden caber más cosas.

521
00:20:32,100 --> 00:20:35,520
porque está declarado como array de tipo empleado

522
00:20:35,520 --> 00:20:36,940
y si no

523
00:20:36,940 --> 00:20:38,980
pues entonces le sumo el salario

524
00:20:38,980 --> 00:20:41,180
pero además le tengo que sumar el bonus

525
00:20:41,180 --> 00:20:42,600
¿verdad?

526
00:20:43,460 --> 00:20:45,120
le sumo el salario y además le tengo que sumar el bonus

527
00:20:45,120 --> 00:20:47,240
y aquí es donde habréis encontrado

528
00:20:47,240 --> 00:20:49,140
el problema, pues si uno más o menos

529
00:20:49,140 --> 00:20:50,040
ha trabajado así

530
00:20:50,040 --> 00:20:52,940
habréis encontrado el problema de

531
00:20:52,940 --> 00:20:55,020
¡uh! el salario estupendo

532
00:20:55,020 --> 00:20:56,760
pero el bonus

533
00:20:56,760 --> 00:20:58,200
no puedo sacarlo de él

534
00:20:58,200 --> 00:21:01,060
claro, ya lo sabemos, es con lo que hemos estado

535
00:21:01,060 --> 00:21:01,860
trabajando estos días

536
00:21:01,860 --> 00:21:03,700
el compilador

537
00:21:03,700 --> 00:21:06,140
no mira como se instanció ese objeto

538
00:21:06,140 --> 00:21:07,320
porque ni siquiera lo sabe

539
00:21:07,320 --> 00:21:10,060
porque aquí todavía no hay ningún programa ejecutándose

540
00:21:10,060 --> 00:21:11,980
aquí hay variables declaradas

541
00:21:11,980 --> 00:21:14,200
y el compilador lo único que mira es

542
00:21:14,200 --> 00:21:15,900
oye, perdona, que

543
00:21:15,900 --> 00:21:17,980
está declarado como empleado

544
00:21:17,980 --> 00:21:20,340
que luego tú cuando lo instancias metes un gerente

545
00:21:20,340 --> 00:21:21,800
genial, puedes meter lo que te dé la gana

546
00:21:21,800 --> 00:21:24,140
pero está declarado como empleado

547
00:21:24,140 --> 00:21:25,920
y la clase empleado

548
00:21:25,920 --> 00:21:27,360
si yo me voy a mirarla

549
00:21:27,360 --> 00:21:30,620
lo siento mucho pero en la clase empleado no hay un get bonus

550
00:21:30,620 --> 00:21:33,580
no lo hay, solo lo hay en la clase gerente

551
00:21:33,580 --> 00:21:35,640
¿vale? así es como funciona

552
00:21:35,640 --> 00:21:37,620
el compilador, como ya sabemos, lo hemos repetido

553
00:21:37,620 --> 00:21:39,520
varias veces, él va mirando

554
00:21:39,520 --> 00:21:41,480
si todo casa y cuadra según

555
00:21:41,480 --> 00:21:42,940
lo que hay declarado y escrito

556
00:21:42,940 --> 00:21:45,420
¿vale? pero eso ya sabemos

557
00:21:45,420 --> 00:21:47,520
cómo solucionarlo, es decir, ya, pero es que yo sé

558
00:21:47,520 --> 00:21:49,380
que se ha instanciado como

559
00:21:49,380 --> 00:21:50,980
gerente, porque estoy en esta rama

560
00:21:50,980 --> 00:21:53,420
no estoy en la rama de que se ha instanciado como empleado

561
00:21:53,420 --> 00:21:55,440
sino en la otra, entonces como sé que

562
00:21:55,440 --> 00:21:57,440
se ha instanciado como gerente, le hago

563
00:21:57,440 --> 00:21:59,640
el casting y ya, si ya le he hecho

564
00:21:59,640 --> 00:22:01,500
el casting, el compilador

565
00:22:01,500 --> 00:22:03,280
entonces ya se va a mirar la clase gerente

566
00:22:03,280 --> 00:22:05,900
y ahí sí que va a ver que hay un get bonus, entonces ya se callará

567
00:22:05,900 --> 00:22:07,800
vale, pues le hacemos

568
00:22:07,800 --> 00:22:08,540
el casting

569
00:22:08,540 --> 00:22:13,780
vale, se lo vamos a poner a mano

570
00:22:13,780 --> 00:22:17,400
para no tirar tanto de...

571
00:22:17,400 --> 00:22:18,840
y entonces

572
00:22:18,840 --> 00:22:21,820
si le hacemos el casting a

573
00:22:21,820 --> 00:22:24,320
gerente

574
00:22:24,320 --> 00:22:27,660
recordad que el casting es por entre paréntesis

575
00:22:27,660 --> 00:22:29,259
el tipo al que yo hago el casting

576
00:22:29,259 --> 00:22:31,640
pues si le hago el casting a gerente

577
00:22:31,640 --> 00:22:33,059
todo este objeto ya

578
00:22:33,059 --> 00:22:34,879
con el casting hecho

579
00:22:34,879 --> 00:22:37,079
todo ese objeto con el casting hecho

580
00:22:37,079 --> 00:22:39,579
ya, al ser de la clase gerente

581
00:22:39,579 --> 00:22:41,079
el compilador dice, ah, fenomenal

582
00:22:41,079 --> 00:22:43,119
esto es de la clase gerente

583
00:22:43,119 --> 00:22:45,900
porque has hecho el casting, voy a mirar en la declaración de gerente

584
00:22:45,900 --> 00:22:48,000
efectivamente en la declaración

585
00:22:48,000 --> 00:22:49,799
de la clase gerente hay un

586
00:22:49,799 --> 00:22:51,119
método getBonus

587
00:22:51,119 --> 00:22:52,900
magnífico

588
00:22:52,900 --> 00:22:55,519
vale, pues entonces

589
00:22:55,519 --> 00:22:57,599
una vez que ya he terminado el for

590
00:22:57,600 --> 00:23:00,020
he sumado todo, pues devuelvo la suma

591
00:23:00,020 --> 00:23:01,160
y se acabó

592
00:23:01,160 --> 00:23:03,260
bueno, le habéis sentido a este método, ¿no?

593
00:23:03,860 --> 00:23:05,340
es una suma acumulativa

594
00:23:05,340 --> 00:23:06,660
que recorre todo el array

595
00:23:06,660 --> 00:23:08,660
y para cada elemento del array

596
00:23:08,660 --> 00:23:11,820
ese empleado solo aporta su salario

597
00:23:11,820 --> 00:23:12,920
no

598
00:23:12,920 --> 00:23:15,120
con lo cual gerente, porque son dos alternativas

599
00:23:15,120 --> 00:23:17,380
dos empleados, gerente, no caben más cosas en empleado

600
00:23:17,380 --> 00:23:17,920
no caben más

601
00:23:17,920 --> 00:23:21,280
pues entonces le sumo el salario más el bonus

602
00:23:21,280 --> 00:23:22,860
para el cual he tenido que hacer el casting

603
00:23:22,860 --> 00:23:24,980
para que el compilador me deje

604
00:23:24,980 --> 00:23:27,380
¿vale?

605
00:23:27,380 --> 00:23:29,400
Bueno, ya habéis sentido el método, ¿no?

606
00:23:30,740 --> 00:23:31,500
Sí, sí, sí.

607
00:23:32,280 --> 00:23:32,460
¿Vale?

608
00:23:32,500 --> 00:23:34,240
Pero a esto que he hecho yo lo habéis sentido, ¿no?

609
00:23:34,580 --> 00:23:34,940
Vale.

610
00:23:35,040 --> 00:23:36,020
Bueno, vamos a ejecutarlo.

611
00:23:37,820 --> 00:23:38,180
Vale.

612
00:23:40,840 --> 00:23:46,160
Entonces, yo ahora voy a meter numeritos para que sea fácil.

613
00:23:46,900 --> 00:23:54,920
Voy a meter un gerente que tiene sueldo 10 y bonus otros 10.

614
00:23:54,920 --> 00:23:56,920
y luego un empleado

615
00:23:56,920 --> 00:23:58,120
que tiene sueldo 10

616
00:23:58,120 --> 00:24:00,660
con lo cual cuando yo llame al sueldo total

617
00:24:00,660 --> 00:24:02,039
de departamento y lo muestre

618
00:24:02,039 --> 00:24:04,500
me deberá salir 30

619
00:24:04,500 --> 00:24:06,080
¿verdad? los 20

620
00:24:06,080 --> 00:24:08,539
del PP1 y los 10 del este

621
00:24:08,539 --> 00:24:09,880
30 me debería salir

622
00:24:09,880 --> 00:24:11,440
vale

623
00:24:11,440 --> 00:24:14,340
pues vamos a ejecutarlo

624
00:24:14,340 --> 00:24:18,539
pues no me sale 30

625
00:24:18,539 --> 00:24:19,480
me sale 20

626
00:24:19,480 --> 00:24:22,380
da la sensación de que el bonus del gerente

627
00:24:22,380 --> 00:24:23,019
no lo ha metido

628
00:24:23,019 --> 00:24:28,240
Pues algo pasa

629
00:24:28,240 --> 00:24:31,639
¿Vale?

630
00:24:35,759 --> 00:24:37,059
Vale, entonces

631
00:24:37,059 --> 00:24:41,379
Si lo habéis organizado de otra manera

632
00:24:41,379 --> 00:24:43,480
A lo mejor no os habéis encontrado con esta situación

633
00:24:43,480 --> 00:24:45,299
Pero yo la he provocado a propósito

634
00:24:45,299 --> 00:24:48,039
La he provocado para que entendamos lo que ha pasado

635
00:24:48,039 --> 00:24:49,359
La he provocado a propósito

636
00:24:49,359 --> 00:24:51,579
¿Vale? Entonces

637
00:24:51,579 --> 00:24:52,500
¿Qué ha pasado aquí?

638
00:24:53,019 --> 00:24:55,839
Bueno, pues lo que ocurre es que cuando se instancia

639
00:24:55,839 --> 00:25:00,460
un objeto gerente, fijaos lo que está ocurriendo.

640
00:25:01,160 --> 00:25:04,400
Aquí en nuestro main hemos instanciado un objeto gerente.

641
00:25:05,740 --> 00:25:07,619
Este, ¿vale?

642
00:25:08,819 --> 00:25:11,039
Gerente, cuando se instanció, ¿vale?

643
00:25:11,119 --> 00:25:14,619
Gerente se apoyó en el constructor del de arriba, empleado.

644
00:25:14,859 --> 00:25:16,400
Se apoyó en el constructor del de arriba.

645
00:25:17,460 --> 00:25:19,960
Vale, entonces, ¿qué hace en realidad InstanceOff?

646
00:25:20,180 --> 00:25:22,099
¿Qué está haciendo el InstanceOff este de aquí?

647
00:25:23,019 --> 00:25:44,420
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.

648
00:25:44,420 --> 00:25:45,660
a los dos

649
00:25:45,660 --> 00:25:48,100
con lo cual el instance off

650
00:25:48,100 --> 00:25:49,720
cuando se ha encontrado un gerente

651
00:25:49,720 --> 00:25:51,900
este ya ha dado true

652
00:25:51,900 --> 00:25:53,400
este ya ha dado true

653
00:25:53,400 --> 00:25:55,700
entonces como este ya ha dado true no se ha ido al else

654
00:25:55,700 --> 00:25:57,620
¿vale?

655
00:25:58,240 --> 00:25:59,259
eso es lo que ha ocurrido

656
00:25:59,259 --> 00:26:02,000
y se da en esta combinación

657
00:26:02,000 --> 00:26:03,300
que yo he provocado a propósito

658
00:26:03,300 --> 00:26:05,980
para que nos demos cuenta de eso

659
00:26:05,980 --> 00:26:06,920
para que lo registremos

660
00:26:06,920 --> 00:26:09,960
si tú tienes una referencia, tú tienes dos clases

661
00:26:09,960 --> 00:26:12,120
animal y gato

662
00:26:12,120 --> 00:26:13,560
¿vale?

663
00:26:13,559 --> 00:26:15,519
y ahora instancia es gato, new gato

664
00:26:15,519 --> 00:26:18,079
y ahora haces el instance of

665
00:26:18,079 --> 00:26:19,579
de esa referencia, te va a dar true

666
00:26:19,579 --> 00:26:22,079
tanto si lo haces para gato como para

667
00:26:22,079 --> 00:26:24,019
animal, te va a dar true porque

668
00:26:24,019 --> 00:26:25,519
pertenece a ambas en realidad

669
00:26:25,519 --> 00:26:28,480
el instance of te detecta que pertenece a las dos

670
00:26:28,480 --> 00:26:30,599
te va a dar true en ambas

671
00:26:30,599 --> 00:26:32,339
sin embargo si lo has instanciado

672
00:26:32,339 --> 00:26:34,179
como animal solamente, solo te va a dar true

673
00:26:34,179 --> 00:26:35,079
en animal, en gato no

674
00:26:35,079 --> 00:26:37,819
pero si lo has instanciado como la subclase

675
00:26:37,819 --> 00:26:39,859
el instance of te va a dar true

676
00:26:39,859 --> 00:26:42,000
en ambas, entonces eso

677
00:26:42,000 --> 00:26:44,720
en función de cómo lo hayas programado tú

678
00:26:44,720 --> 00:26:46,700
pues te puede dar situaciones

679
00:26:46,700 --> 00:26:48,799
que en este caso

680
00:26:48,799 --> 00:26:50,640
es fácil de detectar porque estamos haciendo esta prueba en concreto

681
00:26:50,640 --> 00:26:52,380
pero entra una aplicación enorme

682
00:26:52,380 --> 00:26:54,940
donde ese resultado luego se encadena

683
00:26:54,940 --> 00:26:56,839
y se pasa a otro y luego a otro y luego a otro

684
00:26:56,839 --> 00:26:57,559
vete a saber

685
00:26:57,559 --> 00:27:00,619
cómo averiguas tú que el resultado final

686
00:27:00,619 --> 00:27:01,740
¿por qué no es el que es?

687
00:27:03,400 --> 00:27:04,900
bueno pues a lo mejor es que en algún

688
00:27:04,900 --> 00:27:07,000
momento de tu cadena de miles de llamadas

689
00:27:07,000 --> 00:27:08,740
se te ha colado algo de esto

690
00:27:08,740 --> 00:27:10,400
y es

691
00:27:10,400 --> 00:27:12,660
que cuando un objeto, un segundito, termino la frase

692
00:27:12,660 --> 00:27:15,060
que cuando un objeto está instanciado

693
00:27:15,060 --> 00:27:16,100
como una subclase

694
00:27:16,100 --> 00:27:19,240
el instance of te da true

695
00:27:19,240 --> 00:27:21,100
si lo pruebas para esa subclase

696
00:27:21,100 --> 00:27:22,540
y para las superclases

697
00:27:22,540 --> 00:27:24,740
o lo que es lo mismo, cualquier objeto

698
00:27:24,740 --> 00:27:26,519
si le hacéis un instance of the object

699
00:27:26,519 --> 00:27:27,680
va a dar true también

700
00:27:27,680 --> 00:27:30,400
¿vale? entonces

701
00:27:30,400 --> 00:27:32,840
esto simplemente si lo habéis

702
00:27:32,840 --> 00:27:34,480
hecho de casualidad o como sea

703
00:27:34,480 --> 00:27:36,960
en otro orden, pues no os habréis encontrado

704
00:27:36,960 --> 00:27:38,780
con esto, imaginaos que yo lo he hecho al revés

705
00:27:38,779 --> 00:27:41,940
y he dicho, si está instanciado como gerente

706
00:27:41,940 --> 00:27:44,099
entonces hago lo de abajo

707
00:27:44,099 --> 00:27:51,819
y si no está instanciado

708
00:27:51,819 --> 00:27:53,920
como gerente, entonces hago esto

709
00:27:53,920 --> 00:27:56,000
si yo lo he hecho así

710
00:27:56,000 --> 00:27:57,899
ya está, esto ya va a estar perfecto

711
00:27:57,899 --> 00:27:59,700
si está instanciado

712
00:27:59,700 --> 00:28:01,639
como gerente, suma todo

713
00:28:01,639 --> 00:28:04,079
y si es un empleado

714
00:28:04,079 --> 00:28:05,559
suelto, este va a ser falso

715
00:28:05,559 --> 00:28:07,139
obviamente, porque es de la super clase

716
00:28:07,140 --> 00:28:10,120
Entonces si es un empleado suelto

717
00:28:10,120 --> 00:28:11,200
Entonces ya

718
00:28:11,200 --> 00:28:12,620
Si que se meterá aquí

719
00:28:12,620 --> 00:28:15,040
Si lo habéis hecho en este orden

720
00:28:15,040 --> 00:28:16,500
Esto ya si que va a funcionar

721
00:28:16,500 --> 00:28:18,020
Vamos a comprobarlo

722
00:28:18,020 --> 00:28:19,000
Y ahora me dices lo que

723
00:28:19,000 --> 00:28:22,340
Vale

724
00:28:22,340 --> 00:28:24,980
Entonces si yo ahora ejecuto esto

725
00:28:24,980 --> 00:28:29,860
Pues este ya si

726
00:28:29,860 --> 00:28:31,620
Este ya si, este ya me da 30

727
00:28:31,620 --> 00:28:33,860
Vale

728
00:28:33,860 --> 00:28:34,620
Este ya si

729
00:28:34,620 --> 00:28:40,320
¿vale?

730
00:28:41,000 --> 00:28:42,320
entonces hombre, pues

731
00:28:42,320 --> 00:28:45,180
si uno

732
00:28:45,180 --> 00:28:47,300
es consciente

733
00:28:47,300 --> 00:28:49,440
de eso, pues mejor

734
00:28:49,440 --> 00:28:51,600
para que no sea de casualidad

735
00:28:51,600 --> 00:28:53,420
que lo ha hecho bien, sino que además sea consciente

736
00:28:53,420 --> 00:28:55,520
no vaya a ser que en algún momento lo haga de otra manera

737
00:28:55,520 --> 00:28:56,720
y les haga errores por ahí

738
00:28:56,720 --> 00:28:58,280
¿vale?

739
00:28:59,100 --> 00:29:01,160
entonces, ¿entendéis eso, no?

740
00:29:02,160 --> 00:29:03,300
que si un objeto está

741
00:29:03,300 --> 00:29:04,480
instanciado de una clase

742
00:29:04,480 --> 00:29:06,360
y usáis instance of para algo

743
00:29:06,360 --> 00:29:07,279
porque lo necesitáis

744
00:29:07,279 --> 00:29:09,480
ese instance of va a dar true

745
00:29:09,480 --> 00:29:11,420
tanto si lo probáis con esa clase

746
00:29:11,420 --> 00:29:13,140
como cualquiera de las superclases

747
00:29:13,140 --> 00:29:14,700
va a dar true en todas

748
00:29:14,700 --> 00:29:21,860
es que ya no va a entrar en el safe

749
00:29:21,860 --> 00:29:23,220
porque if, el safe

750
00:29:23,220 --> 00:29:26,220
esa sentencia de decisión

751
00:29:26,220 --> 00:29:27,299
si ya te ha entrado en una rama

752
00:29:27,299 --> 00:29:29,120
ya no entran las otras, ya no las comprueba

753
00:29:29,120 --> 00:29:31,059
sería true en ambas

754
00:29:31,059 --> 00:29:32,940
pero es que a la segunda no se plantea entrar ya

755
00:29:32,940 --> 00:29:34,460
son excluyentes

756
00:29:34,460 --> 00:29:38,680
si no lo haces en un if-else-if

757
00:29:38,680 --> 00:29:39,779
entonces sí, imagínate, haces

758
00:29:39,779 --> 00:29:42,059
if este que es salario, y luego haces otra vez

759
00:29:42,059 --> 00:29:43,759
y no sé qué, le sumas el bonus

760
00:29:43,759 --> 00:29:46,340
entonces ya sí, pero porque lo hagas en ramas

761
00:29:46,340 --> 00:29:48,799
separadas, entonces fuerzas a que compruebe todas las condiciones

762
00:29:48,799 --> 00:29:50,660
no sé si me explico

763
00:29:50,660 --> 00:29:52,500
claro, entonces sí, pero si lo haces

764
00:29:52,500 --> 00:29:54,759
en un if-else-if, o te hace una, o te hace la otra

765
00:29:54,759 --> 00:29:55,720
porque son excluyentes

766
00:29:55,720 --> 00:29:56,900
¿vale?

767
00:29:57,860 --> 00:30:00,400
entonces imagino que, bueno, habréis hecho algo así

768
00:30:00,400 --> 00:30:02,360
o que otra cosa

769
00:30:02,360 --> 00:30:04,640
a lo mejor os habéis planteado hacer cambiando el diseño

770
00:30:04,640 --> 00:30:05,880
que podéis hacer lo que os dé la gana.

771
00:30:06,580 --> 00:30:08,440
Pues os podéis haber empleado, o habéis planteado

772
00:30:08,440 --> 00:30:10,300
justo el instance of, es un rollo, esto

773
00:30:10,300 --> 00:30:12,280
tendrá que hacer un casting, pues os habéis planteado

774
00:30:12,280 --> 00:30:14,280
hombre, voy a hacer un método en la clase

775
00:30:14,280 --> 00:30:16,160
empleado, que me devuelva el sueldo total

776
00:30:16,160 --> 00:30:18,560
y ya lo sobrescribo

777
00:30:18,560 --> 00:30:19,620
en el gerente.

778
00:30:20,560 --> 00:30:22,440
Entonces, se queda

779
00:30:22,440 --> 00:30:23,520
esto más bonito.

780
00:30:24,960 --> 00:30:26,360
¿No? Pero claro, tiene que tener uno

781
00:30:26,360 --> 00:30:28,120
la opción de modificar las clases.

782
00:30:28,940 --> 00:30:30,640
Si uno tiene la opción de modificar las clases,

783
00:30:30,820 --> 00:30:32,060
pues se hace aquí su método

784
00:30:32,059 --> 00:30:43,220
get sueldo total

785
00:30:43,220 --> 00:30:44,940
¿vale?

786
00:30:45,019 --> 00:30:46,039
entonces para empleado

787
00:30:46,039 --> 00:30:47,599
el sueldo total de empleado

788
00:30:47,599 --> 00:30:49,919
pues va a ser el salario

789
00:30:49,919 --> 00:30:51,759
es que esto va a ser como el get en realidad

790
00:30:51,759 --> 00:30:54,139
pero claro

791
00:30:54,139 --> 00:30:56,099
lo tengo que poner para luego sobre escribirlo

792
00:30:56,099 --> 00:30:56,539
en la otra

793
00:30:56,539 --> 00:31:00,019
vale entonces este será

794
00:31:00,019 --> 00:31:01,960
simplemente return para el empleado

795
00:31:01,960 --> 00:31:04,279
normal, devolvemos el salario

796
00:31:04,279 --> 00:31:05,840
y ya está, pero

797
00:31:05,840 --> 00:31:07,500
lo podemos sobreescribir en gestor

798
00:31:07,500 --> 00:31:08,920
perdón, en gerente

799
00:31:08,920 --> 00:31:12,200
este mismo lo sobreescribimos en gerente

800
00:31:12,200 --> 00:31:15,980
lo sobreescribimos

801
00:31:15,980 --> 00:31:16,380
aquí

802
00:31:16,380 --> 00:31:21,700
y aquí que me dé esto

803
00:31:25,900 --> 00:31:26,799
y aquí

804
00:31:26,799 --> 00:31:27,759
como es privada

805
00:31:27,759 --> 00:31:30,299
si tuviera protected

806
00:31:30,299 --> 00:31:31,860
podría haber accedido directamente

807
00:31:31,860 --> 00:31:34,160
pero como no tengo protected sino privada

808
00:31:34,160 --> 00:31:35,880
solo puedo acceder a salario

809
00:31:35,880 --> 00:31:37,460
al estar escrito en la super clase

810
00:31:37,460 --> 00:31:39,560
solo puedo acceder a salario con el get

811
00:31:39,560 --> 00:31:42,080
a menos que le ponga el protected, repito

812
00:31:42,080 --> 00:31:43,960
vale, pues ya está

813
00:31:43,960 --> 00:31:45,860
con este

814
00:31:45,860 --> 00:31:47,800
get sueldo total, este método

815
00:31:47,800 --> 00:31:49,040
que nos hemos inventado aquí

816
00:31:49,040 --> 00:31:51,620
porque hemos podido modificar las clases

817
00:31:51,620 --> 00:31:53,040
pues

818
00:31:53,040 --> 00:31:55,160
el método departamento

819
00:31:55,160 --> 00:31:57,900
de get sueldo total de departamento

820
00:31:57,900 --> 00:32:00,160
pues esta parte de aquí

821
00:32:00,160 --> 00:32:03,000
en lugar de hacerla con este instant off

822
00:32:03,000 --> 00:32:03,800
y todo este rollo

823
00:32:03,800 --> 00:32:06,440
pues

824
00:32:06,440 --> 00:32:08,720
quedaría más bonita

825
00:32:08,720 --> 00:32:10,660
si ponemos

826
00:32:10,660 --> 00:32:12,080
suma más igual

827
00:32:12,080 --> 00:32:14,920
punto get sueldo total

828
00:32:14,920 --> 00:32:18,300
y ahora ya gracias al

829
00:32:18,300 --> 00:32:20,680
gracias al polimorfismo

830
00:32:20,680 --> 00:32:22,660
cuando esto se ejecute

831
00:32:22,660 --> 00:32:24,660
la máquina virtual dirá, a ver tú que eres

832
00:32:24,660 --> 00:32:26,100
eres gerente

833
00:32:26,100 --> 00:32:28,259
pues llamo a get sueldo total de gerente

834
00:32:28,259 --> 00:32:30,680
perfecto, ¿qué eres empleado?

835
00:32:31,319 --> 00:32:32,420
pues llamo a getSoldOtal

836
00:32:32,420 --> 00:32:32,940
empleado

837
00:32:32,940 --> 00:32:36,440
esta es la ventaja del polimorfismo

838
00:32:36,440 --> 00:32:39,019
el getSoldOtal que se va a ejecutar

839
00:32:39,019 --> 00:32:40,660
es el de gerente, es el de empleado

840
00:32:40,660 --> 00:32:42,359
dependiendo de lo que sea este objeto

841
00:32:42,359 --> 00:32:44,799
para nosotros en el momento de hacer la clase es que nos da igual

842
00:32:44,799 --> 00:32:45,900
nos da lo mismo

843
00:32:45,900 --> 00:32:51,039
cuidado siempre con las sobrescrituras

844
00:32:51,039 --> 00:32:52,740
para que todo esto case y funcione

845
00:32:52,740 --> 00:32:54,599
este método

846
00:32:54,599 --> 00:32:56,740
tiene que estar sobrescribiendo

847
00:32:56,740 --> 00:32:57,339
el de arriba

848
00:32:57,340 --> 00:33:01,500
y sobreescribirlo significa que su cabecera sea idéntica

849
00:33:01,500 --> 00:33:02,780
no me vaya a ver yo confundido

850
00:33:02,780 --> 00:33:06,820
y la mejor manera de asegurarnos de que su cabecera es idéntica

851
00:33:06,820 --> 00:33:07,800
y yo no me he confundido

852
00:33:07,800 --> 00:33:13,020
es poner esta anotación

853
00:33:13,020 --> 00:33:15,860
pero bueno, ya son cosas un poquito más

854
00:33:15,860 --> 00:33:18,560
que podéis hasta olvidar como si no lo hubiera dicho

855
00:33:18,560 --> 00:33:21,380
lo importante es que para que un método

856
00:33:21,380 --> 00:33:23,620
esté sobreescribiendo y pisando el de arriba

857
00:33:23,620 --> 00:33:26,620
la cabecera tiene que ser idéntica

858
00:33:26,620 --> 00:33:28,880
vale

859
00:33:28,880 --> 00:33:33,380
entonces esta anotación verifica

860
00:33:33,380 --> 00:33:35,460
que la cabecera, que hay un método

861
00:33:35,460 --> 00:33:36,860
arriba con una cabecera igual que esa

862
00:33:36,860 --> 00:33:39,500
lo verifica, bueno pues entonces

863
00:33:39,500 --> 00:33:41,260
ahora ya, hecho así este

864
00:33:41,260 --> 00:33:43,520
con esta

865
00:33:43,520 --> 00:33:44,880
variante, con este método

866
00:33:44,880 --> 00:33:47,200
esto queda mejor, queda más bonito

867
00:33:47,200 --> 00:33:48,080
queda más

868
00:33:48,080 --> 00:33:51,640
y esto debería darme 30 otra vez

869
00:33:51,640 --> 00:33:52,780
si lo hemos hecho bien

870
00:33:52,780 --> 00:33:54,320
y efectivamente nos da 30

871
00:33:54,320 --> 00:33:55,820
vale

872
00:33:55,819 --> 00:33:58,679
Vale, a ver

873
00:33:58,679 --> 00:34:00,279
Del resto de las clases

874
00:34:00,279 --> 00:34:02,259
¿Habéis ido avanzando?

875
00:34:04,019 --> 00:34:05,039
¿Estáis en ello?

876
00:34:07,399 --> 00:34:09,000
¿Seguís por vuestra cuenta?

877
00:34:09,599 --> 00:34:10,159
¿Otro rato?

878
00:34:12,420 --> 00:34:14,019
¿Decís algo o no decís nada?

879
00:34:16,179 --> 00:34:17,360
¿Que continúe yo?

880
00:34:19,519 --> 00:34:20,679
De verdad, ¿eh?

881
00:34:20,679 --> 00:34:22,159
¿Por qué lo tenemos que hacer siempre todos nosotras?

882
00:34:22,980 --> 00:34:23,380
En fin

883
00:34:23,380 --> 00:34:24,880
Bueno, vale

884
00:34:24,880 --> 00:34:29,160
vale, vale, seguimos

885
00:34:29,160 --> 00:34:31,619
si, si, si me parece bien

886
00:34:31,619 --> 00:34:34,240
yo lo que no quiero es que

887
00:34:34,240 --> 00:34:36,559
os olvidéis del cerebro

888
00:34:36,559 --> 00:34:36,960
vuestro

889
00:34:36,960 --> 00:34:45,980
venga, a ver que

890
00:34:45,980 --> 00:34:48,280
a ver que cosas raras hay por aquí

891
00:34:48,280 --> 00:34:52,079
venga, empleado y departamento

892
00:34:52,079 --> 00:34:54,220
ya tenemos su arquitectura, es una jerarquía

893
00:34:54,220 --> 00:34:57,180
con empleado

894
00:34:57,180 --> 00:34:59,040
gerente y luego un departamento

895
00:34:59,040 --> 00:35:01,000
esto pues en base de datos

896
00:35:01,000 --> 00:35:02,760
hay unas tablas, tabla de departamento

897
00:35:02,760 --> 00:35:04,700
tabla, no sé cómo mapeáis

898
00:35:04,700 --> 00:35:06,640
los temas de herencia en modelo relacional

899
00:35:06,640 --> 00:35:07,780
bueno, da igual

900
00:35:07,780 --> 00:35:12,060
vale, pues venga

901
00:35:12,060 --> 00:35:13,740
seguimos con clases

902
00:35:13,740 --> 00:35:16,600
empresa, tiene nombre

903
00:35:16,600 --> 00:35:18,860
y los departamentos, pues ya está

904
00:35:18,860 --> 00:35:20,000
empresa

905
00:35:20,000 --> 00:35:22,760
yo aquí, aunque esto es feo

906
00:35:22,760 --> 00:35:24,860
para ahora subirlo al aula virtual

907
00:35:24,860 --> 00:35:26,820
todos juntos, los que vayamos corrigiendo

908
00:35:26,820 --> 00:35:28,960
en clase, pues en un único proyecto

909
00:35:28,960 --> 00:35:30,220
ejercicio herencia estoy metiendo

910
00:35:30,220 --> 00:35:33,100
en un paquete todas las clases enteras

911
00:35:33,100 --> 00:35:34,820
pero normal es que se vayan separando

912
00:35:34,820 --> 00:35:36,340
por modelo, patatín, pero bueno

913
00:35:36,340 --> 00:35:40,960
entonces, vámonos

914
00:35:40,960 --> 00:35:42,240
a empresa

915
00:35:42,240 --> 00:35:48,620
ahí

916
00:35:48,620 --> 00:35:50,540
empresa, pues venga, una clase nueva

917
00:35:52,760 --> 00:35:56,560
Empresa no hereda de nadie

918
00:35:56,560 --> 00:35:57,740
Luego hereda de object

919
00:35:57,740 --> 00:36:00,180
Y empresa pues teníamos

920
00:36:00,180 --> 00:36:01,800
Dicho sus propiedades, nombre

921
00:36:01,800 --> 00:36:03,680
Y conjunto de departamentos

922
00:36:03,680 --> 00:36:08,120
A ver

923
00:36:08,120 --> 00:36:09,780
Prida

924
00:36:09,780 --> 00:36:17,460
Ala

925
00:36:17,460 --> 00:36:19,420
Los departamentos de la empresa

926
00:36:19,420 --> 00:36:21,300
Departamentos

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

928
00:36:36,300 --> 00:36:39,420
A ver

929
00:36:39,420 --> 00:36:43,460
Relax

930
00:36:43,460 --> 00:36:51,320
Vale, pues nada

931
00:36:51,320 --> 00:36:53,240
Constructor sin parámetros

932
00:36:53,240 --> 00:36:56,960
Constructor con parámetros

933
00:36:56,960 --> 00:36:59,720
Get y set

934
00:37:06,300 --> 00:37:17,440
vale

935
00:37:17,440 --> 00:37:20,039
una cosita, fijaos que aquí

936
00:37:20,039 --> 00:37:20,680
hay un empleado

937
00:37:20,680 --> 00:37:23,940
que hemos puesto el toString para decir

938
00:37:23,940 --> 00:37:26,039
bueno, pues no está mal, por si alguna vez

939
00:37:26,039 --> 00:37:28,300
queremos mostrar un empleado de golpe

940
00:37:28,300 --> 00:37:29,640
así en el system.out.println

941
00:37:29,640 --> 00:37:32,100
pues nos podríamos haber aprovechado

942
00:37:32,100 --> 00:37:32,980
de él, que me he olvidado

943
00:37:32,980 --> 00:37:35,019
en el método mostrar empleados

944
00:37:35,019 --> 00:37:37,340
el método mostrar empleados

945
00:37:37,340 --> 00:37:40,259
que está en departamento

946
00:37:40,259 --> 00:37:43,579
yo he mostrado el nombre

947
00:37:43,579 --> 00:37:45,940
porque me había olvidado

948
00:37:45,940 --> 00:37:47,719
de que había hecho un toString en empleado

949
00:37:47,719 --> 00:37:49,800
si no me olvido de que hay un toString en empleado

950
00:37:49,800 --> 00:37:51,840
muestro el objeto empleado

951
00:37:51,840 --> 00:37:53,599
directamente, muestro

952
00:37:53,599 --> 00:37:56,380
recordáis que hacía System.out.println

953
00:37:56,380 --> 00:37:57,759
este método, lo dijimos el otro día

954
00:37:57,759 --> 00:37:59,820
pues coge lo que le pasemos aquí

955
00:37:59,820 --> 00:38:00,639
y llama toString

956
00:38:00,639 --> 00:38:06,779
Claro, pero si yo quiero mostrarlo todo

957
00:38:06,779 --> 00:38:09,739
Bueno ya, a ver, depende de lo que quiera hacer

958
00:38:09,739 --> 00:38:10,779
Pero me refiero que

959
00:38:10,779 --> 00:38:12,859
Gracias a que tenemos un toString, este método

960
00:38:12,859 --> 00:38:14,379
Te lo puede mostrar todo

961
00:38:14,379 --> 00:38:18,179
¿No? Entonces si volvemos a hacer este main

962
00:38:18,179 --> 00:38:21,579
Pues mira, aquí tenemos

963
00:38:21,579 --> 00:38:23,839
Este es el toString tan estupendo que habíamos hecho

964
00:38:23,839 --> 00:38:25,639
Tu nombre, tu contrato

965
00:38:25,639 --> 00:38:27,239
Tu fecha, efectivamente 9 de febrero

966
00:38:27,239 --> 00:38:29,299
Cuando lo instanciamos a las 13 y 26

967
00:38:29,300 --> 00:38:31,620
¿Vale?

968
00:38:31,720 --> 00:38:33,200
Entonces si no tuviéramos el toString

969
00:38:33,200 --> 00:38:35,760
Aquí nos saldría una cosa muy rara

970
00:38:35,760 --> 00:38:36,820
Que es el toString de object

971
00:38:36,820 --> 00:38:39,500
Pero como tenemos nuestro toString

972
00:38:39,500 --> 00:38:41,380
Que este toString no nos gusta

973
00:38:41,380 --> 00:38:43,420
Porque en empleado

974
00:38:43,420 --> 00:38:44,940
Porque cuando me muestra el empleado

975
00:38:44,940 --> 00:38:48,080
Quiero que me muestre, no quiero que me muestre la fecha

976
00:38:48,080 --> 00:38:49,600
O quiero que me lo muestre de otra manera

977
00:38:49,600 --> 00:38:51,700
O no quiero que me muestre esto de aquí

978
00:38:51,700 --> 00:38:52,780
Porque es muy feo

979
00:38:52,780 --> 00:38:55,360
Pues ya lo toqueteo y lo modifico

980
00:38:55,360 --> 00:38:55,780
Oye

981
00:38:55,780 --> 00:39:01,980
¡Hala! Así más bonito

982
00:39:01,980 --> 00:39:02,740
Por ejemplo

983
00:39:02,740 --> 00:39:03,980
¿No?

984
00:39:05,500 --> 00:39:07,680
Toqueteo el toString para adaptarlo a lo que yo quiero

985
00:39:07,680 --> 00:39:12,920
Ahora ya, ¡hala! Ya los tengo

986
00:39:12,920 --> 00:39:14,960
Salario, fecha, patatín

987
00:39:14,960 --> 00:39:19,019
¿Vale? Entonces el toString es cómodo en eso

988
00:39:19,019 --> 00:39:21,180
Porque si queremos pasar

989
00:39:21,180 --> 00:39:24,700
Al system.out.println para mostrar un objeto

990
00:39:24,700 --> 00:39:26,800
pues ya no tengo que preocuparme

991
00:39:26,800 --> 00:39:28,640
yo de ahí construir la cadena que quiero

992
00:39:28,640 --> 00:39:29,260
con los get

993
00:39:29,260 --> 00:39:31,420
yo le paso el objeto

994
00:39:31,420 --> 00:39:34,380
y ya en el toString se extrae

995
00:39:34,380 --> 00:39:35,880
la información que yo quiera

996
00:39:35,880 --> 00:39:37,480
bueno

997
00:39:37,480 --> 00:39:40,740
pero estábamos ahora con la empresa

998
00:39:40,740 --> 00:39:42,640
la empresa

999
00:39:42,640 --> 00:39:44,960
tiene sus get, sus set y constructores

1000
00:39:44,960 --> 00:39:45,980
que ya los tengo hechos

1001
00:39:45,980 --> 00:39:48,640
y le podríamos poner también

1002
00:39:48,640 --> 00:39:50,640
un toString si es que vamos a listar empresas

1003
00:39:50,640 --> 00:39:51,620
pero bueno

1004
00:39:51,620 --> 00:39:54,400
Andoni

1005
00:39:54,400 --> 00:39:55,920
Cállate

1006
00:39:55,920 --> 00:40:02,180
Vale, ¿qué métodos tiene que tener la clase empresa?

1007
00:40:03,380 --> 00:40:03,980
Pues nada

1008
00:40:03,980 --> 00:40:06,440
Calcular todo lo que paga la empresa

1009
00:40:06,440 --> 00:40:07,019
Todo el mundo

1010
00:40:07,019 --> 00:40:08,619
Todo lo que paga

1011
00:40:08,619 --> 00:40:11,280
Pues bueno

1012
00:40:11,280 --> 00:40:14,680
Calcular todo lo que paga

1013
00:40:14,680 --> 00:40:18,480
Va a ser una suma de salarios

1014
00:40:18,480 --> 00:40:19,340
Luego un double

1015
00:40:19,340 --> 00:40:21,599
Pues get

1016
00:40:21,599 --> 00:40:23,619
Sueldo total

1017
00:40:23,619 --> 00:40:25,099
empresa.

1018
00:40:26,900 --> 00:40:28,159
Sueldo total de la empresa.

1019
00:40:28,279 --> 00:40:28,880
Lo de siempre.

1020
00:40:29,759 --> 00:40:31,639
¿Necesitamos pasar alguna información desde fuera?

1021
00:40:31,739 --> 00:40:31,940
No.

1022
00:40:32,920 --> 00:40:34,299
Porque lo que paga la empresa,

1023
00:40:34,920 --> 00:40:35,859
¿dónde está recogido?

1024
00:40:37,559 --> 00:40:39,659
Pues está recogido dentro de los sueldos

1025
00:40:39,659 --> 00:40:40,319
de los empleados.

1026
00:40:40,819 --> 00:40:41,960
¿Y los empleados dónde están?

1027
00:40:42,219 --> 00:40:43,460
Dentro de los departamentos.

1028
00:40:44,239 --> 00:40:45,579
Luego, dentro de este array,

1029
00:40:46,579 --> 00:40:48,219
dentro de ese array,

1030
00:40:48,359 --> 00:40:50,440
está toda la información que necesito.

1031
00:40:51,139 --> 00:40:52,619
Dentro de ese array están los empleados.

1032
00:40:52,619 --> 00:40:54,940
Perdón, dentro de esa raíz están los departamentos

1033
00:40:54,940 --> 00:40:56,880
Y dentro de cada departamento

1034
00:40:56,880 --> 00:40:57,960
Están los empleados

1035
00:40:57,960 --> 00:40:59,659
Y dentro de los empleados está el sueldo

1036
00:40:59,659 --> 00:41:02,339
Luego lo tengo todo ahí, no hay que pasarle nada

1037
00:41:02,339 --> 00:41:02,960
Fuera

1038
00:41:02,960 --> 00:41:11,019
Ala

1039
00:41:11,019 --> 00:41:15,759
Pues

1040
00:41:15,759 --> 00:41:17,519
Tendremos lo de siempre

1041
00:41:17,519 --> 00:41:19,599
Una suma de sueldos

1042
00:41:19,599 --> 00:41:24,079
y ahora que hay que recorrer

1043
00:41:24,079 --> 00:41:26,099
pues hay que recorrer mi array de departamentos

1044
00:41:26,099 --> 00:41:27,420
porque ahí es donde están

1045
00:41:27,420 --> 00:41:29,940
los sueldos, departamento

1046
00:41:29,940 --> 00:41:31,239
por cada departamento de

1047
00:41:31,239 --> 00:41:36,000
y ahora como

1048
00:41:36,000 --> 00:41:38,000
tenemos la suerte

1049
00:41:38,000 --> 00:41:40,079
estupenda de que en departamento teníamos

1050
00:41:40,079 --> 00:41:42,059
un método que me saca

1051
00:41:42,059 --> 00:41:43,719
todo lo que paga ese departamento

1052
00:41:43,719 --> 00:41:45,179
no tengo que a su vez

1053
00:41:45,179 --> 00:41:47,639
hacer un for aquí anidado

1054
00:41:47,639 --> 00:41:49,960
para dentro del departamento recorrer los empleados

1055
00:41:49,960 --> 00:41:51,539
y sumar, no tengo que hacerlo

1056
00:41:51,539 --> 00:41:53,259
porque tengo un método

1057
00:41:53,259 --> 00:41:55,119
estupendo

1058
00:41:55,119 --> 00:41:56,759
en departamento

1059
00:41:56,759 --> 00:41:59,059
que me devuelve el sueldo total

1060
00:41:59,059 --> 00:42:03,739
entonces, este sueldo

1061
00:42:03,739 --> 00:42:07,819
perdón, este método ya dentro

1062
00:42:07,819 --> 00:42:09,960
de él, a su vez, hace un for

1063
00:42:09,960 --> 00:42:11,579
que recorre los empleados del

1064
00:42:11,579 --> 00:42:13,839
objeto de, los va sumando

1065
00:42:13,839 --> 00:42:15,879
me lo devuelve, pues eso yo ahora

1066
00:42:15,880 --> 00:42:17,840
lo sumo a este y así paso

1067
00:42:17,840 --> 00:42:19,079
al siguiente departamento, etc

1068
00:42:19,079 --> 00:42:25,340
el objeto es cada uno

1069
00:42:25,340 --> 00:42:27,480
de los departamentos

1070
00:42:27,480 --> 00:42:29,440
de mi array de departamentos

1071
00:42:29,440 --> 00:42:31,420
es como llamarlo yo dentro del foricha

1072
00:42:31,420 --> 00:42:35,200
bueno, pues ya está

1073
00:42:35,200 --> 00:42:39,220
este ya estaría

1074
00:42:39,220 --> 00:42:40,880
se apoyan unos sobre otros

1075
00:42:40,880 --> 00:42:44,740
y aquí devolveríamos

1076
00:42:44,740 --> 00:42:47,080
Este

1077
00:42:47,080 --> 00:42:49,380
Y se acabó

1078
00:42:49,380 --> 00:42:51,800
Que es sueldal de la empresa

1079
00:42:51,800 --> 00:42:52,400
Pues ya está

1080
00:42:52,400 --> 00:42:55,920
Sumamos los sueldos de todos los departamentos

1081
00:42:55,920 --> 00:42:59,120
Andoni

1082
00:42:59,120 --> 00:43:02,620
A la siguiente te muevo aquí delante

1083
00:43:14,440 --> 00:43:14,720
Bueno

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

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

1086
00:43:30,960 --> 00:43:39,260
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.

1087
00:43:39,260 --> 00:43:41,400
que va a ser como añadir empleado al departamento

1088
00:43:41,400 --> 00:43:42,140
entonces aquí

1089
00:43:42,140 --> 00:43:45,320
estamos espabilados y copiamos

1090
00:43:45,320 --> 00:43:47,100
y pegamos este y lo modificamos

1091
00:43:47,100 --> 00:43:48,880
nos ahorramos un montón de trabajo

1092
00:43:48,880 --> 00:43:51,640
copio este de añadir empleado

1093
00:43:51,640 --> 00:43:53,300
a departamento a la empresa

1094
00:43:53,300 --> 00:43:55,380
copio este

1095
00:43:55,380 --> 00:43:59,360
y cambio

1096
00:43:59,360 --> 00:44:04,600
al departamento

1097
00:44:04,600 --> 00:44:07,100
que tenemos que añadir aquí

1098
00:44:07,099 --> 00:44:33,319
Un departamento, un departamento de, vale, ahora, departamento es el tipo que sustituye a empleado, vale,

1099
00:44:33,320 --> 00:44:58,760
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.

1100
00:44:58,760 --> 00:45:01,680
bueno, he hecho un añadir departamento rápido

1101
00:45:01,680 --> 00:45:03,280
para luego cuando en el main

1102
00:45:03,280 --> 00:45:05,540
hagamos la prueba, pues podré añadir

1103
00:45:05,540 --> 00:45:07,320
departamento según nos vaya dando la gana

1104
00:45:07,320 --> 00:45:09,320
una empresa, pero es lo mismo

1105
00:45:09,320 --> 00:45:11,860
de siempre, cojo la raíz de departamento

1106
00:45:11,860 --> 00:45:12,840
lo extiendo en una posición

1107
00:45:12,840 --> 00:45:15,380
copio el viejo

1108
00:45:15,380 --> 00:45:17,520
en el nuevo, en la posición extendida

1109
00:45:17,520 --> 00:45:19,480
del nuevo, paso el

1110
00:45:19,480 --> 00:45:21,320
de y sobre escribo

1111
00:45:21,320 --> 00:45:22,400
añadir departamento

1112
00:45:22,400 --> 00:45:25,060
por comodidad solamente

1113
00:45:25,060 --> 00:45:26,780
vale, la empresa no tiene más métodos

1114
00:45:26,780 --> 00:45:29,800
bueno, ahora que nos dicen por aquí

1115
00:45:29,800 --> 00:45:31,320
pues la empresa

1116
00:45:31,320 --> 00:45:32,720
ha decidido que

1117
00:45:32,720 --> 00:45:35,040
empieza a contratar temporales

1118
00:45:35,040 --> 00:45:37,980
porque le viene bien

1119
00:45:37,980 --> 00:45:39,760
pues bueno, entonces esta aplicación

1120
00:45:39,760 --> 00:45:41,480
ahora tiene que escalarse, tiene que mantenerse

1121
00:45:41,480 --> 00:45:43,920
tiene que ampliarse para poder tener en cuenta

1122
00:45:43,920 --> 00:45:44,980
empleados temporales

1123
00:45:44,980 --> 00:45:46,660
pues entonces

1124
00:45:46,660 --> 00:45:48,940
si la hemos diseñado bien

1125
00:45:48,940 --> 00:45:51,440
esta

1126
00:45:51,440 --> 00:45:53,640
ampliación será sencilla

1127
00:45:53,640 --> 00:45:55,340
si la hemos diseñado mal

1128
00:45:55,340 --> 00:45:57,500
esta ampliación será un bipostio, la tiraremos a la basura

1129
00:45:57,500 --> 00:45:58,920
y el que la hizo pues le echaremos

1130
00:45:58,920 --> 00:46:01,840
entonces, la hemos diseñado

1131
00:46:01,840 --> 00:46:03,680
bien porque ya en su momento

1132
00:46:03,680 --> 00:46:05,360
decidimos trabajar

1133
00:46:05,360 --> 00:46:07,280
por separado con empleados y gerentes

1134
00:46:07,280 --> 00:46:08,940
y hacer una relación de herencia entre ellos

1135
00:46:08,940 --> 00:46:11,340
si hubiéramos decidido un empleado

1136
00:46:11,340 --> 00:46:13,380
solamente una clase empleado y en esa clase

1137
00:46:13,380 --> 00:46:15,559
empleado tener un bonus que a veces lo tenemos en cuenta

1138
00:46:15,559 --> 00:46:16,240
y a veces no

1139
00:46:16,240 --> 00:46:18,880
entonces ya empezaría a quedar feo

1140
00:46:18,880 --> 00:46:21,519
porque entonces le tendría que meter otro parámetro para el temporal

1141
00:46:21,519 --> 00:46:23,360
pero ya se queda una clase con mil parámetros

1142
00:46:23,360 --> 00:46:25,519
pero que algunos solo afectan a un otro

1143
00:46:25,519 --> 00:46:27,539
a otros, no, eso ya empieza

1144
00:46:27,539 --> 00:46:29,579
los parches empiezan ahí

1145
00:46:29,579 --> 00:46:31,059
a dar guerra y se lían

1146
00:46:31,059 --> 00:46:33,660
pero hemos tenido la suerte que hemos hecho de partida

1147
00:46:33,660 --> 00:46:35,180
un buen diseño, que es no

1148
00:46:35,180 --> 00:46:37,740
una clase de empleados solo con lo común

1149
00:46:37,740 --> 00:46:38,680
a todos los empleados

1150
00:46:38,680 --> 00:46:41,079
y ahora ya si vienen más tipos

1151
00:46:41,079 --> 00:46:42,700
ya los iré incorporando

1152
00:46:42,700 --> 00:46:44,740
de partida había un gerente, vale

1153
00:46:44,740 --> 00:46:46,780
pero es que ahora han llegado los temporales

1154
00:46:46,780 --> 00:46:48,840
no pasa nada, me hago yo mi clase temporal

1155
00:46:48,840 --> 00:46:51,059
y la heredo de la otra

1156
00:46:51,059 --> 00:46:52,220
pues maravilloso

1157
00:46:52,220 --> 00:46:54,560
Es más fácil ampliarlo ahora

1158
00:46:54,560 --> 00:46:56,020
Porque el diseño inicial era bueno

1159
00:46:56,020 --> 00:46:58,720
Pues venga, vamos a hacernos nuestra clase

1160
00:46:58,720 --> 00:46:59,600
Empleado temporal

1161
00:46:59,600 --> 00:47:08,600
Hay que ver que a gusto

1162
00:47:08,600 --> 00:47:09,760
Me voy a quedar ahora

1163
00:47:09,760 --> 00:47:12,780
No me lo voy a creer

1164
00:47:12,780 --> 00:47:16,900
Vale, empleado temporal

1165
00:47:16,900 --> 00:47:18,620
Es un empleado más de la empresa

1166
00:47:18,620 --> 00:47:20,260
Os espera Estefano aquí el lunes

1167
00:47:20,260 --> 00:47:27,040
bueno

1168
00:47:27,040 --> 00:47:29,960
empleado temporal

1169
00:47:29,960 --> 00:47:31,900
afortunadamente tenemos ese buen diseño

1170
00:47:31,900 --> 00:47:33,380
una clase empleado ya hecha

1171
00:47:33,380 --> 00:47:35,860
pues ala, magnífico, empleado temporal

1172
00:47:35,860 --> 00:47:37,740
hereda de empleado

1173
00:47:37,740 --> 00:47:38,540
muy bien

1174
00:47:38,540 --> 00:47:42,200
entonces ya no tengo que ponerle

1175
00:47:42,200 --> 00:47:43,840
ni el nombre, ni el salario

1176
00:47:43,840 --> 00:47:46,280
ni la fecha de contratación, no tengo que ponérsela

1177
00:47:46,280 --> 00:47:48,200
es un empleado como todos, eso ya lo tiene

1178
00:47:48,200 --> 00:47:50,600
Lo único que añade es

1179
00:47:50,600 --> 00:47:52,400
El pobre, pues una fecha de fin

1180
00:47:52,400 --> 00:47:53,780
Es lo único que añade

1181
00:47:53,780 --> 00:47:55,180
¿Verdad?

1182
00:47:57,300 --> 00:47:57,860
Sí

1183
00:47:57,860 --> 00:48:00,140
El temporal añade eso

1184
00:48:00,140 --> 00:48:02,400
Bueno, pues nada, ponemos lo que añade

1185
00:48:02,400 --> 00:48:02,900
Ya está

1186
00:48:02,900 --> 00:48:05,960
Entonces

1187
00:48:05,960 --> 00:48:07,760
Añade una fecha de fin

1188
00:48:07,760 --> 00:48:09,860
Eh

1189
00:48:09,860 --> 00:48:15,900
Fin

1190
00:48:15,900 --> 00:48:17,540
Contrato

1191
00:48:17,539 --> 00:48:23,759
añade esta fecha

1192
00:48:23,759 --> 00:48:29,259
y seleccionamos la clase date

1193
00:48:29,259 --> 00:48:31,219
porque es la que le pega

1194
00:48:31,219 --> 00:48:32,420
pues nada

1195
00:48:32,420 --> 00:48:33,840
lo demás ya es

1196
00:48:33,840 --> 00:48:35,920
le damos a la manivela

1197
00:48:35,920 --> 00:48:37,480
para constructores get y set

1198
00:48:37,480 --> 00:48:39,940
pero le damos a la manivela con criterio

1199
00:48:39,940 --> 00:48:40,840
si no es lo que estamos haciendo

1200
00:48:40,840 --> 00:48:47,480
pues le damos ya

1201
00:48:47,480 --> 00:48:48,940
a esto

1202
00:48:48,940 --> 00:48:58,340
el get y el set

1203
00:48:58,340 --> 00:49:01,740
y ahora

1204
00:49:01,740 --> 00:49:04,300
gracias a que hicimos este diseño

1205
00:49:04,300 --> 00:49:05,900
con herencia

1206
00:49:05,900 --> 00:49:07,880
mi aplicación principal

1207
00:49:07,880 --> 00:49:09,960
que hace las cosas, que ahora mismo era un main

1208
00:49:09,960 --> 00:49:11,280
con tres cosas para probar,

1209
00:49:11,820 --> 00:49:13,280
pero que en condiciones normales

1210
00:49:13,280 --> 00:49:15,280
será una aplicación con una interfaz gráfica

1211
00:49:15,280 --> 00:49:16,000
y la leche.

1212
00:49:16,780 --> 00:49:18,460
Pues gracias a que ya iniciamos

1213
00:49:18,460 --> 00:49:19,980
un diseño con herencia,

1214
00:49:20,820 --> 00:49:22,059
mi aplicación principal

1215
00:49:22,059 --> 00:49:23,679
no tiene que cambiar de principio a fin,

1216
00:49:24,360 --> 00:49:26,159
porque mi aplicación principal decía,

1217
00:49:26,480 --> 00:49:29,059
oye, mis datos están en,

1218
00:49:30,159 --> 00:49:30,599
perdón,

1219
00:49:31,800 --> 00:49:33,320
mi aplicación principal decía,

1220
00:49:34,139 --> 00:49:36,360
mi departamento tiene empleados

1221
00:49:36,360 --> 00:49:37,500
que son del tipo empleado.

1222
00:49:37,800 --> 00:49:38,360
Digo, genial,

1223
00:49:38,360 --> 00:49:40,700
no tienes que cambiar departamento para nada, tienes que cambiarlo

1224
00:49:40,700 --> 00:49:42,880
los empleados temporales que han llegado

1225
00:49:42,880 --> 00:49:44,660
van a caer aquí también

1226
00:49:44,660 --> 00:49:46,700
sin ningún problema, van a caer aquí también

1227
00:49:46,700 --> 00:49:48,340
no tienes que tocar departamento

1228
00:49:48,340 --> 00:49:50,480
pero si hubieras hecho otro diseño

1229
00:49:50,480 --> 00:49:52,340
en el cual no habría herencia

1230
00:49:52,340 --> 00:49:54,740
pues habría que meterse en departamento

1231
00:49:54,740 --> 00:49:56,820
hacerle aquí otro array

1232
00:49:56,820 --> 00:49:58,300
para meter sus temporales

1233
00:49:58,300 --> 00:50:00,500
porque no cabría en el array de arriba, porque el de arriba

1234
00:50:00,500 --> 00:50:02,120
está pensado para los que fueran

1235
00:50:02,120 --> 00:50:04,559
y entonces eso ya sería una locura

1236
00:50:04,559 --> 00:50:06,599
¿vale? pues como no

1237
00:50:06,599 --> 00:50:08,300
como está incorporada la herencia

1238
00:50:08,300 --> 00:50:10,320
el departamento ni se entera

1239
00:50:10,320 --> 00:50:12,720
que me has metido empleados temporales

1240
00:50:12,720 --> 00:50:14,720
a mi que más me da, a mi en mi array cae lo que

1241
00:50:14,720 --> 00:50:16,980
quieras, siempre y cuando herede

1242
00:50:16,980 --> 00:50:18,800
¿vale? siempre y cuando herede

1243
00:50:18,800 --> 00:50:20,980
luego

1244
00:50:20,980 --> 00:50:23,200
la herencia tiene una motivación

1245
00:50:23,200 --> 00:50:26,560
y hacer una

1246
00:50:26,560 --> 00:50:28,340
aplicación sin herencia

1247
00:50:28,340 --> 00:50:31,200
es inabordable

1248
00:50:31,200 --> 00:50:32,660
no tiene ningún sentido

1249
00:50:32,660 --> 00:50:36,260
bueno pues entonces

1250
00:50:36,260 --> 00:50:37,920
ahora, nuestra

1251
00:50:37,920 --> 00:50:40,440
la clase temporal esta, ¿qué tenía que hacer?

1252
00:50:42,240 --> 00:50:43,520
la clase temporal

1253
00:50:43,520 --> 00:50:46,240
empleado, añada

1254
00:50:46,240 --> 00:50:48,280
fin de contrato, constructores

1255
00:50:48,280 --> 00:50:49,580
pues ya está, ya lo hemos hecho

1256
00:50:49,580 --> 00:50:51,660
ya está, ya se ha acabado

1257
00:50:51,660 --> 00:50:53,980
vale, pues vamos a hacer ahora un main nosotros

1258
00:50:53,980 --> 00:50:55,300
haciendo estas cosas

1259
00:50:55,300 --> 00:50:57,740
creamos un objeto empresa

1260
00:50:57,740 --> 00:50:59,880
en lugar de con cuatro departamentos

1261
00:50:59,880 --> 00:51:01,760
bueno, sí, con cuatro se los añadimos con ad

1262
00:51:01,760 --> 00:51:03,600
pues venga, vamos a hacernos un main

1263
00:51:03,599 --> 00:51:06,579
vale

1264
00:51:06,579 --> 00:51:09,960
venga, este main

1265
00:51:09,960 --> 00:51:12,179
yo hice esto para las pruebas

1266
00:51:12,179 --> 00:51:14,199
lo voy a dejar

1267
00:51:14,199 --> 00:51:15,299
comentado aquí

1268
00:51:15,299 --> 00:51:18,159
todo esto que hice para las pruebas

1269
00:51:18,159 --> 00:51:19,799
de los métodos anteriores

1270
00:51:19,799 --> 00:51:21,199
lo voy a dejar

1271
00:51:21,199 --> 00:51:23,519
comentado aquí

1272
00:51:23,519 --> 00:51:25,239
vale

1273
00:51:25,239 --> 00:51:28,400
voy a incorporar a mi proyecto

1274
00:51:28,400 --> 00:51:28,960
este

1275
00:51:28,960 --> 00:51:31,599
el jar ese

1276
00:51:31,599 --> 00:51:34,900
para leer por teclado

1277
00:51:34,900 --> 00:51:36,339
así rápidamente

1278
00:51:36,339 --> 00:51:40,099
meto en el classpad

1279
00:51:40,099 --> 00:51:42,940
un jar externo que tengo en el escritorio

1280
00:51:42,940 --> 00:51:44,579
ahí

1281
00:51:44,579 --> 00:51:48,500
vale

1282
00:51:48,500 --> 00:51:50,920
y me acuerdo de no tener el módule info

1283
00:51:50,920 --> 00:51:52,619
porque como tenga el módule info

1284
00:51:52,619 --> 00:51:54,940
no puedo agregarlo al classpad

1285
00:51:54,940 --> 00:51:57,119
de esta manera, pero eso ya son cosas que exceden

1286
00:51:57,119 --> 00:51:59,139
ahora mismo de nuestras

1287
00:51:59,139 --> 00:52:00,920
de nuestra

1288
00:52:00,920 --> 00:52:03,039
De nuestros conocimientos

1289
00:52:03,039 --> 00:52:05,059
Así que por ahora lo único que digo es

1290
00:52:05,059 --> 00:52:07,659
Cuidado cuando añadáis hard no tengáis un módulo info por ahí

1291
00:52:07,659 --> 00:52:09,820
Por si acaso

1292
00:52:09,820 --> 00:52:11,420
Vale, pues venga

1293
00:52:11,420 --> 00:52:13,260
Ahora vamos a hacer nuestro main

1294
00:52:13,260 --> 00:52:14,380
Que es crear un objeto empresa

1295
00:52:14,380 --> 00:52:16,980
Pues venga, vamos a crear una empresa

1296
00:52:16,980 --> 00:52:19,460
Esta es mi empresa

1297
00:52:19,460 --> 00:52:27,079
Esta empresa

1298
00:52:30,920 --> 00:52:32,880
Venga, vamos a hacerlo tan bonito

1299
00:52:32,880 --> 00:52:34,599
como para meter el nombre de la empresa

1300
00:52:34,599 --> 00:52:35,260
por teclado.

1301
00:52:38,320 --> 00:52:39,280
Nombre empresa.

1302
00:52:42,420 --> 00:52:43,340
Nombre empresa.

1303
00:52:43,659 --> 00:52:44,960
Pues bueno, nombre empresa.

1304
00:52:47,159 --> 00:52:47,659
Este.

1305
00:52:48,099 --> 00:52:48,460
Ya está.

1306
00:52:51,220 --> 00:52:51,480
¡Hala!

1307
00:52:51,680 --> 00:52:52,860
Ya tenemos una empresa.

1308
00:52:54,860 --> 00:52:56,280
Ahí con su nombrecito.

1309
00:52:57,099 --> 00:52:58,000
Bueno, no, no la tengo.

1310
00:52:58,000 --> 00:52:58,639
Es que me emperro.

1311
00:52:58,900 --> 00:53:00,440
No tengo constructor solo con el nombre.

1312
00:53:00,440 --> 00:53:02,280
Entonces la tengo que crear sin parámetros

1313
00:53:02,280 --> 00:53:03,280
Y ahora ya hacerle el set

1314
00:53:03,280 --> 00:53:07,559
Empresa.set

1315
00:53:07,559 --> 00:53:08,420
Nombre

1316
00:53:08,420 --> 00:53:11,440
Y ahora ya sí que leo el nombre

1317
00:53:11,440 --> 00:53:18,320
¡Hala! Tenemos una empresa con un nombre que me han dado

1318
00:53:18,320 --> 00:53:20,539
La aplicación ha arrancado

1319
00:53:20,539 --> 00:53:21,659
Mi empresa se llama

1320
00:53:21,659 --> 00:53:23,659
Vale, pues ya está

1321
00:53:23,659 --> 00:53:26,679
¿Qué más cosas me dicen que haga mi aplicación?

1322
00:53:27,639 --> 00:53:28,700
Ya hemos hecho esta primera parte

1323
00:53:28,700 --> 00:53:30,540
Aquí me dice con 4 departamentos

1324
00:53:30,540 --> 00:53:31,440
Por ahora sin empleados

1325
00:53:31,440 --> 00:53:33,360
Venga vamos a meterle 4 departamentos

1326
00:53:33,360 --> 00:53:35,880
Se los voy a meter con el método

1327
00:53:35,880 --> 00:53:37,940
AddDepartamento que hice en empresa

1328
00:53:37,940 --> 00:53:39,120
Que es muy cómodo

1329
00:53:39,120 --> 00:53:40,860
Por ahora sin empleados

1330
00:53:40,860 --> 00:53:41,760
Pues

1331
00:53:41,760 --> 00:53:46,740
Como tengo el constructor

1332
00:53:46,740 --> 00:53:48,540
El problema es que

1333
00:53:48,540 --> 00:53:50,480
En departamento tengo un constructor

1334
00:53:50,480 --> 00:53:53,140
Sin parámetros

1335
00:53:53,140 --> 00:53:54,700
Y otro con parámetros

1336
00:53:54,700 --> 00:53:56,200
Que me obliga a meter el array

1337
00:53:56,200 --> 00:53:57,480
Y yo no quiero

1338
00:53:57,480 --> 00:53:59,980
Entonces aquí es bastante interesante

1339
00:53:59,980 --> 00:54:01,079
Hacer un constructor

1340
00:54:01,079 --> 00:54:02,440
Solo con el nombre

1341
00:54:02,440 --> 00:54:04,760
Es bastante interesante

1342
00:54:04,760 --> 00:54:06,860
Para ahorrarnos líneas luego en el main

1343
00:54:06,860 --> 00:54:09,199
Vamos a hacer un constructor

1344
00:54:09,199 --> 00:54:11,260
Para hacer un departamento

1345
00:54:11,260 --> 00:54:12,340
Solo con el nombre

1346
00:54:12,340 --> 00:54:18,440
Sí, pero es que como lo quiero

1347
00:54:18,440 --> 00:54:20,219
Pasar directamente

1348
00:54:20,219 --> 00:54:22,360
Luego el new departamento

1349
00:54:22,360 --> 00:54:23,519
Al método add

1350
00:54:23,519 --> 00:54:26,780
Pues en el momento en el que se lo paso

1351
00:54:26,780 --> 00:54:28,300
a las departamento quiero hacer ya el new

1352
00:54:28,300 --> 00:54:30,540
ahora lo vemos

1353
00:54:30,540 --> 00:54:32,140
entonces me ahorro así una línea

1354
00:54:32,140 --> 00:54:35,740
entonces este dis.nombre

1355
00:54:35,740 --> 00:54:37,300
que lo que dices tú

1356
00:54:37,300 --> 00:54:39,280
implica que yo cree la referencia antes

1357
00:54:39,280 --> 00:54:40,440
y luego ya se la pase al método

1358
00:54:40,440 --> 00:54:42,240
entonces la quiero directamente pasar

1359
00:54:42,240 --> 00:54:44,640
dis.nombre igual a nombre

1360
00:54:44,640 --> 00:54:47,100
venga

1361
00:54:47,100 --> 00:54:49,000
me hago un constructor que me va a crear

1362
00:54:49,000 --> 00:54:50,700
como lo tengo aquí inicializado

1363
00:54:50,700 --> 00:54:53,460
me va a crear el array de empleados

1364
00:54:53,460 --> 00:54:55,000
lo va a inicializar vacío, sin nada

1365
00:54:55,000 --> 00:54:56,920
Y al nombre le va a dar un valor

1366
00:54:56,920 --> 00:55:00,019
Vale, bueno, pues para qué he hecho este constructor

1367
00:55:00,019 --> 00:55:01,300
Pues porque soy muy vaga

1368
00:55:01,300 --> 00:55:02,960
Entonces yo ahora quiero hacer

1369
00:55:02,960 --> 00:55:05,980
A empresa, vamos a añadirle un departamento

1370
00:55:05,980 --> 00:55:08,159
Y le voy a añadir un departamento

1371
00:55:08,159 --> 00:55:09,420
Que voy a crear en este momento

1372
00:55:09,420 --> 00:55:10,820
Departamento

1373
00:55:10,820 --> 00:55:13,119
Pues personal

1374
00:55:13,119 --> 00:55:15,280
Ala, ya está

1375
00:55:15,280 --> 00:55:17,039
Ya tengo un departamento ahí creado

1376
00:55:17,039 --> 00:55:21,019
Porque si no tendría que crearlo antes

1377
00:55:21,019 --> 00:55:22,880
Con el set y ahora pasárselo aquí dentro

1378
00:55:22,880 --> 00:55:26,599
Venga

1379
00:55:26,599 --> 00:55:28,800
Y voy a, como me dice enunciado

1380
00:55:28,800 --> 00:55:30,400
Que le haga cuatro, pues le voy a hacer cuatro

1381
00:55:30,400 --> 00:55:37,700
Departamento personal

1382
00:55:37,700 --> 00:55:40,760
Departamento informática

1383
00:55:40,760 --> 00:55:46,180
Departamento sanitario

1384
00:55:46,180 --> 00:55:49,640
Departamento

1385
00:55:49,639 --> 00:55:53,039
Educación física

1386
00:55:53,039 --> 00:55:59,179
Ya tenemos una empresa

1387
00:55:59,179 --> 00:56:00,699
Con cuatro departamentos

1388
00:56:00,699 --> 00:56:05,079
Por ahora ninguno de ellos tiene empleados

1389
00:56:05,079 --> 00:56:09,480
Ninguno de ellos tiene empleados

1390
00:56:09,480 --> 00:56:10,900
Y ahora

1391
00:56:10,900 --> 00:56:12,460
¿Qué más me dicen que haga por aquí?

1392
00:56:13,440 --> 00:56:15,299
Pues ahora ya la aplicación de gestión

1393
00:56:15,299 --> 00:56:16,379
Te tiene que permitir

1394
00:56:16,379 --> 00:56:19,019
Meterle empleados al departamento

1395
00:56:19,019 --> 00:56:22,559
Mostrar salario de la empresa

1396
00:56:22,559 --> 00:56:24,320
Y mostrar departamento que más salario paga

1397
00:56:24,320 --> 00:56:29,539
Pues ahora ya sí que sí

1398
00:56:29,539 --> 00:56:30,639
Tengo que hacer un menú

1399
00:56:30,639 --> 00:56:32,880
Y esto pues siempre lo hacemos de esta manera

1400
00:56:32,880 --> 00:56:42,659
Incorporar un empleado

1401
00:56:49,019 --> 00:56:52,099
y este menú, esta aplicación

1402
00:56:52,099 --> 00:56:53,960
ya podría hacerse enorme, con mil

1403
00:56:53,960 --> 00:56:54,780
funcionalidades

1404
00:56:54,780 --> 00:56:58,199
mostrar sueldo del

1405
00:56:58,199 --> 00:56:59,400
empleado dado su nombre

1406
00:56:59,400 --> 00:57:01,099
dado dos nombres, pues

1407
00:57:01,099 --> 00:57:04,199
dado un nombre, decir si es gerente o no lo es

1408
00:57:04,199 --> 00:57:06,179
o sea, esta aplicación ya podría incorporarse

1409
00:57:06,179 --> 00:57:07,960
millones de funcionalidades para hacer cosas

1410
00:57:07,960 --> 00:57:10,059
con estos datos, que son datos sencillos

1411
00:57:10,059 --> 00:57:11,800
una empresa que tiene departamentos

1412
00:57:11,800 --> 00:57:13,820
y un departamento que tiene empleados

1413
00:57:13,820 --> 00:57:16,000
pues con ese modelo de datos bien hecho

1414
00:57:16,000 --> 00:57:17,639
ahora ya la aplicación puede gestionar

1415
00:57:17,639 --> 00:57:19,859
de todo lo que necesites

1416
00:57:19,859 --> 00:57:22,119
pues dados dos empleados

1417
00:57:22,119 --> 00:57:24,559
ver cuál de ellos se incorporó antes

1418
00:57:24,559 --> 00:57:26,440
mirando la fecha

1419
00:57:26,440 --> 00:57:28,579
de todo, cualquier cosa que se nos ocurra

1420
00:57:28,579 --> 00:57:29,819
se podría incorporar en este menú

1421
00:57:29,819 --> 00:57:31,179
cualquier cosa que se nos ocurra

1422
00:57:31,179 --> 00:57:33,000
se podría incorporar

1423
00:57:33,000 --> 00:57:35,980
mostrar, esto es mostrar

1424
00:57:35,980 --> 00:57:36,859
el salario

1425
00:57:36,859 --> 00:57:40,460
el sueldo que paga la empresa

1426
00:57:40,460 --> 00:57:54,380
Y ahora aquí

1427
00:57:54,380 --> 00:57:55,679
Pues

1428
00:57:55,679 --> 00:58:00,599
Esta va para hacer un máximo

1429
00:58:00,599 --> 00:58:02,599
Que es el departamento

1430
00:58:02,599 --> 00:58:03,679
Que más salario paga

1431
00:58:03,679 --> 00:58:08,480
Pues para empezar a quitarle empleados

1432
00:58:08,480 --> 00:58:09,220
O para lo que sea

1433
00:58:09,220 --> 00:58:22,860
y ahora la opción de salir

1434
00:58:22,860 --> 00:58:25,160
por si uno quiere ampliarlo y hacer aquí ya

1435
00:58:25,160 --> 00:58:26,600
tropecientas mil gestiones

1436
00:58:26,600 --> 00:58:28,120
que se pueden hacer tropecientas mil

1437
00:58:28,120 --> 00:58:29,940
pues la ponemos en cero

1438
00:58:29,940 --> 00:58:35,560
y esta ya es la historia de siempre

1439
00:58:35,559 --> 00:58:38,900
esta es la opción en la que vamos a guardar

1440
00:58:38,900 --> 00:58:39,539
el menú

1441
00:58:39,539 --> 00:58:42,639
y ahora

1442
00:58:42,639 --> 00:58:44,599
la opción la leemos con

1443
00:58:44,599 --> 00:58:46,239
leer entero de aquí

1444
00:58:46,239 --> 00:58:49,739
vale

1445
00:58:49,739 --> 00:58:53,119
y ahora ya lo de siempre

1446
00:59:05,559 --> 00:59:32,679
Vale, vamos a poner todos los casos, el 1, el 2, el 3 y el 0, el 0 será salir.

1447
00:59:35,559 --> 00:59:39,199
Y el default será opción incorrecta.

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

1449
00:59:59,279 --> 01:00:03,840
mientras la opción que se haya introducido sea diferente de la correspondiente a salir

1450
01:00:03,840 --> 01:00:04,320
que es la c.

1451
01:00:06,320 --> 01:00:07,720
Pues ya, la estructura ya está.

1452
01:00:08,579 --> 01:00:09,960
Ahora es, ¿qué hacemos en cada caso?

1453
01:00:12,600 --> 01:00:14,039
Añadir un nuevo

1454
01:00:14,039 --> 01:00:15,539
departamento a la empresa.

1455
01:00:16,840 --> 01:00:17,840
La empresa es en...

1456
01:00:18,539 --> 01:00:19,840
No, perdón. Añadir

1457
01:00:19,840 --> 01:00:21,860
un nuevo empleado al departamento. ¿Verdad?

1458
01:00:21,960 --> 01:00:23,240
Incorporar empleado al departamento.

1459
01:00:24,400 --> 01:00:25,800
Entonces, aquí hay que pedir un montón de cosas.

1460
01:00:26,740 --> 01:00:27,760
Hay que pedir, ¿vale? ¿A qué

1461
01:00:27,760 --> 01:00:29,720
departamento? ¿El departamento por qué

1462
01:00:29,720 --> 01:00:30,820
se caracteriza por el nombre?

1463
01:00:31,440 --> 01:00:32,920
Pues habrá que decir, primero

1464
01:00:32,920 --> 01:00:34,420
qué departamento quieres

1465
01:00:34,420 --> 01:00:36,659
para meterlo en él, en su array

1466
01:00:36,659 --> 01:00:38,760
y luego qué tipo de empleado

1467
01:00:38,760 --> 01:00:41,260
porque en función de si es gerente, empleado normal o temporal

1468
01:00:41,260 --> 01:00:42,740
el new que hay que hacer es diferente

1469
01:00:42,740 --> 01:00:45,000
¿no? entonces habrá que hacer

1470
01:00:45,000 --> 01:00:45,680
dos preguntas

1471
01:00:45,680 --> 01:00:48,619
¿vale? habrá que hacer dos preguntas

1472
01:00:48,619 --> 01:00:51,119
bueno, varias

1473
01:00:51,119 --> 01:00:52,700
entonces, pero primero es

1474
01:00:52,700 --> 01:00:54,900
¿a qué departamento? para que este main

1475
01:00:54,900 --> 01:00:55,680
pueda trabajar

1476
01:00:55,680 --> 01:00:58,820
entonces, bueno, aunque se nos alargue

1477
01:00:58,820 --> 01:01:00,840
un poquito, un poquito el este

1478
01:01:00,840 --> 01:01:03,260
no vamos a estar todo el rato tirando de métodos

1479
01:01:03,260 --> 01:01:04,500
métodos, vamos a escribirlo aquí

1480
01:01:04,500 --> 01:01:07,019
primero le decimos al usuario

1481
01:01:07,019 --> 01:01:09,480
a ver, vale, quieres que te incorpore un empleado

1482
01:01:09,480 --> 01:01:10,740
pues

1483
01:01:10,740 --> 01:01:13,120
nombre del departamento al que lo vas a incorporar

1484
01:01:13,120 --> 01:01:14,680
no hay otra

1485
01:01:14,680 --> 01:01:18,880
dime el nombre

1486
01:01:18,880 --> 01:01:20,480
y entonces yo, pues decido

1487
01:01:20,480 --> 01:01:22,960
que te incorporo al empleado de ese departamento

1488
01:01:22,960 --> 01:01:23,620
dime el nombre

1489
01:01:23,620 --> 01:01:26,840
vale, pues entonces, el nombre

1490
01:01:26,840 --> 01:01:28,460
lo vamos a dejar aquí guardadito

1491
01:01:28,460 --> 01:01:29,620
para luego

1492
01:01:29,619 --> 01:01:31,940
usarlo

1493
01:01:31,940 --> 01:01:33,759
para instanciar el objeto departamento

1494
01:01:33,759 --> 01:01:35,699
añadir. El nombre lo dejamos

1495
01:01:35,699 --> 01:01:36,500
aquí guardadito.

1496
01:01:42,159 --> 01:01:42,639
¡Hala!

1497
01:01:43,539 --> 01:01:45,420
¿Pero qué más necesitamos

1498
01:01:45,420 --> 01:01:46,759
para

1499
01:01:46,759 --> 01:01:51,359
añadir el empleado?

1500
01:01:52,079 --> 01:01:53,539
Pues los datos del empleado.

1501
01:01:53,880 --> 01:01:55,299
¿Ya tenemos a qué departamento va?

1502
01:01:55,519 --> 01:01:55,940
Muy bien.

1503
01:01:56,940 --> 01:01:59,319
¿Ya tenemos a qué departamento? Y tenemos dentro de

1504
01:01:59,320 --> 01:02:01,500
departamento, una de empleado, para añadir

1505
01:02:01,500 --> 01:02:02,620
ese empleado en concreto.

1506
01:02:03,400 --> 01:02:04,420
Pero hay que crear el empleado.

1507
01:02:05,900 --> 01:02:07,320
Pues es que tenemos tres tipos

1508
01:02:07,320 --> 01:02:09,539
de empleados. Habrá que decir primero

1509
01:02:09,539 --> 01:02:11,380
¿qué empleado quieres?

1510
01:02:12,420 --> 01:02:13,380
Bueno, los datos comunes

1511
01:02:13,380 --> 01:02:14,640
los podemos pedir antes de preguntar.

1512
01:02:15,480 --> 01:02:17,360
Los comunes son nombre, salario

1513
01:02:17,360 --> 01:02:19,420
y fecha de inicio. Pues podemos

1514
01:02:19,420 --> 01:02:20,860
pedirle ya esos

1515
01:02:20,860 --> 01:02:22,039
tres datos.

1516
01:02:24,019 --> 01:02:25,240
Vamos a pedirle esos

1517
01:02:25,240 --> 01:02:25,820
tres datos.

1518
01:02:25,820 --> 01:02:29,400
nombre del empleado

1519
01:02:29,400 --> 01:02:35,980
y ahora el nombre del empleado

1520
01:02:35,980 --> 01:02:36,420
va aquí

1521
01:02:36,420 --> 01:02:45,800
claro, pero hace empleado

1522
01:02:45,800 --> 01:02:47,740
necesita ya tener

1523
01:02:47,740 --> 01:02:48,860
construido el objeto

1524
01:02:48,860 --> 01:02:51,900
entonces previamente pido los datos para construirlo

1525
01:02:51,900 --> 01:02:55,400
vale, entonces nombre del empleado

1526
01:02:55,400 --> 01:02:57,760
¿Qué más datos comunes tendrían todos?

1527
01:02:57,860 --> 01:02:58,440
El salario

1528
01:02:58,440 --> 01:03:00,860
Pues el salario

1529
01:03:00,860 --> 01:03:05,660
¿Perdón?

1530
01:03:07,180 --> 01:03:08,240
Ahora, no lo he pedido todavía

1531
01:03:08,240 --> 01:03:11,059
Ahora lo leemos

1532
01:03:11,059 --> 01:03:12,760
Ahora lo leemos

1533
01:03:12,760 --> 01:03:16,099
Vale, entonces, nombre del empleado

1534
01:03:16,099 --> 01:03:17,480
Aquí, nombre del empleado

1535
01:03:17,480 --> 01:03:18,240
Sueldo

1536
01:03:18,240 --> 01:03:21,519
Pues esto se va a guardar en un dabble

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

1538
01:03:39,880 --> 01:03:44,619
Lo dejamos ahí guardadito, tenemos ya el nombre y el sueldo para instanciarlo cuando toque.

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

1540
01:03:50,720 --> 01:03:52,680
aquí es donde nos toca

1541
01:03:52,680 --> 01:03:55,520
indagar y buscar en la documentación

1542
01:03:55,520 --> 01:03:56,960
de date y decir, vamos a ver

1543
01:03:56,960 --> 01:03:59,080
¿cómo construyo un objeto

1544
01:03:59,080 --> 01:04:01,360
fecha a partir de

1545
01:04:01,360 --> 01:04:03,120
un string que me digan

1546
01:04:03,120 --> 01:04:05,000
3 de abril, ¿cómo lo hago?

1547
01:04:05,900 --> 01:04:07,280
pues no pasa nada, uno hace

1548
01:04:07,280 --> 01:04:09,100
lo que tiene que hacer en este caso

1549
01:04:09,100 --> 01:04:10,660
pues se abre

1550
01:04:10,660 --> 01:04:11,940
su Google

1551
01:04:11,940 --> 01:04:15,100
evita preguntarle a chat GPT

1552
01:04:15,100 --> 01:04:17,360
y lo busca en los foros

1553
01:04:17,360 --> 01:04:19,300
o directamente en la documentación de Oracle

1554
01:04:19,300 --> 01:04:20,260
directamente

1555
01:04:20,260 --> 01:04:22,600
entonces

1556
01:04:22,600 --> 01:04:25,800
hace una búsqueda correcta

1557
01:04:25,800 --> 01:04:28,120
buscando a ver que quiero yo instanciar

1558
01:04:28,120 --> 01:04:30,160
adiós

1559
01:04:30,160 --> 01:04:31,500
objeto date

1560
01:04:31,500 --> 01:04:32,900
java

1561
01:04:32,900 --> 01:04:35,800
stream porque me lo va

1562
01:04:35,800 --> 01:04:37,720
yo lo voy a leer con una calle en un stream

1563
01:04:37,720 --> 01:04:39,720
hace una búsqueda porque

1564
01:04:39,720 --> 01:04:41,720
hay que aprender

1565
01:04:41,720 --> 01:04:43,760
a solucionar problemas

1566
01:04:43,760 --> 01:04:45,100
haciendo búsquedas aquí

1567
01:04:45,100 --> 01:04:47,860
porque ese es el 30% de vuestro

1568
01:04:47,860 --> 01:04:49,880
trabajo y cuidado

1569
01:04:49,880 --> 01:04:50,740
con el chat GPT

1570
01:04:50,740 --> 01:04:53,920
porque bueno, todavía en estas cosas

1571
01:04:53,920 --> 01:04:55,880
tan básicas vale, pero en cuanto

1572
01:04:55,880 --> 01:04:57,460
te sales un poquito de lo básico

1573
01:04:57,460 --> 01:04:59,800
no te dice más que gilipolleces, y cuando se lo recuerdas

1574
01:04:59,800 --> 01:05:01,220
te dice, uy, perdona, es verdad

1575
01:05:01,220 --> 01:05:03,059
y de ahí no sales

1576
01:05:03,059 --> 01:05:06,160
vale, ¿cómo convertir

1577
01:05:06,160 --> 01:05:07,860
un de stream para date

1578
01:05:07,860 --> 01:05:09,800
en java? uy, esto tiene toda la pinta

1579
01:05:09,800 --> 01:05:11,800
crear un date a partir de un stream, ah, pues mira

1580
01:05:11,800 --> 01:05:13,579
tiene pinta de que esto es justo lo que queremos hacer

1581
01:05:13,579 --> 01:05:15,900
a partir de un stream que hemos leído del teclado

1582
01:05:15,900 --> 01:05:17,840
crear un date, tiene pinta de que

1583
01:05:17,840 --> 01:05:18,760
este nos va a resolver

1584
01:05:18,760 --> 01:05:21,320
el problema, y yo si tengo internet

1585
01:05:21,320 --> 01:05:22,000
vale

1586
01:05:22,000 --> 01:05:25,460
entonces me dice

1587
01:05:25,460 --> 01:05:27,680
mira, este es tu string, el que tú habrás

1588
01:05:27,680 --> 01:05:28,880
leído de la consola

1589
01:05:28,880 --> 01:05:31,440
pues lo que tendrás que hacer será

1590
01:05:31,440 --> 01:05:33,480
hacerle un parse

1591
01:05:33,480 --> 01:05:35,500
mediante un objeto formater

1592
01:05:35,500 --> 01:05:37,840
que creas así, al que le dices el formato

1593
01:05:37,840 --> 01:05:38,580
de tu string

1594
01:05:38,580 --> 01:05:42,080
y ya está, ya lo tienes hecho, ah, magnífico

1595
01:05:42,080 --> 01:05:43,500
pues ya está, listo, ya lo tenemos

1596
01:05:43,500 --> 01:05:44,100
solucionado

1597
01:05:44,100 --> 01:05:47,240
ya lo tenemos, vamos a escribirlo y una vez escrito

1598
01:05:47,240 --> 01:05:49,480
¿Vale?

1599
01:05:54,240 --> 01:05:54,940
Vale, pues

1600
01:05:54,940 --> 01:05:57,600
¿Cómo funciona date?

1601
01:05:58,400 --> 01:06:00,100
Pues te dice, ah, te tienes que crear

1602
01:06:00,100 --> 01:06:01,460
Un objeto este

1603
01:06:01,460 --> 01:06:03,860
Pues venga, lo importamos, ¿vale?

1604
01:06:07,020 --> 01:06:07,420
Vale

1605
01:06:07,420 --> 01:06:10,120
Y ahora, le dices en el formato

1606
01:06:10,120 --> 01:06:12,000
En el que le vas a pedir tú la fecha

1607
01:06:12,000 --> 01:06:14,300
En string, nos gusta pedírsela así

1608
01:06:14,300 --> 01:06:15,400
Año, mes y día, bueno

1609
01:06:15,400 --> 01:06:17,260
esto es muy inglés

1610
01:06:17,260 --> 01:06:19,039
vamos a pedirlo en español

1611
01:06:19,039 --> 01:06:20,220
perdón

1612
01:06:20,220 --> 01:06:26,039
a ver, pero esto es para hacer

1613
01:06:26,039 --> 01:06:27,240
el cambio de string a date

1614
01:06:27,240 --> 01:06:29,480
tú desde consola solo puedes leer string

1615
01:06:29,480 --> 01:06:32,200
entonces el string lo tienes que pasar

1616
01:06:32,200 --> 01:06:32,880
a objeto date

1617
01:06:32,880 --> 01:06:34,820
y este es el que te hace la conversión

1618
01:06:34,820 --> 01:06:37,280
entonces

1619
01:06:37,280 --> 01:06:39,059
tú ahora ya

1620
01:06:39,059 --> 01:06:40,900
cuando tengas tu cadena leída

1621
01:06:40,900 --> 01:06:42,720
vamos a leer la fecha en cadena

1622
01:06:42,720 --> 01:06:46,300
La fecha en texto

1623
01:06:46,300 --> 01:06:48,420
Pues la fecha en texto

1624
01:06:48,420 --> 01:06:50,600
La leeremos, vamos a pedírsela

1625
01:06:50,600 --> 01:06:51,540
Vamos a decirle

1626
01:06:51,540 --> 01:06:53,040
Introduzca

1627
01:06:53,040 --> 01:06:58,800
Introduzca fecha en formato

1628
01:06:58,800 --> 01:07:00,680
Y vamos a decirle

1629
01:07:00,680 --> 01:07:01,600
El formato

1630
01:07:01,600 --> 01:07:04,040
Que yo voy a necesitar

1631
01:07:04,040 --> 01:07:05,360
Para hacer la conversión

1632
01:07:05,360 --> 01:07:09,980
Le decimos, venga, introduzca fecha

1633
01:07:09,980 --> 01:07:10,880
En este formato

1634
01:07:10,880 --> 01:07:13,519
vale, la leemos en cadena

1635
01:07:13,519 --> 01:07:15,260
porque de la consola solo podemos leer

1636
01:07:15,260 --> 01:07:16,220
en formato cadena

1637
01:07:16,220 --> 01:07:19,380
ahora tenemos la fecha

1638
01:07:19,380 --> 01:07:19,960
en string

1639
01:07:19,960 --> 01:07:23,220
pero en string no nos vale

1640
01:07:23,220 --> 01:07:25,079
nosotros la queremos así

1641
01:07:25,079 --> 01:07:27,880
así la queremos

1642
01:07:27,880 --> 01:07:29,039
para pasársela al constructor

1643
01:07:29,039 --> 01:07:31,559
vale, pero es que la podemos convertir

1644
01:07:31,559 --> 01:07:32,980
mediante este

1645
01:07:32,980 --> 01:07:35,200
parser de arriba con el método

1646
01:07:35,200 --> 01:07:35,880
parser

1647
01:07:35,880 --> 01:07:38,619
y le pasamos el string

1648
01:07:38,619 --> 01:07:39,920
y ya está

1649
01:07:39,920 --> 01:07:47,559
Vale, ahora quitamos el rojo

1650
01:07:47,559 --> 01:07:49,500
No, no, es la excepción

1651
01:07:49,500 --> 01:07:51,820
Pero no os da igual, ahora mismo ya lo quitamos

1652
01:07:51,820 --> 01:07:55,700
Entonces, esto es una cosa que podemos

1653
01:07:55,700 --> 01:07:57,180
Usar habitualmente

1654
01:07:57,180 --> 01:07:58,340
Entonces

1655
01:07:58,340 --> 01:08:01,400
¿Necesitas un segundo objeto para pasárselo al primero?

1656
01:08:02,920 --> 01:08:04,980
Claro, pero este objeto es el conversor

1657
01:08:04,980 --> 01:08:06,559
O sea, conviertes

1658
01:08:06,559 --> 01:08:07,260
Destina date

1659
01:08:07,260 --> 01:08:09,060
y para convertir de string a date

1660
01:08:09,060 --> 01:08:10,680
te hace falta un objeto conversor

1661
01:08:10,680 --> 01:08:12,600
y el objeto conversor es este

1662
01:08:12,600 --> 01:08:15,420
este objeto conversor te hace el parse

1663
01:08:15,420 --> 01:08:16,600
de esta fecha cadena

1664
01:08:16,600 --> 01:08:18,840
y te la devuelve el objeto date

1665
01:08:18,840 --> 01:08:22,940
tú no puedes leer de consola directamente el objeto

1666
01:08:22,940 --> 01:08:27,340
o sea string no tiene un parse

1667
01:08:27,340 --> 01:08:29,320
para que tú pases automáticamente a date

1668
01:08:29,320 --> 01:08:31,520
no lo tiene, tienes que hacer un objeto

1669
01:08:31,520 --> 01:08:32,960
que es capaz de

1670
01:08:32,960 --> 01:08:34,920
porque string cuando se hizo string

1671
01:08:34,920 --> 01:08:36,560
o sea, no tiene por qué ser

1672
01:08:36,560 --> 01:08:38,480
string consciente de que hay una clase date

1673
01:08:38,480 --> 01:08:40,859
que tú la puedes transformar, no puedes hacer un casting tampoco

1674
01:08:40,859 --> 01:08:42,640
no puedes coger el string

1675
01:08:42,640 --> 01:08:44,380
este que has leído, aquí

1676
01:08:44,380 --> 01:08:46,220
y hacerle un casting a date

1677
01:08:46,220 --> 01:08:48,100
ese casting no va a funcionar

1678
01:08:48,100 --> 01:08:50,600
¿vale? entonces la clase date

1679
01:08:50,600 --> 01:08:52,579
te ofrece un conversor

1680
01:08:52,579 --> 01:08:55,279
bueno, no es que te ofrezca un conversor

1681
01:08:55,279 --> 01:08:57,039
la clase date va asociada a un conversor

1682
01:08:57,039 --> 01:08:59,020
que te dice, oye, si tienes una fecha

1683
01:08:59,020 --> 01:09:00,680
en string, que aquí la tenemos

1684
01:09:00,680 --> 01:09:02,940
una fecha, pues este

1685
01:09:02,940 --> 01:09:04,940
objeto conversor, esa fecha

1686
01:09:04,940 --> 01:09:07,000
en string te la transforma en objeto date

1687
01:09:07,000 --> 01:09:08,880
porque un casting tal cual

1688
01:09:08,880 --> 01:09:10,480
no funciona, ¿vale?

1689
01:09:10,800 --> 01:09:12,840
Y string no tiene un método que sea

1690
01:09:12,840 --> 01:09:15,040
to date para pasar a date, tampoco lo tiene.

1691
01:09:18,140 --> 01:09:19,060
¿Vale? Entonces

1692
01:09:19,060 --> 01:09:20,940
eso por un lado, pues

1693
01:09:20,940 --> 01:09:22,860
si uno quiere manejar fechas de forma sencilla

1694
01:09:22,860 --> 01:09:25,020
leerlas por teclado y guardarlas

1695
01:09:25,020 --> 01:09:26,780
como fechas, siempre puede usar esto porque es

1696
01:09:26,780 --> 01:09:28,900
la opción más simple. Luego hay objetos

1697
01:09:28,900 --> 01:09:30,920
date más raros y más sofisticados que te permiten

1698
01:09:30,920 --> 01:09:32,420
hacer más cosas, pero esto es un poco

1699
01:09:32,420 --> 01:09:34,279
el sencillo de toda la vida

1700
01:09:34,279 --> 01:09:36,180
y segundo

1701
01:09:36,180 --> 01:09:38,159
segunda cosa que quiero que

1702
01:09:38,159 --> 01:09:40,440
continuamente vais a estar usando

1703
01:09:40,440 --> 01:09:42,579
clases y necesitando

1704
01:09:42,579 --> 01:09:44,579
indagar sobre recursos que

1705
01:09:44,579 --> 01:09:46,859
vais a necesitar, anda necesito hacer esto

1706
01:09:46,859 --> 01:09:49,060
¿cómo lo hago? pues tenéis que buscarlo

1707
01:09:49,060 --> 01:09:50,920
tenéis que buscarlo y cada vez

1708
01:09:50,920 --> 01:09:52,960
acostumbrar, pues irse uno acostumbrando

1709
01:09:52,960 --> 01:09:54,140
más a hacer búsquedas

1710
01:09:54,140 --> 01:09:56,720
lo más orientadas posible para no ir a

1711
01:09:56,720 --> 01:09:59,199
ir identificando pues en qué sitios

1712
01:09:59,199 --> 01:10:00,880
normalmente lo que te dicen

1713
01:10:00,880 --> 01:10:03,119
tiene sentido, que en esta cover flow suele ser

1714
01:10:03,119 --> 01:10:05,020
casi siempre, suele tener sentido lo que

1715
01:10:05,020 --> 01:10:06,359
dicen, ¿vale?

1716
01:10:06,739 --> 01:10:08,920
Porque obviamente, uno no puede

1717
01:10:08,920 --> 01:10:11,020
saberse todas las clases de memoria y todos los

1718
01:10:11,020 --> 01:10:12,859
métodos, es imposible, de parte se van incorporando

1719
01:10:12,859 --> 01:10:14,500
¿Cuál de ellas?

1720
01:10:14,760 --> 01:10:14,980
Esta

1721
01:10:14,980 --> 01:10:19,319
La he importado de donde me ha ofrecido

1722
01:10:19,319 --> 01:10:20,980
que era Javatex

1723
01:10:20,980 --> 01:10:21,520
creo que era

1724
01:10:21,520 --> 01:10:22,859
¿Vale?

1725
01:10:22,859 --> 01:10:24,859
Sí, gente, está útil

1726
01:10:24,859 --> 01:10:28,500
porque por ejemplo, está en el

1727
01:10:28,500 --> 01:10:30,739
de IT también, es muy útil

1728
01:10:30,739 --> 01:10:35,479
Bueno, es otro paquete con utilidades más genéricas asociadas a texto.

1729
01:10:35,479 --> 01:10:36,639
Bueno, porque está ahí.

1730
01:10:37,300 --> 01:10:41,639
No lo sé, habría que preguntarle al que diseñó el JDK.

1731
01:10:44,219 --> 01:10:45,460
Esa clase está ahí.

1732
01:10:47,119 --> 01:10:50,079
A lo mejor hay otro parser dentro de Java útil.

1733
01:10:51,939 --> 01:10:52,699
Vale, entonces.

1734
01:10:52,699 --> 01:11:00,260
este rojito de aquí es

1735
01:11:00,260 --> 01:11:02,559
porque esto puede

1736
01:11:02,559 --> 01:11:04,199
que te crea una excepción

1737
01:11:04,199 --> 01:11:06,139
porque el objeto este te dice

1738
01:11:06,139 --> 01:11:08,139
oye, yo estoy confiando

1739
01:11:08,139 --> 01:11:10,559
en que ese string que me estás pasando

1740
01:11:10,559 --> 01:11:12,819
tenga el formato

1741
01:11:12,819 --> 01:11:14,139
para el que yo me he construido

1742
01:11:14,139 --> 01:11:16,679
o sea, este formateador

1743
01:11:16,679 --> 01:11:19,199
se especializa

1744
01:11:19,199 --> 01:11:20,619
en un

1745
01:11:20,619 --> 01:11:21,960
formato de fecha

1746
01:11:21,960 --> 01:11:23,640
Yo lo he hecho para este formato

1747
01:11:23,640 --> 01:11:24,980
Especializar este formato

1748
01:11:24,980 --> 01:11:28,279
Si yo luego le paso una cadena que no está en este formato

1749
01:11:28,279 --> 01:11:30,420
Se va a volver loco

1750
01:11:30,420 --> 01:11:31,920
Entonces

1751
01:11:31,920 --> 01:11:33,380
La forma de

1752
01:11:33,380 --> 01:11:35,840
Garantizar eso es que esta clase

1753
01:11:35,840 --> 01:11:38,220
Está hecha para que te lance una excepción

1754
01:11:38,220 --> 01:11:40,520
Es decir, unas letritas rojas

1755
01:11:40,520 --> 01:11:41,640
Si

1756
01:11:41,640 --> 01:11:43,619
Le pasas la cadena mal

1757
01:11:43,619 --> 01:11:46,119
Cuando veamos excepciones ya entenderemos

1758
01:11:46,119 --> 01:11:47,760
Este mecanismo en realidad que aporta

1759
01:11:47,760 --> 01:11:48,500
Que aporta mucho

1760
01:11:48,500 --> 01:11:50,880
A nosotros ahora mismo, efectos prácticos

1761
01:11:50,880 --> 01:11:52,779
en lo que se traduce es

1762
01:11:52,779 --> 01:11:54,760
que el formater te dice, ojo

1763
01:11:54,760 --> 01:11:57,000
que cuando me pases la cadena mal voy a hacer

1764
01:11:57,000 --> 01:11:58,579
cosas muy raras, ojo

1765
01:11:58,579 --> 01:12:00,859
y te avisa con rojo

1766
01:12:00,859 --> 01:12:01,920
entonces para que se calle

1767
01:12:01,920 --> 01:12:04,400
lo que hacemos es simplemente

1768
01:12:04,400 --> 01:12:07,140
hacer el a throws

1769
01:12:07,140 --> 01:12:08,680
esto

1770
01:12:08,680 --> 01:12:12,460
en el método mail

1771
01:12:12,460 --> 01:12:15,000
hacemos y decimos, vale, no te preocupes

1772
01:12:15,000 --> 01:12:16,739
si lo que quieres es que yo avise de que

1773
01:12:16,739 --> 01:12:18,480
la puedes cagar con el parse, yo aviso

1774
01:12:18,480 --> 01:12:21,980
avisas y el compilador ya se queda tranquilo

1775
01:12:21,980 --> 01:12:23,340
vale, ya se ha avisado

1776
01:12:23,340 --> 01:12:25,540
ahora mismo se traduce en esto

1777
01:12:25,540 --> 01:12:27,540
para nosotros, luego ya entenderemos un poco

1778
01:12:27,540 --> 01:12:29,340
esto que aporta y que

1779
01:12:29,340 --> 01:12:30,880
porque nos es útil

1780
01:12:30,880 --> 01:12:32,880
pero ahora como tenemos que seguir trabajando

1781
01:12:32,880 --> 01:12:35,200
pues para que el compilador se calle

1782
01:12:35,200 --> 01:12:37,540
me obliga a avisar de que, ojo, cuidado

1783
01:12:37,540 --> 01:12:39,140
que ese objeto que hace el parse

1784
01:12:39,140 --> 01:12:41,460
puede que te haga algo raro, como le metas mal

1785
01:12:41,460 --> 01:12:43,340
la cadena, vale, pues ya está, si yo aviso

1786
01:12:43,340 --> 01:12:44,580
no pasa nada, si es por eso

1787
01:12:44,579 --> 01:12:49,439
si, podríamos poner también un try catch

1788
01:12:49,439 --> 01:12:51,399
lo que pasa es que no quiero complicar el código

1789
01:12:51,399 --> 01:12:52,880
porque ya en el case ya es muy largo

1790
01:12:52,880 --> 01:12:54,579
entonces es más cómodo

1791
01:12:54,579 --> 01:12:55,859
siempre tienes las dos opciones

1792
01:12:55,859 --> 01:12:57,340
siempre tienes las dos

1793
01:12:57,340 --> 01:13:00,180
yo es que cuando hicimos la clase

1794
01:13:00,180 --> 01:13:05,000
esta sería la de pasarle el problema al de arriba

1795
01:13:05,000 --> 01:13:06,640
y el otro sería

1796
01:13:06,640 --> 01:13:07,659
ocuparte tú de él

1797
01:13:07,659 --> 01:13:10,300
el try catch es, cuidado, si hay un error yo me ocupo

1798
01:13:10,300 --> 01:13:12,420
y en el catch te digo lo que voy a hacer, yo me ocupo

1799
01:13:12,420 --> 01:13:13,859
y este sería

1800
01:13:13,859 --> 01:13:16,579
si hay un problema, para afuera

1801
01:13:16,579 --> 01:13:18,179
el que me haya llamado

1802
01:13:18,179 --> 01:13:20,619
que ya se ocupe, yo no me ocupe

1803
01:13:20,619 --> 01:13:22,359
¿vale? entonces, ahora

1804
01:13:22,359 --> 01:13:24,159
para no hacer el código largo

1805
01:13:24,159 --> 01:13:26,519
pues opto por esa opción

1806
01:13:26,519 --> 01:13:28,799
que es más cómoda

1807
01:13:28,799 --> 01:13:29,639
que es más cómoda

1808
01:13:29,639 --> 01:13:32,139
como todavía no estamos metidos en excepciones

1809
01:13:32,139 --> 01:13:33,199
ni las hemos estudiado

1810
01:13:33,199 --> 01:13:36,339
¿vale? bueno, pues entonces

1811
01:13:36,339 --> 01:13:38,479
ala, ya tengo

1812
01:13:38,479 --> 01:13:40,659
leídos los tres parámetros

1813
01:13:40,659 --> 01:13:41,619
comunes

1814
01:13:41,619 --> 01:13:43,839
el nombre del empleado

1815
01:13:43,840 --> 01:13:57,460
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.

1816
01:13:57,980 --> 01:14:07,800
Entonces, eso ya como os guste más. Podemos hacerle una pregunta, decir, ¿es gestor? Y que nos lo diga con sí o no.

1817
01:14:07,800 --> 01:14:09,840
Sí o no

1818
01:14:09,840 --> 01:14:14,199
Vale, y ahora vamos a leer

1819
01:14:14,199 --> 01:14:16,400
Uy, perdón

1820
01:14:16,400 --> 01:14:17,840
Gerente

1821
01:14:17,840 --> 01:14:21,680
Es gerente

1822
01:14:21,680 --> 01:14:23,340
Que me lo diga con sí o no

1823
01:14:23,340 --> 01:14:24,180
Entonces leemos

1824
01:14:24,180 --> 01:14:28,260
De esta manera

1825
01:14:28,260 --> 01:14:30,180
Si teclado

1826
01:14:30,180 --> 01:14:33,420
Punto leer cadena

1827
01:14:37,800 --> 01:14:40,699
leer cadena

1828
01:14:40,699 --> 01:14:42,520
punto equals

1829
01:14:42,520 --> 01:14:44,539
ahora que ya sabemos todo lo del equals

1830
01:14:44,539 --> 01:14:46,039
y del string y de todo

1831
01:14:46,039 --> 01:14:47,579
es igual a S

1832
01:14:47,579 --> 01:14:50,920
vamos a confiar que me va a meter siempre S o N

1833
01:14:50,920 --> 01:14:52,220
porque como tenemos que verificar

1834
01:14:52,220 --> 01:14:54,340
que me mete Z o J ya

1835
01:14:54,340 --> 01:14:55,720
hacemos aquí un código larguísimo

1836
01:14:55,720 --> 01:14:58,600
¿que lo es? ¿que me ha dicho que sí?

1837
01:14:59,159 --> 01:15:00,960
pues entonces voy a tener que pedir el bonus

1838
01:15:00,960 --> 01:15:03,480
vale

1839
01:15:03,480 --> 01:15:05,600
entonces le decimos aquí

1840
01:15:05,600 --> 01:15:07,900
Que meta el bonus

1841
01:15:07,900 --> 01:15:11,079
Y lo leemos

1842
01:15:11,079 --> 01:15:13,560
Y ya de paso

1843
01:15:13,560 --> 01:15:15,860
Ya de paso

1844
01:15:15,860 --> 01:15:17,300
Creamos aquí mismo en este if

1845
01:15:17,300 --> 01:15:18,680
El gerente y lo metemos

1846
01:15:18,680 --> 01:15:20,900
Bueno no, no lo creamos aquí porque

1847
01:15:20,900 --> 01:15:24,380
Voy a doblar código a lo tonto

1848
01:15:24,380 --> 01:15:26,380
Pues venga, el bonus que es un dabble también

1849
01:15:35,600 --> 01:15:37,300
vale, pues ya está

1850
01:15:37,300 --> 01:15:39,700
si me ha dicho que sí, leo el bonus

1851
01:15:39,700 --> 01:15:41,880
en el ELSE aquí no hace falta ELSE

1852
01:15:41,880 --> 01:15:43,360
si me ha dicho que no, no tengo más que hacer

1853
01:15:43,360 --> 01:15:44,360
ahora

1854
01:15:44,360 --> 01:15:49,360
le puedo preguntar otra vez

1855
01:15:49,360 --> 01:15:50,920
¿es empleado temporal?

1856
01:15:52,940 --> 01:15:53,720
lo que pasa es

1857
01:15:53,720 --> 01:15:55,220
lo puedo meter en un ELSE, sí

1858
01:15:55,220 --> 01:15:56,460
porque así

1859
01:15:56,460 --> 01:15:59,720
si es gerente ya no pregunto si es empleado temporal

1860
01:15:59,720 --> 01:16:00,480
¿no?

1861
01:16:02,660 --> 01:16:04,039
lo puedo meter en un ELSE

1862
01:16:04,039 --> 01:16:05,340
entonces si no es gerente

1863
01:16:05,340 --> 01:16:07,760
si no es gerente, le pregunto

1864
01:16:07,760 --> 01:16:08,400
¿es temporal?

1865
01:16:20,260 --> 01:16:21,640
Sí, pero si no me

1866
01:16:21,640 --> 01:16:23,420
si no es ni este ni este

1867
01:16:23,420 --> 01:16:25,779
no tengo nada que hacer porque es un empleado

1868
01:16:25,779 --> 01:16:27,739
normal y ya con lo de arriba ya he terminado

1869
01:16:27,739 --> 01:16:29,480
entonces aquí estoy añadiendo

1870
01:16:29,480 --> 01:16:31,520
solo si está en alguno de los otros

1871
01:16:31,520 --> 01:16:33,760
dos casos particulares, porque si está el empleado

1872
01:16:33,760 --> 01:16:35,079
aquí ya habría acabado

1873
01:16:35,079 --> 01:16:57,399
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.

1874
01:17:05,079 --> 01:17:06,699
Vale, si es empleado temporal

1875
01:17:06,699 --> 01:17:08,239
Entonces lo mismo puedo hacer

1876
01:17:08,239 --> 01:17:08,899
La lectura

1877
01:17:08,899 --> 01:17:16,939
Punto equals

1878
01:17:16,939 --> 01:17:19,800
¿Sí?

1879
01:17:20,140 --> 01:17:21,180
¿Sí me ha dicho que sí?

1880
01:17:25,659 --> 01:17:26,619
Equals sí

1881
01:17:26,619 --> 01:17:29,039
Pues entonces le digo

1882
01:17:29,039 --> 01:17:30,439
Vale, mete la fecha de fin

1883
01:17:35,079 --> 01:17:39,100
¿Vale?

1884
01:17:39,239 --> 01:17:41,059
Y para meter la fecha de fin

1885
01:17:41,059 --> 01:17:43,119
¿Vale?

1886
01:17:43,159 --> 01:17:44,739
Estaría bien que en la clase teclado

1887
01:17:44,739 --> 01:17:46,579
Metiéramos el método leer fecha

1888
01:17:46,579 --> 01:17:49,399
Y así ya vamos a leer fecha

1889
01:17:49,399 --> 01:17:50,380
Y nos ahorramos

1890
01:17:50,380 --> 01:17:52,180
Todo este rollo

1891
01:17:52,180 --> 01:17:53,460
De aquí

1892
01:17:53,460 --> 01:17:56,800
¿Vale?

1893
01:17:56,800 --> 01:17:58,619
De hecho lo vamos a incorporar el próximo día

1894
01:17:58,619 --> 01:18:03,859
Bueno, no hace falta

1895
01:18:03,859 --> 01:18:04,739
Este objeto ya lo tengo

1896
01:18:04,739 --> 01:18:06,219
no hace falta que lo vuelva a declarar

1897
01:18:06,219 --> 01:18:08,719
me leo la fecha

1898
01:18:08,719 --> 01:18:10,639
texto otra vez y ahora

1899
01:18:10,639 --> 01:18:11,760
fecha de fin

1900
01:18:11,760 --> 01:18:14,519
la fecha de fin, convierto

1901
01:18:14,519 --> 01:18:16,059
la fecha texto que me he leído

1902
01:18:16,059 --> 01:18:17,319
fecha fin

1903
01:18:17,319 --> 01:18:21,760
vale, entonces aquí

1904
01:18:21,760 --> 01:18:24,219
de alguna manera hemos

1905
01:18:24,219 --> 01:18:26,559
leído todos los datos que necesitamos

1906
01:18:26,559 --> 01:18:28,479
pero ahí hay que organizar esto

1907
01:18:28,479 --> 01:18:30,159
hay que organizar esto porque ahora hay que

1908
01:18:30,159 --> 01:18:33,079
buscar dentro de la raíz de departamentos

1909
01:18:33,079 --> 01:18:34,899
el departamento que sea

1910
01:18:34,899 --> 01:18:37,059
y a ese departamento llamarle a de empleado.

1911
01:18:38,140 --> 01:18:39,380
Entonces, ahora hay que meter aquí

1912
01:18:39,380 --> 01:18:41,960
la instanciación del objeto correcto.

1913
01:18:43,000 --> 01:18:44,539
Hay que meter aquí la instanciación del objeto correcto.

1914
01:18:45,340 --> 01:18:49,319
Ahora ya se trata de instanciar el objeto correcto

1915
01:18:49,319 --> 01:18:51,939
y añadírselo al departamento que sea.

1916
01:18:53,519 --> 01:18:55,619
Entonces, ¿dónde va a ser lo más cómodo?

1917
01:18:56,720 --> 01:18:58,000
Pues lo más cómodo va a ser

1918
01:18:58,000 --> 01:19:00,840
si es gerente,

1919
01:19:00,840 --> 01:19:03,239
Aquí mismo ya directamente

1920
01:19:03,239 --> 01:19:05,340
Instanciar el objeto gerente

1921
01:19:05,340 --> 01:19:06,440
Y añadirlo al departamento

1922
01:19:06,440 --> 01:19:09,699
Si no es gerente y es empleado

1923
01:19:09,699 --> 01:19:11,800
Aquí mismo ya

1924
01:19:11,800 --> 01:19:13,720
Dentro de este if

1925
01:19:13,720 --> 01:19:15,659
Instanciar el objeto empleado

1926
01:19:15,659 --> 01:19:16,279
Temporal

1927
01:19:16,279 --> 01:19:18,319
Y añadirlo al departamento

1928
01:19:18,319 --> 01:19:20,659
Y si no

1929
01:19:20,659 --> 01:19:20,980
Pues

1930
01:19:20,980 --> 01:19:24,640
Vale

1931
01:19:24,640 --> 01:19:26,560
Buscamos entonces

1932
01:19:26,560 --> 01:19:29,600
Aquí que sería interesante

1933
01:19:29,600 --> 01:19:32,160
primero vamos a localizar el departamento

1934
01:19:32,160 --> 01:19:33,500
al que hay que añadirlo, ¿verdad?

1935
01:19:34,000 --> 01:19:35,480
el departamento al que hay que añadirlo

1936
01:19:35,480 --> 01:19:38,100
por ejemplo, nos vamos aquí, una vez que teníamos el nombre

1937
01:19:38,100 --> 01:19:39,760
vamos a localizar el departamento

1938
01:19:39,760 --> 01:19:42,520
primero, localizamos

1939
01:19:42,520 --> 01:19:44,160
el departamento

1940
01:19:45,060 --> 01:19:46,720
al que hay que añadir

1941
01:19:46,720 --> 01:19:47,000
este

1942
01:19:47,000 --> 01:19:49,980
sí

1943
01:19:49,980 --> 01:19:58,400
por ahora es una variable que voy a usar

1944
01:19:58,400 --> 01:19:59,900
para instanciar el empleado temporal.

1945
01:20:00,060 --> 01:20:01,560
O sea, empleado temporal va a necesitar

1946
01:20:01,560 --> 01:20:05,320
el fecha que tenía la de inicio,

1947
01:20:05,420 --> 01:20:06,960
la común para todas, más fecha fin.

1948
01:20:14,720 --> 01:20:17,040
Claro, esta va a ser para inicializar esa.

1949
01:20:18,240 --> 01:20:19,340
Es el dato de entrada,

1950
01:20:19,620 --> 01:20:20,940
pero todavía no he construido el objeto.

1951
01:20:21,300 --> 01:20:22,660
Lo voy a usar para cuando construya el objeto.

1952
01:20:23,680 --> 01:20:25,420
Vale, pues vamos a localizar el departamento.

1953
01:20:25,700 --> 01:20:27,380
Entonces, para localizar el departamento,

1954
01:20:27,380 --> 01:20:30,020
Pues aquí simplemente podemos hacer

1955
01:20:30,020 --> 01:20:32,340
El departamento al que hay que añadir

1956
01:20:32,340 --> 01:20:33,859
Departamento

1957
01:20:33,859 --> 01:20:35,560
Al que hay que añadir de

1958
01:20:35,560 --> 01:20:38,940
Vamos a localizarlo

1959
01:20:38,940 --> 01:20:40,260
Y podríamos hacer

1960
01:20:40,260 --> 01:20:40,680
Si

1961
01:20:40,680 --> 01:20:42,880
Un for

1962
01:20:42,880 --> 01:20:48,680
Mientras si sea menor que

1963
01:20:48,680 --> 01:20:51,319
Empresa.get

1964
01:20:51,319 --> 01:20:52,520
Departamentos

1965
01:20:52,520 --> 01:20:54,640
Punto length

1966
01:20:54,640 --> 01:20:58,579
y ahora incrementando i

1967
01:20:58,579 --> 01:21:03,160
pues ahora

1968
01:21:03,160 --> 01:21:03,820
si

1969
01:21:03,820 --> 01:21:05,539
de

1970
01:21:05,539 --> 01:21:09,060
en .get

1971
01:21:09,060 --> 01:21:10,360
departamentos

1972
01:21:10,360 --> 01:21:12,720
de i

1973
01:21:12,720 --> 01:21:16,800
.get

1974
01:21:16,800 --> 01:21:17,340
nombre

1975
01:21:17,340 --> 01:21:21,160
es igual al que me han dado

1976
01:21:24,640 --> 01:21:28,000
Al nombre de este de aquí

1977
01:21:34,640 --> 01:21:36,020
¿Qué hay aquí con la letra tan grande?

1978
01:21:36,980 --> 01:21:38,700
Pues entonces ya he encontrado

1979
01:21:38,700 --> 01:21:40,579
A ver

1980
01:21:40,579 --> 01:21:41,640
Ahí

1981
01:21:41,640 --> 01:21:47,020
Entonces ya he encontrado

1982
01:21:47,020 --> 01:21:49,140
El departamento al que hay que añadir

1983
01:21:49,140 --> 01:21:51,039
Que es este, de igual a

1984
01:21:51,039 --> 01:21:54,500
Em, getDepartamentos, de ahí

1985
01:21:54,500 --> 01:22:01,619
vale, entonces este primer

1986
01:22:01,619 --> 01:22:03,600
esto primero de aquí

1987
01:22:03,600 --> 01:22:07,939
esto primero de aquí

1988
01:22:07,939 --> 01:22:09,699
primero hemos localizado

1989
01:22:09,699 --> 01:22:11,979
el departamento dentro de la raíz

1990
01:22:11,979 --> 01:22:14,300
de departamentos al que hay que añadirle

1991
01:22:14,300 --> 01:22:15,420
el empleado

1992
01:22:15,420 --> 01:22:19,779
vale, hemos recorrido la raíz de departamentos

1993
01:22:19,779 --> 01:22:21,300
de la empresa, que es este

1994
01:22:21,300 --> 01:22:23,060
la raíz de departamentos

1995
01:22:23,060 --> 01:22:25,060
lo hemos recorrido con este for

1996
01:22:25,060 --> 01:22:28,980
hemos visto cuál de todos

1997
01:22:28,980 --> 01:22:30,800
esos departamentos de la red de departamentos

1998
01:22:30,800 --> 01:22:32,860
su nombre es este que me han pasado

1999
01:22:32,860 --> 01:22:33,539
por teclado

2000
01:22:33,539 --> 01:22:36,800
y cuando lo haya encontrado lo guardo ahí

2001
01:22:36,800 --> 01:22:38,560
vale, para tener en esta referencia

2002
01:22:38,560 --> 01:22:41,060
ahí ya, en esa referencia más cómoda

2003
01:22:41,060 --> 01:22:42,240
en esa referencia

2004
01:22:42,240 --> 01:22:43,320
tengo ya

2005
01:22:43,320 --> 01:22:45,539
mi departamento

2006
01:22:45,539 --> 01:22:49,080
y ahora ya a ese departamento le tengo que añadir

2007
01:22:49,080 --> 01:22:50,920
el nuevo empleado que toco

2008
01:22:50,920 --> 01:22:52,280
con los datos de abajo

2009
01:22:52,279 --> 01:23:02,300
vale, pues a ver

2010
01:23:02,300 --> 01:23:04,759
ahora, ¿qué es lo que hemos

2011
01:23:04,759 --> 01:23:06,500
hecho después? leer los datos

2012
01:23:06,500 --> 01:23:11,819
entonces

2013
01:23:11,819 --> 01:23:13,659
si es

2014
01:23:13,659 --> 01:23:16,019
si me han dicho que es gerente

2015
01:23:16,019 --> 01:23:18,340
si me han dicho que es gerente

2016
01:23:18,340 --> 01:23:20,639
he entrado por aquí, aquí ya puedo

2017
01:23:20,640 --> 01:23:22,720
añadir a ese un nuevo

2018
01:23:22,720 --> 01:23:24,100
adempleado

2019
01:23:24,100 --> 01:23:26,700
gerente ya directamente porque tengo

2020
01:23:26,700 --> 01:23:28,880
todos los datos, new gerente

2021
01:23:28,880 --> 01:23:29,940
y gerente necesita

2022
01:23:29,940 --> 01:23:32,900
el nombre que lo acabo de leer

2023
01:23:32,900 --> 01:23:34,760
nom

2024
01:23:34,760 --> 01:23:35,280
emp

2025
01:23:35,280 --> 01:23:39,079
el sueldo que lo acabo de leer

2026
01:23:39,079 --> 01:23:42,980
la fecha de comienzo

2027
01:23:42,980 --> 01:23:44,640
que la he leído ahí en fecha

2028
01:23:44,640 --> 01:23:47,180
y el bonus

2029
01:23:47,180 --> 01:23:48,160
que lo acabo de leer

2030
01:23:48,159 --> 01:23:52,079
y cierro

2031
01:23:52,079 --> 01:23:52,699
vale

2032
01:23:52,699 --> 01:23:54,739
pues si es gerente

2033
01:23:54,739 --> 01:23:57,300
estoy en el if de gerente

2034
01:23:57,300 --> 01:23:58,220
si es gerente

2035
01:23:58,220 --> 01:24:00,059
añado al departamento

2036
01:24:00,059 --> 01:24:01,399
un empleado gerente

2037
01:24:01,399 --> 01:24:02,039
con esos datos

2038
01:24:02,039 --> 01:24:03,079
y ya está

2039
01:24:03,079 --> 01:24:03,720
vale

2040
01:24:03,720 --> 01:24:05,960
vale

2041
01:24:05,960 --> 01:24:07,019
en este else de aquí

2042
01:24:07,019 --> 01:24:08,340
en este else estaba

2043
01:24:08,340 --> 01:24:11,059
si es empleado temporal

2044
01:24:11,059 --> 01:24:13,439
entonces cuando yo estoy aquí

2045
01:24:13,439 --> 01:24:14,079
en este punto

2046
01:24:14,079 --> 01:24:15,680
es porque es empleado temporal

2047
01:24:15,680 --> 01:24:16,659
pues entonces

2048
01:24:16,659 --> 01:24:18,239
a mi D le añado

2049
01:24:18,239 --> 01:24:21,180
una de empleado pero que en este caso

2050
01:24:21,180 --> 01:24:22,880
será un new empleado

2051
01:24:22,880 --> 01:24:24,859
temporal

2052
01:24:24,859 --> 01:24:27,840
al que le doy los datos

2053
01:24:27,840 --> 01:24:29,159
que los datos van a ser

2054
01:24:29,159 --> 01:24:31,220
el nombre del empleado

2055
01:24:31,220 --> 01:24:33,760
el sueldo

2056
01:24:33,760 --> 01:24:36,920
la fecha

2057
01:24:36,920 --> 01:24:38,899
y la fecha fin

2058
01:24:38,899 --> 01:24:40,960
que acabo de leer

2059
01:24:40,960 --> 01:24:45,220
y cierro

2060
01:24:45,220 --> 01:24:46,220
vale

2061
01:24:46,220 --> 01:24:52,560
¿Vale?

2062
01:24:55,900 --> 01:24:56,380
Entonces

2063
01:24:56,380 --> 01:24:57,940
Me falta colocar aquí

2064
01:24:57,940 --> 01:24:59,079
Donde coloco

2065
01:24:59,079 --> 01:25:01,400
Si no es ninguno de los anteriores

2066
01:25:01,400 --> 01:25:03,860
Entonces esto casi mejor si lo hago como un if

2067
01:25:03,860 --> 01:25:06,440
Else if y dejo el else para que sea empleado

2068
01:25:06,440 --> 01:25:06,760
¿Verdad?

2069
01:25:08,880 --> 01:25:10,140
O sea, si es gerente

2070
01:25:10,140 --> 01:25:11,039
Ya está

2071
01:25:11,039 --> 01:25:13,600
Else if

2072
01:25:13,600 --> 01:25:17,640
sería

2073
01:25:17,640 --> 01:25:19,740
a ver

2074
01:25:19,740 --> 01:25:22,460
es que no quiero complicar el código

2075
01:25:22,460 --> 01:25:24,700
pero entendéis lo que estoy, ya lo he complicado mucho

2076
01:25:24,700 --> 01:25:26,940
claro, por no sacar a métodos

2077
01:25:26,940 --> 01:25:28,620
este es el problema, si no sacas a métodos

2078
01:25:28,620 --> 01:25:30,860
pero a ver, estáis entendiendo lo que estamos haciendo

2079
01:25:30,860 --> 01:25:32,560
si es que estamos haciendo lo mismo de una otra vez

2080
01:25:32,560 --> 01:25:34,740
lo que pasa es que son muchas líneas, pero es hacer lo mismo

2081
01:25:34,740 --> 01:25:35,420
todo el rato

2082
01:25:35,420 --> 01:25:38,300
entonces aquí lo único que estoy mirando es

2083
01:25:38,300 --> 01:25:40,980
donde colocar, para que no quede demasiado feo

2084
01:25:40,980 --> 01:25:43,240
la instanciación del empleado

2085
01:25:43,239 --> 01:25:47,899
Porque aquí si es gerente ya he terminado

2086
01:25:47,899 --> 01:25:49,019
Lo de alzaría

2087
01:25:49,019 --> 01:25:50,800
¿Vale?

2088
01:25:51,479 --> 01:25:52,819
Si no es gerente

2089
01:25:52,819 --> 01:25:54,380
Pregunto

2090
01:25:54,380 --> 01:25:57,439
Y ahora este if

2091
01:25:57,439 --> 01:25:59,380
Aquí, sería aquí

2092
01:25:59,380 --> 01:26:02,039
¿Vale? Pues lo podría poner aquí mismo

2093
01:26:02,039 --> 01:26:04,139
¿Por qué? Esto me dice

2094
01:26:04,139 --> 01:26:05,119
Que es

2095
01:26:05,119 --> 01:26:11,239
Sí, sí, sí

2096
01:26:11,239 --> 01:26:12,559
Seguramente

2097
01:26:12,560 --> 01:26:14,940
que sí, que sí

2098
01:26:14,940 --> 01:26:19,539
efectivamente, que sí

2099
01:26:19,539 --> 01:26:21,080
¿qué nos enseña eso?

2100
01:26:21,160 --> 01:26:22,960
que siempre es mucho mejor

2101
01:26:22,960 --> 01:26:25,400
hacerse, antes de empezar a escribir código

2102
01:26:25,400 --> 01:26:27,480
siempre un diseñito

2103
01:26:27,480 --> 01:26:29,560
previo, ya no solo de tu aplicación

2104
01:26:29,560 --> 01:26:30,640
con las claves, que eso está claro

2105
01:26:30,640 --> 01:26:32,220
sino cuando quieres hacer un código

2106
01:26:32,220 --> 01:26:35,160
claro, claro, cuando quieres

2107
01:26:35,160 --> 01:26:37,020
hacer un código, siempre, siempre

2108
01:26:37,020 --> 01:26:39,280
es deseable, hacerte antes un diseño

2109
01:26:39,280 --> 01:26:40,539
previo de cómo lo vas a organizar

2110
01:26:40,539 --> 01:26:41,820
porque aquí, ¿qué estamos haciendo?

2111
01:26:42,560 --> 01:26:44,180
directamente estamos escribiendo,

2112
01:26:44,620 --> 01:26:45,740
quiero hacer esto, lo voy haciendo.

2113
01:26:46,120 --> 01:26:47,380
Y cada vez lo vamos resolviendo.

2114
01:26:47,920 --> 01:26:49,380
Pero el resultado final que nos queda,

2115
01:26:49,780 --> 01:26:50,620
pues puede no gustarnos.

2116
01:26:51,600 --> 01:26:55,080
Entonces, lo evitamos si antes uno se coge un papel

2117
01:26:55,080 --> 01:26:57,560
y dice, a ver, yo tengo que leer estos datos,

2118
01:26:57,660 --> 01:26:59,340
con esto construir esto, si hace esto, esto.

2119
01:26:59,800 --> 01:27:00,880
¿Cómo lo voy a organizar?

2120
01:27:01,600 --> 01:27:03,220
Una vez que tengamos el juego de organizarlo,

2121
01:27:03,780 --> 01:27:04,740
te pones a escribir código.

2122
01:27:04,920 --> 01:27:06,000
Porque lo que hemos hecho ahora es,

2123
01:27:06,380 --> 01:27:08,660
ponernos a escribir código para resolver esto sobre la marcha.

2124
01:27:08,760 --> 01:27:10,200
Podemos resolverlo porque sabemos hacerlo,

2125
01:27:10,199 --> 01:27:11,519
pero es verdad que luego a lo mejor

2126
01:27:11,519 --> 01:27:13,920
nos sale más enrevesado de lo que nos saldría

2127
01:27:13,920 --> 01:27:16,519
si hubiéramos hecho un papelito

2128
01:27:16,519 --> 01:27:18,800
el enunciado te dice

2129
01:27:18,800 --> 01:27:20,800
que crees un empleado y lo añades al departamento

2130
01:27:20,800 --> 01:27:21,840
estamos haciendo lo que te dice el enunciado

2131
01:27:21,840 --> 01:27:23,439
pues eso

2132
01:27:23,439 --> 01:27:26,439
que estamos haciendo lo que te dice el enunciado

2133
01:27:26,439 --> 01:27:30,460
a ver, claro

2134
01:27:30,460 --> 01:27:32,420
obviamente, pero la idea es complicar

2135
01:27:32,420 --> 01:27:34,460
la vida y porque uno

2136
01:27:34,460 --> 01:27:36,380
ve si tiene soltura o tiene que hacer muchas

2137
01:27:36,380 --> 01:27:37,479
cosas raras, claro

2138
01:27:37,480 --> 01:27:42,260
Pero a ver, que esto ya es meterlo en el ELSE y ya hemos terminado, ¿no?

2139
01:27:43,120 --> 01:27:48,060
Si en realidad no es tanto, es, leemos el nombre del departamento y lo localizamos, ¿vale?

2140
01:27:49,100 --> 01:27:51,720
Esa es la primera parte, leer nombre del departamento y localizado.

2141
01:27:52,220 --> 01:27:58,860
Ahora, leemos los datos del empleado, los comunes, que son estos, y los específicos.

2142
01:27:59,360 --> 01:28:03,880
Y ahora ya, en el ELSE que toque, añado el departamento que sea.

2143
01:28:04,140 --> 01:28:05,840
En realidad son tres partes las que hemos hecho.

2144
01:28:05,840 --> 01:28:08,860
localizar departamento, pedir datos

2145
01:28:08,860 --> 01:28:10,199
y añadir

2146
01:28:10,199 --> 01:28:12,460
en cada una de las tres opciones

2147
01:28:12,460 --> 01:28:14,539
el empleado, entonces

2148
01:28:14,539 --> 01:28:16,860
¿qué es gerente? añade el empleado

2149
01:28:16,860 --> 01:28:19,079
gerente, que no, ¿es empleado

2150
01:28:19,079 --> 01:28:21,020
temporal? añado el temporal

2151
01:28:21,020 --> 01:28:22,940
¿que tampoco? es porque es empleado

2152
01:28:22,940 --> 01:28:25,060
normal, pues ya está, entonces lo añado

2153
01:28:25,060 --> 01:28:26,880
a de empleado

2154
01:28:26,880 --> 01:28:29,100
new, empleado

2155
01:28:29,100 --> 01:28:30,800
con los datos que son

2156
01:28:30,800 --> 01:28:33,319
que son, nombre de empleado

2157
01:28:33,319 --> 01:28:34,860
sueldo

2158
01:28:34,859 --> 01:28:37,000
sueldo y fecha

2159
01:28:37,000 --> 01:28:39,979
y ya está

2160
01:28:39,979 --> 01:28:45,359
vale, son muchas líneas

2161
01:28:45,359 --> 01:28:47,380
pero es que son tres partes, conceptualmente

2162
01:28:47,380 --> 01:28:48,099
son tres partes

2163
01:28:48,099 --> 01:28:51,380
pedir datos del departamento y localizarlo en el array

2164
01:28:51,380 --> 01:28:53,319
eso es que hay que hacerlo sí o sí, no se puede hacer de otra manera

2165
01:28:53,319 --> 01:28:55,399
luego, pedir los datos

2166
01:28:55,399 --> 01:28:57,359
hay que pedirlo sí o sí, no se puede

2167
01:28:57,359 --> 01:28:59,000
hacer de otra manera, convertir la fecha

2168
01:28:59,000 --> 01:29:00,719
hay que convertirla sí o sí

2169
01:29:00,719 --> 01:29:03,000
otra cosa es que lo saquemos a métodos, que aquí

2170
01:29:03,000 --> 01:29:05,000
habría estado bien cambiar teclado

2171
01:29:05,000 --> 01:29:06,380
y ponerle un leer fecha.

2172
01:29:06,859 --> 01:29:09,260
Y que dentro de leer fecha te lea el string, te lo convierte

2173
01:29:09,260 --> 01:29:11,380
y te devuelva el date. Pero como no lo tenemos,

2174
01:29:11,680 --> 01:29:12,520
pues tenemos que hacerlo sí o sí.

2175
01:29:13,000 --> 01:29:15,180
Y ahora ya, este if,

2176
01:29:15,220 --> 01:29:17,100
el save, esto es lo que sí que podemos

2177
01:29:17,100 --> 01:29:19,140
remodelar. Pero siempre va a haber

2178
01:29:19,140 --> 01:29:19,899
tres ramas igual.

2179
01:29:20,720 --> 01:29:21,699
Aquí hay tres ramas.

2180
01:29:21,699 --> 01:29:22,680
Al

2181
01:29:22,680 --> 01:29:25,399
entero le has añadido además

2182
01:29:25,399 --> 01:29:27,699
el llegar departamento.

2183
01:29:27,899 --> 01:29:29,479
No estaba en la caleta.

2184
01:29:30,079 --> 01:29:31,479
Sin eso cambia mucho también.

2185
01:29:31,480 --> 01:29:33,700
A ver, el otro día

2186
01:29:33,700 --> 01:29:34,840
Yo lo que añadí fue

2187
01:29:34,840 --> 01:29:36,680
El otro día yo lo

2188
01:29:36,680 --> 01:29:39,120
Pero eso no tiene nada que ver con esta opción

2189
01:29:39,120 --> 01:29:44,320
No, esto es incorporar empleado al departamento

2190
01:29:44,320 --> 01:29:48,800
He creado un método

2191
01:29:48,800 --> 01:29:50,800
Añadir departamento a la empresa

2192
01:29:50,800 --> 01:29:52,700
Que nos ha solucionado mucho la vida

2193
01:29:52,700 --> 01:29:54,840
Pero eso nos ha solucionado la vida

2194
01:29:54,840 --> 01:29:56,560
Porque eso afectaba a esta primera parte solo

2195
01:29:56,560 --> 01:29:57,440
La segunda no tiene nada que ver

2196
01:29:57,440 --> 01:30:00,400
Y esta primera parte mira que cómoda ha quedado y que estupenda

2197
01:30:00,400 --> 01:30:04,260
ah, que sería más complicado

2198
01:30:04,260 --> 01:30:06,060
dices, si yo no hubiera hecho

2199
01:30:06,060 --> 01:30:07,860
añadir departamento, claro

2200
01:30:07,860 --> 01:30:09,060
sin añadir departamento

2201
01:30:09,060 --> 01:30:11,360
sería más complicado, sería más

2202
01:30:11,360 --> 01:30:13,940
de nuevo, ahí habría quedado un código más largo

2203
01:30:13,940 --> 01:30:15,720
efectivamente, claro

2204
01:30:15,720 --> 01:30:22,200
bueno, pues entonces

2205
01:30:22,200 --> 01:30:23,200
ya tenemos todo

2206
01:30:23,200 --> 01:30:25,100
son tres partes

2207
01:30:25,100 --> 01:30:27,240
que es que hay que hacerlas, sí o sí

2208
01:30:27,240 --> 01:30:29,840
en métodos aparte o dentro, pero es que no hay otra

2209
01:30:29,840 --> 01:30:32,039
localizar el departamento

2210
01:30:32,039 --> 01:30:33,079
localizado

2211
01:30:33,079 --> 01:30:35,380
pedir los datos, pedidos

2212
01:30:35,380 --> 01:30:36,840
y luego ya, tres ramas

2213
01:30:36,840 --> 01:30:38,880
eso ya, esas tres ramas

2214
01:30:38,880 --> 01:30:41,060
sí que puedo yo decidir cómo las saco

2215
01:30:41,060 --> 01:30:42,600
yo lo he hecho con un if, un else

2216
01:30:42,600 --> 01:30:44,659
y un if anidado en el else, que es verdad que eso es feo

2217
01:30:44,659 --> 01:30:46,800
pues esas tres ramas

2218
01:30:46,800 --> 01:30:49,239
uno las hace con un if else if, las hace con un switch case

2219
01:30:49,239 --> 01:30:51,060
las hace como sea, pero tres ramas hay

2220
01:30:51,060 --> 01:30:53,199
porque lo que hay que hacer es tres cosas

2221
01:30:53,199 --> 01:30:54,440
distintas

2222
01:30:54,440 --> 01:30:56,319
o bien añadir un new gerente

2223
01:30:56,319 --> 01:30:58,739
o bien añadir un new empleado

2224
01:30:58,739 --> 01:31:00,420
O bien hay un empleado temporal

2225
01:31:00,420 --> 01:31:02,979
Son tres cosas distintas que hay que hacer

2226
01:31:02,979 --> 01:31:04,939
¿Vale?

2227
01:31:05,059 --> 01:31:06,019
Tres cosas diferentes

2228
01:31:06,019 --> 01:31:08,359
Y ya está

2229
01:31:08,359 --> 01:31:14,699
¿Vale? Entonces

2230
01:31:14,699 --> 01:31:16,059
Esta es

2231
01:31:16,059 --> 01:31:18,739
La más liosa

2232
01:31:18,739 --> 01:31:20,659
La segunda, es que la segunda es llamar al método

2233
01:31:20,659 --> 01:31:23,059
La segunda ya hay un método

2234
01:31:23,059 --> 01:31:23,679
Que es

2235
01:31:23,679 --> 01:31:27,039
La empresa tiene un método que es

2236
01:31:27,039 --> 01:31:28,340
GetSueldoTotal

2237
01:31:28,340 --> 01:31:29,800
Pues es que ya está

2238
01:31:29,800 --> 01:31:31,819
La opción 2 ya la tengo

2239
01:31:31,819 --> 01:31:35,079
Y la opción 3, esta es la bonita

2240
01:31:35,079 --> 01:31:37,520
Que es la que vais a hacer el fin de semana

2241
01:31:37,520 --> 01:31:38,420
¿Vale?

2242
01:31:38,800 --> 01:31:40,360
Porque aquí ya hay que hacer un máximo

2243
01:31:40,360 --> 01:31:42,640
Pero bueno

2244
01:31:42,640 --> 01:31:45,100
Es para repasar de nuevo lo de los máximos

2245
01:31:45,100 --> 01:31:45,900
¿Vale?