1
00:00:00,000 --> 00:00:05,780
eres una señorita

2
00:00:05,780 --> 00:00:08,759
del siglo XVIII. Vale, pues entonces

3
00:00:08,759 --> 00:00:13,400
con una caja que hasta ahora era un array

4
00:00:13,400 --> 00:00:17,760
hemos accedido por posición tranquilamente y con esta nueva construida

5
00:00:17,760 --> 00:00:21,820
por encima también por posición correctamente. Un array

6
00:00:21,820 --> 00:00:25,899
y lo recorríamos. Pues hombre, ese también nos gustaría poder recorrerlo, ¿no?

7
00:00:26,480 --> 00:00:29,539
Nos gustaría poder hacer algo así para ver lo que tiene.

8
00:00:30,000 --> 00:00:32,780
mientras si sea menor que

9
00:00:32,780 --> 00:00:34,140
ala, ya la hemos liado

10
00:00:34,140 --> 00:00:37,479
como que con get

11
00:00:37,479 --> 00:00:40,820
claro, imaginaos que ahora lo que quiero

12
00:00:40,820 --> 00:00:42,880
es mostrar el resultado

13
00:00:42,880 --> 00:00:43,500
de la caja

14
00:00:43,500 --> 00:00:46,439
que será, o sea, lo que tiene la caja

15
00:00:46,439 --> 00:00:48,560
get de i, verdad

16
00:00:48,560 --> 00:00:52,539
es decir, silencio

17
00:00:52,539 --> 00:00:54,219
vale

18
00:00:54,219 --> 00:00:56,899
yo quiero recorrer, ver todo lo que hay

19
00:00:56,899 --> 00:00:58,380
en todas las posiciones de mi caja

20
00:00:58,380 --> 00:00:59,320
Igual que con un array

21
00:00:59,320 --> 00:01:01,500
Pues ningún problema, me hago un for

22
00:01:01,500 --> 00:01:03,380
Nombre es get de i

23
00:01:03,380 --> 00:01:05,299
Mientras si cero

24
00:01:05,299 --> 00:01:06,819
Y sea menor que

25
00:01:06,819 --> 00:01:08,280
¿Qué pongo ahí?

26
00:01:11,400 --> 00:01:15,260
¿Qué pongo ahí?

27
00:01:15,519 --> 00:01:16,340
¿Tenéis la interrogación?

28
00:01:17,680 --> 00:01:18,719
¿Cuál es el tamaño del array?

29
00:01:25,700 --> 00:01:27,700
¿Pero cómo vamos a poner datos.lens

30
00:01:27,700 --> 00:01:28,640
Si datos está oculto?

31
00:01:28,700 --> 00:01:31,000
Yo aquí datos ni lo conozco, ni tengo acceso

32
00:01:31,000 --> 00:01:32,040
Ni existe para mí

33
00:01:32,040 --> 00:01:38,040
Un objeto de la clase ya está creado.

34
00:01:39,680 --> 00:01:41,599
Entonces, ¿qué necesitamos?

35
00:01:44,000 --> 00:01:48,120
Necesitamos un método que me diga qué tamaño tiene la raíz.

36
00:01:49,000 --> 00:01:50,340
Necesitamos un método, no hay otra.

37
00:01:50,859 --> 00:01:53,260
Ojalá tuviéramos, qué bien nos vendría.

38
00:01:53,260 --> 00:01:58,219
Un método, por ejemplo este

39
00:01:58,219 --> 00:02:00,500
Ojalá tuviera yo un método

40
00:02:00,500 --> 00:02:04,939
Que me dijera cuál es el tamaño de esta cajita

41
00:02:04,939 --> 00:02:06,420
Nombres en cada momento

42
00:02:06,420 --> 00:02:08,979
Que me dijera el tamaño de esta cajita

43
00:02:08,979 --> 00:02:09,860
Ojalá lo tuviera

44
00:02:09,860 --> 00:02:12,400
Porque si lo tuviera, pues ya está

45
00:02:12,400 --> 00:02:13,879
Lo puedo recorrer tranquilamente

46
00:02:13,879 --> 00:02:16,620
Bueno, pero es que es facilísimo hacer ese método

47
00:02:16,620 --> 00:02:18,659
Es facilísimo hacerlo

48
00:02:18,659 --> 00:02:24,430
Porque yo hago esto y ya está

49
00:02:24,430 --> 00:02:28,360
¿Qué pongo ahí dentro?

50
00:02:29,699 --> 00:02:31,699
exacto

51
00:02:31,699 --> 00:02:36,430
ala, ya está, ya tengo ese método

52
00:02:36,430 --> 00:02:39,930
con lo cual

53
00:02:39,930 --> 00:02:41,650
ahora ya yo puedo recorrerlo

54
00:02:41,650 --> 00:02:49,009
si quiero, vale, y aquí está

55
00:02:49,009 --> 00:02:50,509
el recorrido del array

56
00:02:50,509 --> 00:02:52,830
de la cajita, array list

57
00:02:52,830 --> 00:02:56,830
y tendría también que poder borrar

58
00:02:56,830 --> 00:02:58,949
por posición, tendría

59
00:02:58,949 --> 00:03:00,889
pues por ejemplo, si yo quiero borrar un elemento

60
00:03:00,889 --> 00:03:02,669
pues ojalá tuviera

61
00:03:02,669 --> 00:03:04,110
un método

62
00:03:04,110 --> 00:03:06,389
dentro de ese objeto ArrayList

63
00:03:06,389 --> 00:03:08,550
al que si yo le paso una posición

64
00:03:08,550 --> 00:03:12,849
pues la borra, ojalá lo tuviera

65
00:03:12,849 --> 00:03:17,680
bueno, pues ese método

66
00:03:17,680 --> 00:03:19,120
lo tendría que hacer aquí

67
00:03:19,120 --> 00:03:34,340
¿vale? lo dejamos aquí en blanco

68
00:03:34,340 --> 00:03:36,240
para que lo completéis

69
00:03:36,240 --> 00:03:36,900
vosotros

70
00:03:36,900 --> 00:03:40,199
bueno y así le podría

71
00:03:40,199 --> 00:03:41,759
añadir más métodos

72
00:03:41,759 --> 00:03:43,939
si quiero pues que esta cajita

73
00:03:43,939 --> 00:03:45,439
sea más completa, haga más cosas

74
00:03:45,439 --> 00:03:47,699
el ArrayList real pues tiene más métodos

75
00:03:47,699 --> 00:03:48,699
para hacer más cositas

76
00:03:48,699 --> 00:03:50,039
como por ejemplo

77
00:03:50,039 --> 00:03:51,620
tiene un ad

78
00:03:51,620 --> 00:03:53,120
que

79
00:03:53,120 --> 00:03:56,460
tú le puedes añadir de golpe un montón

80
00:03:56,460 --> 00:03:57,099
de datos

81
00:03:57,099 --> 00:04:00,159
en lugar de uno por uno

82
00:04:00,159 --> 00:04:02,199
podríamos hacer aquí

83
00:04:02,199 --> 00:04:04,379
un montón más de métodos para que esta

84
00:04:04,379 --> 00:04:05,520
cajita sea más flexible

85
00:04:05,520 --> 00:04:07,860
y lo que importa es que ahora yo ya

86
00:04:07,860 --> 00:04:09,180
uso esta caja

87
00:04:09,180 --> 00:04:11,939
y la uso tranquilamente

88
00:04:11,939 --> 00:04:14,080
o absolutamente al margen de

89
00:04:14,080 --> 00:04:16,439
cómo funcione por dentro porque me da igual

90
00:04:16,439 --> 00:04:18,040
la creo

91
00:04:18,040 --> 00:04:20,420
Inicialmente está vacía, creada

92
00:04:20,420 --> 00:04:22,300
No tiene nada

93
00:04:22,300 --> 00:04:24,100
Dentro, ni espacio, ni nada

94
00:04:24,100 --> 00:04:26,220
Y luego yo voy añadiendo

95
00:04:26,220 --> 00:04:27,939
Recupero

96
00:04:27,939 --> 00:04:30,199
Voy borrando, hago lo que quiera

97
00:04:30,199 --> 00:04:31,740
Con esa caja

98
00:04:31,740 --> 00:04:35,959
¿Vale? Pues esto es una colección

99
00:04:35,959 --> 00:04:37,019
Ya está

100
00:04:37,019 --> 00:04:38,399
No es más que esto

101
00:04:38,399 --> 00:04:41,819
¿Vale? Lo que pasa es que hay diferentes tipos

102
00:04:41,819 --> 00:04:43,839
Vale

103
00:04:43,839 --> 00:04:45,379
Pues antes de meternos más

104
00:04:45,379 --> 00:04:47,360
Ya en los tipos de colecciones

105
00:04:47,360 --> 00:04:48,720
Que ya están hechas en Java

106
00:04:48,720 --> 00:04:50,759
pues porque usamos una, porque usamos otra, etc

107
00:04:50,759 --> 00:04:51,399
etc, etc

108
00:04:51,399 --> 00:04:54,540
vamos a dar por lo menos un pequeño salto

109
00:04:54,540 --> 00:04:56,740
y es en este mi ArrayList

110
00:04:56,740 --> 00:04:58,519
chulo con stream, si es muy chulo

111
00:04:58,519 --> 00:04:59,779
pero

112
00:04:59,779 --> 00:05:02,120
solo puedo guardar stream

113
00:05:02,120 --> 00:05:04,680
como me gustaría a mi tener una

114
00:05:04,680 --> 00:05:06,639
caja donde en el momento de crearla

115
00:05:06,639 --> 00:05:08,660
yo le pudiera decir, créate

116
00:05:08,660 --> 00:05:09,920
pero para stream

117
00:05:09,920 --> 00:05:12,639
ahora créate pero para

118
00:05:12,639 --> 00:05:14,300
int, ahora créate

119
00:05:14,300 --> 00:05:16,480
pero para dabble, ojalá

120
00:05:16,480 --> 00:05:18,480
tuviera una caja que en el momento de crearla

121
00:05:18,480 --> 00:05:20,480
pudiera decidir

122
00:05:20,480 --> 00:05:22,300
de qué tipo de datos

123
00:05:22,300 --> 00:05:24,519
quiero que tenga, porque si no

124
00:05:24,519 --> 00:05:26,399
tengo esa posibilidad, tendría que hacerme

125
00:05:26,399 --> 00:05:28,560
mi array list chulo con string

126
00:05:28,560 --> 00:05:30,519
mi array list chulo con int

127
00:05:30,519 --> 00:05:32,399
mi array list chulo con dabble

128
00:05:32,399 --> 00:05:34,199
tendría que tener ahí un mi array list chulo

129
00:05:34,199 --> 00:05:35,800
para todos los tipos de datos

130
00:05:35,800 --> 00:05:38,699
y si tengo alumnos, mi array list chulo

131
00:05:38,699 --> 00:05:40,939
con alumno, o sea, me hago un mi array list chulo

132
00:05:40,939 --> 00:05:42,680
para cualquier tipo de dato que yo

133
00:05:42,680 --> 00:05:43,560
quiera poner aquí

134
00:05:43,560 --> 00:05:46,699
pues hombre, no es muy operativo tener 200.000

135
00:05:46,699 --> 00:05:49,079
clases distintas, cada una de ellas

136
00:05:49,079 --> 00:05:50,639
para un tipo de

137
00:05:50,639 --> 00:05:52,740
dato distinto aquí, porque mi aplicación

138
00:05:52,740 --> 00:05:54,660
puede tener 200.000 tipos de datos

139
00:05:54,660 --> 00:05:56,860
distintos, alumno, factura, cliente

140
00:05:56,860 --> 00:05:58,139
no tiene sentido

141
00:05:58,139 --> 00:06:02,600
bueno, pues menos mal que en Java tenemos la

142
00:06:02,600 --> 00:06:04,560
posibilidad de hacer una cosa

143
00:06:04,560 --> 00:06:06,699
que se llaman tipos genéricos

144
00:06:07,680 --> 00:06:10,740
¿vale? menos mal

145
00:06:10,740 --> 00:06:15,170
que tenemos esa

146
00:06:15,170 --> 00:06:15,750
posibilidad

147
00:06:15,750 --> 00:06:18,050
de en Java

148
00:06:18,050 --> 00:06:20,269
usar

149
00:06:20,269 --> 00:06:22,250
algo que se llaman

150
00:06:22,250 --> 00:06:27,629
tipos genéricos

151
00:06:27,629 --> 00:06:29,930
que viene a ser lo siguiente

152
00:06:29,930 --> 00:06:32,389
te estás durmiendo

153
00:06:32,389 --> 00:06:34,629
pero no puede ser, eso es muy divertido

154
00:06:34,629 --> 00:06:39,529
yo no te estaba durmiendo

155
00:06:39,529 --> 00:06:41,870
vale, entonces

156
00:06:41,870 --> 00:06:44,209
tipos genéricos, menos mal que en Java

157
00:06:44,209 --> 00:06:46,629
tenemos la opción de usar tipos genéricos

158
00:06:46,629 --> 00:06:48,370
¿qué es un tipo genérico?

159
00:06:48,370 --> 00:07:08,910
Un tipo genérico es un tipo genérico, ¿verdad? Es decir, cuando nosotros hemos declarado una variable, siempre, siempre, siempre que hemos declarado una variable, la variable X, la variable Y, le hemos puesto un tipo delante, obligatoriamente le hemos puesto un tipo delante.

160
00:07:08,910 --> 00:07:10,069
porque es obligatorio

161
00:07:10,069 --> 00:07:12,850
porque Java es un lenguaje que se llama

162
00:07:12,850 --> 00:07:14,829
tipado, con lo cual cualquier

163
00:07:14,829 --> 00:07:17,089
variable, en el momento

164
00:07:17,089 --> 00:07:18,949
de crearla, hay que

165
00:07:18,949 --> 00:07:20,370
decir a qué tipo pertenece

166
00:07:20,370 --> 00:07:23,189
¿vale? bueno, esto tiene un

167
00:07:23,189 --> 00:07:24,629
minimísimo matiz

168
00:07:24,629 --> 00:07:26,970
cuando estudiáis cosas por ahí

169
00:07:26,970 --> 00:07:28,250
pero bueno, que es lo de menos

170
00:07:28,250 --> 00:07:30,389
que uno podría poner aquí var

171
00:07:30,389 --> 00:07:33,029
y cuando pone aquí var

172
00:07:33,029 --> 00:07:35,050
dice, todavía, todavía no me

173
00:07:35,050 --> 00:07:36,970
comprometo, pero la primera vez que

174
00:07:36,970 --> 00:07:39,029
le das valor, la primera vez que se lo

175
00:07:39,029 --> 00:07:40,930
das, ya automáticamente se queda

176
00:07:40,930 --> 00:07:43,050
de ese tipo y así queda de ese tipo para siempre.

177
00:07:43,470 --> 00:07:44,310
Para siempre jamás.

178
00:07:44,930 --> 00:07:46,829
Pero bueno, este matiz del var no nos

179
00:07:46,829 --> 00:07:48,029
importa porque es una chorra.

180
00:07:50,189 --> 00:07:50,769
Pero bueno,

181
00:07:50,850 --> 00:07:52,250
como lo veréis por ahí por un rato,

182
00:07:53,209 --> 00:07:54,829
lo que nos importa es que las variables

183
00:07:54,829 --> 00:07:57,029
en Java son de un tipo concreto.

184
00:07:57,750 --> 00:07:58,990
Desde la primera vez que las

185
00:07:58,990 --> 00:08:00,889
usas y le das su valor, son

186
00:08:00,889 --> 00:08:02,810
de un tipo concreto. Ese tipo ya no cambia nunca.

187
00:08:04,189 --> 00:08:04,949
Eso hace que

188
00:08:04,949 --> 00:08:06,230
la escritura de código en Java

189
00:08:06,230 --> 00:08:07,870
sea un poco pesada

190
00:08:07,870 --> 00:08:10,430
porque tienes que satisfacer muchas reglas.

191
00:08:10,509 --> 00:08:11,230
Es el problema de Java,

192
00:08:11,310 --> 00:08:12,870
que tienes que cumplir un montón de reglas.

193
00:08:13,550 --> 00:08:15,629
Pero gracias a que cumples un montón de reglas

194
00:08:15,629 --> 00:08:17,029
y eso hace muy complicado,

195
00:08:17,430 --> 00:08:18,730
entre comillas, programar en Java,

196
00:08:19,389 --> 00:08:22,709
los programas son infinitamente más robustos.

197
00:08:23,430 --> 00:08:23,589
¿Vale?

198
00:08:24,490 --> 00:08:25,470
Bueno, pues entonces,

199
00:08:26,170 --> 00:08:27,610
cuando hemos declarado una variable

200
00:08:27,610 --> 00:08:28,550
hemos dicho siempre

201
00:08:28,550 --> 00:08:30,209
¿de qué tipo es?

202
00:08:30,810 --> 00:08:33,409
Pues eso es justo lo último que yo quiero aquí.

203
00:08:34,250 --> 00:08:35,789
Es lo último que yo quiero aquí.

204
00:08:36,230 --> 00:08:56,370
Cuando yo declaro en mi array chulo, declaro el array de datos que va a contener los datos, esto no quiero comprometerme todavía, no quiero comprometerme, quiero dejar como tipo abierto, tipo abierto y cuando ya se cree el objeto ya diré qué tipo es.

205
00:08:56,370 --> 00:08:58,809
Pero ahora mismo que estoy todavía declarando

206
00:08:58,809 --> 00:09:00,889
El funcionamiento, no estoy creando nada

207
00:09:00,889 --> 00:09:02,070
No estoy instanciando nada

208
00:09:02,070 --> 00:09:04,750
Ahora mismo lo quiero dejar como tipo abierto

209
00:09:04,750 --> 00:09:07,149
Bueno, pues podemos hacerlo

210
00:09:07,149 --> 00:09:09,549
Podemos dejarlo como tipo abierto

211
00:09:09,549 --> 00:09:10,309
Que sería

212
00:09:10,309 --> 00:09:13,409
Lo que yo estoy llamando como tipo genérico

213
00:09:13,409 --> 00:09:15,909
¿Y cómo lo dejamos como tipo abierto?

214
00:09:16,730 --> 00:09:17,509
Poniendo aquí

215
00:09:17,509 --> 00:09:19,330
Una letra mayúscula sin más

216
00:09:19,330 --> 00:09:21,330
Normalmente

217
00:09:21,330 --> 00:09:23,669
Se suele poner una T, pero podría poner una V

218
00:09:23,669 --> 00:09:25,110
Podría poner una E

219
00:09:25,110 --> 00:09:27,549
una letra mayúscula sin más

220
00:09:27,549 --> 00:09:29,830
normalmente

221
00:09:29,830 --> 00:09:31,809
se usa la T por tipo

222
00:09:31,809 --> 00:09:37,720
vale, pues entonces

223
00:09:37,720 --> 00:09:38,840
yo pongo ahí T

224
00:09:38,840 --> 00:09:41,940
y ahora digo, yo cuando

225
00:09:41,940 --> 00:09:44,039
esta clase se cree, se instancie

226
00:09:44,039 --> 00:09:48,100
ya me dirán este T cual es

227
00:09:48,100 --> 00:09:49,840
ya me lo dirán, pero ahora mismo

228
00:09:49,840 --> 00:09:50,620
lo dejo abierto

229
00:09:50,620 --> 00:09:53,539
y yo trabajo aquí

230
00:09:53,539 --> 00:09:55,740
cada vez que me quiera referir a ese tipo

231
00:09:55,740 --> 00:09:58,080
cada vez que me quiera referir, lo dejo abierto

232
00:09:58,080 --> 00:09:59,980
entonces aquí igual

233
00:09:59,980 --> 00:10:02,059
aquí no pondré string, sino que pondré

234
00:10:02,059 --> 00:10:03,919
t, aquí no pondré

235
00:10:03,919 --> 00:10:05,460
string, sino que pondré t

236
00:10:05,460 --> 00:10:08,080
¿vale? aquí tampoco

237
00:10:08,080 --> 00:10:09,399
es decir, lo dejo

238
00:10:09,399 --> 00:10:11,860
abierto, ese tipo

239
00:10:11,860 --> 00:10:13,820
de datos, ¿vale? lo dejo

240
00:10:13,820 --> 00:10:14,120
abierto

241
00:10:14,120 --> 00:10:17,960
y luego ya, cuando el objeto

242
00:10:17,960 --> 00:10:19,919
se instancie, cuando

243
00:10:19,919 --> 00:10:21,919
el objeto se cree, ya

244
00:10:21,919 --> 00:10:23,860
diré, oye, te voy a crear a ti, me hará

245
00:10:23,860 --> 00:10:26,059
chulo, pero te voy a crear

246
00:10:26,059 --> 00:10:28,039
con el tipo stream.

247
00:10:28,299 --> 00:10:30,080
Entonces, cuando se construye

248
00:10:30,080 --> 00:10:31,500
ese objeto, se construye

249
00:10:31,500 --> 00:10:34,019
sustituyéndose todas

250
00:10:34,019 --> 00:10:36,039
las referencias a T por ese

251
00:10:36,039 --> 00:10:38,019
tipo en particular. Ahora te

252
00:10:38,019 --> 00:10:39,639
voy a crear con el tipo alumnos.

253
00:10:40,639 --> 00:10:41,940
Pues se crea ese objeto,

254
00:10:42,200 --> 00:10:43,919
pero ahora sustituyendo todas

255
00:10:43,919 --> 00:10:46,059
las referencias a T con el tipo

256
00:10:46,059 --> 00:10:46,460
alumno.

257
00:10:48,179 --> 00:10:50,179
Con lo cual, esta única clase

258
00:10:50,179 --> 00:10:52,440
de aquí, esta única clase

259
00:10:52,440 --> 00:10:53,559
me vale

260
00:10:53,559 --> 00:10:55,559
Para cualquier tipo de dato

261
00:10:55,559 --> 00:10:56,580
Para cualquiera

262
00:10:56,580 --> 00:11:01,429
¿Vale? Pues vamos a hacerla

263
00:11:01,429 --> 00:11:10,139
No, no voy a empezar a cambiar todo

264
00:11:10,139 --> 00:11:11,639
Lo voy a hacer una clase aparte

265
00:11:11,639 --> 00:11:13,299
A ver

266
00:11:13,299 --> 00:11:16,990
Entonces

267
00:11:16,990 --> 00:11:24,070
Vamos a copiar esta clase

268
00:11:24,070 --> 00:11:26,009
¿Vale?

269
00:11:29,929 --> 00:11:32,370
Lo llamamos mearraychulo sin más

270
00:11:32,370 --> 00:11:39,250
Vale, pues mearraychulo sin más

271
00:11:39,250 --> 00:11:40,730
Este es el que va a valer para todo

272
00:11:40,730 --> 00:11:42,509
Luego este string

273
00:11:42,509 --> 00:11:44,289
Fuera

274
00:11:44,289 --> 00:11:48,399
Este fuera también

275
00:11:48,399 --> 00:11:57,629
Este fuera

276
00:11:57,629 --> 00:12:04,610
Este, esto ahora lo tendremos que cambiar

277
00:12:04,610 --> 00:12:05,610
Porque

278
00:12:05,610 --> 00:12:08,669
Este fuera

279
00:12:08,669 --> 00:12:10,129
Todas las referencias a string

280
00:12:10,129 --> 00:12:12,929
Se quedan genéricas

281
00:12:12,929 --> 00:12:14,710
Este se queda aquí fuera

282
00:12:14,710 --> 00:12:19,000
Hombre, t, tipo

283
00:12:19,000 --> 00:12:20,659
Hombre, si quieres lo llamamos

284
00:12:20,659 --> 00:12:21,559
X o V

285
00:12:21,559 --> 00:12:24,360
Sí, una letra mayúscula

286
00:12:29,029 --> 00:12:30,149
Vale, ¿dónde tenemos más

287
00:12:30,149 --> 00:12:32,330
referencias a string en ningún sitio más.

288
00:12:33,950 --> 00:12:35,490
Aquí, vale.

289
00:12:36,509 --> 00:12:37,750
Ah, aquí, aquí, aquí.

290
00:12:41,370 --> 00:12:41,629
Vale.

291
00:12:43,370 --> 00:12:43,929
Entonces,

292
00:12:44,649 --> 00:12:47,009
puede que se nos haya dejado en algún sitio,

293
00:12:47,129 --> 00:12:49,210
ahora lo, si se nos ha escapado, lo cambiamos.

294
00:12:50,149 --> 00:12:51,070
Muchas cosas rojas,

295
00:12:51,169 --> 00:12:52,570
¿verdad? Mucha angustia.

296
00:12:53,990 --> 00:12:55,330
Vale, pues entonces,

297
00:12:56,049 --> 00:12:57,149
desde el momento

298
00:12:57,149 --> 00:12:58,610
en que en una clase

299
00:12:58,610 --> 00:13:02,159
hago referencia a un tipo

300
00:13:02,159 --> 00:13:03,639
genérico, como aquí,

301
00:13:04,240 --> 00:13:27,649
que he hecho referencia en varios sitios, pero desde el momento en que hago referencia a un tipo genérico, desde el momento en que una clase se convierte dependiente de un tipo genérico, esa clase se convierte en genérica, ¿verdad? Esta clase ahora mismo se ha convertido en clase genérica, ¿vale?

302
00:13:27,649 --> 00:13:30,049
Pues cuando una clase se ha convertido

303
00:13:30,049 --> 00:13:30,950
En clase genérica

304
00:13:30,950 --> 00:13:33,750
Porque depende de un tipo

305
00:13:33,750 --> 00:13:34,830
Que yo he dejado abierto

306
00:13:34,830 --> 00:13:36,190
Por concretar

307
00:13:36,190 --> 00:13:38,370
Tengo que especificarlo

308
00:13:38,370 --> 00:13:40,330
Porque si no me están saliendo todas esas cosas rojas

309
00:13:40,330 --> 00:13:42,110
Tan angustiosas

310
00:13:42,110 --> 00:13:45,490
¿Y cómo especifico que esta clase es genérica?

311
00:13:46,289 --> 00:13:47,169
Poniendo aquí

312
00:13:47,169 --> 00:13:48,470
Los corchetillos

313
00:13:48,470 --> 00:13:49,889
Y la letra famosa

314
00:13:49,889 --> 00:13:52,669
¿Vale?

315
00:13:54,309 --> 00:13:56,190
Entonces se me ha quitado casi todo el rojo

316
00:13:56,190 --> 00:13:58,029
Casi todo

317
00:13:58,029 --> 00:13:59,090
Pero no todo

318
00:13:59,090 --> 00:14:06,440
que llavecitas

319
00:14:06,440 --> 00:14:09,320
pues esto es como si fuera una función

320
00:14:09,320 --> 00:14:10,600
es el parámetro de la función

321
00:14:10,600 --> 00:14:13,659
esto es como si fuera

322
00:14:13,659 --> 00:14:17,120
es decir, cuando tú tienes

323
00:14:17,120 --> 00:14:18,820
una función que depende de

324
00:14:18,820 --> 00:14:21,100
esto es f de x de toda la vida

325
00:14:21,100 --> 00:14:22,460
mi función depende de x

326
00:14:22,460 --> 00:14:24,039
porque es x cuadrado más 1

327
00:14:24,039 --> 00:14:26,460
pues esta clase

328
00:14:26,460 --> 00:14:28,240
depende de t

329
00:14:28,240 --> 00:14:29,820
porque lo tiene dentro

330
00:14:29,820 --> 00:14:33,299
es la forma de expresar de que esta clase es función de t

331
00:14:33,299 --> 00:14:35,919
¿vale? como si fuera esta idea

332
00:14:35,919 --> 00:14:37,740
es la misma idea, esta clase

333
00:14:37,740 --> 00:14:39,820
se convierte dependiente de T mayúscula

334
00:14:39,820 --> 00:14:40,779
porque depende de él

335
00:14:40,779 --> 00:14:44,179
es la manera de expresar

336
00:14:44,179 --> 00:14:46,360
que esta clase tiene una incógnita

337
00:14:46,360 --> 00:14:48,120
dentro todavía, que está por definir

338
00:14:48,120 --> 00:14:49,899
y en su declaración

339
00:14:49,899 --> 00:14:51,379
está tirando de la incógnita

340
00:14:51,379 --> 00:14:54,240
pero luego cuando se cree el objeto

341
00:14:54,240 --> 00:14:56,000
ya en el momento de

342
00:14:56,000 --> 00:14:58,360
crear lo que es cuando aparecen las cosas reales

343
00:14:58,360 --> 00:15:00,039
ahí las incógnitas no funcionan

344
00:15:00,039 --> 00:15:01,740
hay que decir qué tipo de datos, es como aquí

345
00:15:01,740 --> 00:15:03,740
esta es la expresión de una función

346
00:15:03,740 --> 00:15:06,519
pero luego ya, para evaluarla

347
00:15:06,519 --> 00:15:07,919
tienes que dar un valor a la x

348
00:15:07,919 --> 00:15:09,440
o el 3, o el 2, o el 7

349
00:15:09,440 --> 00:15:11,580
vale, pues esto es la misma idea

350
00:15:11,580 --> 00:15:16,500
es decir, esta función

351
00:15:16,500 --> 00:15:18,580
esta clase es una clase

352
00:15:18,580 --> 00:15:19,659
que depende de t

353
00:15:19,659 --> 00:15:22,480
cuando se creya un objeto

354
00:15:22,480 --> 00:15:24,080
habrá que comprometerse

355
00:15:24,080 --> 00:15:26,500
vale, aquí

356
00:15:26,500 --> 00:15:28,179
sí me da error

357
00:15:28,179 --> 00:15:29,960
porque como t es un tipo genérico

358
00:15:29,960 --> 00:15:31,919
el compilador no me deja hacer ni ut

359
00:15:31,919 --> 00:15:34,440
ni ut, porque sería instancia

360
00:15:34,440 --> 00:15:36,539
algo que no sabe lo que está

361
00:15:36,539 --> 00:15:38,460
instanciando. Entonces el compilador

362
00:15:38,460 --> 00:15:40,480
me dice, no me pongas ahí

363
00:15:40,480 --> 00:15:42,580
un new incógnita

364
00:15:42,580 --> 00:15:44,500
porque no

365
00:15:44,500 --> 00:15:46,639
sé qué instanciar, no sé, vale.

366
00:15:47,700 --> 00:15:48,100
Entonces,

367
00:15:48,399 --> 00:15:50,500
¿cómo se soluciona esto a nivel

368
00:15:50,500 --> 00:15:52,340
de compilación? Vale, T

369
00:15:52,340 --> 00:15:54,419
no sabemos qué va a ser. T

370
00:15:54,419 --> 00:15:56,620
puede ser alumno, factura, un número,

371
00:15:56,720 --> 00:15:58,440
no sabemos qué va a ser. Solo hay

372
00:15:58,440 --> 00:16:00,419
una cosa que sabemos sí o sí o sí

373
00:16:00,419 --> 00:16:02,379
o sí o sí, ¿qué va a ser? ¿Qué es?

374
00:16:03,279 --> 00:16:04,120
Heredera de object.

375
00:16:04,440 --> 00:16:04,820
¿Sí o no?

376
00:16:05,539 --> 00:16:05,940
Sí, ¿no?

377
00:16:06,139 --> 00:16:09,820
Porque cualquier tipo de dato, cualquiera hereda de object.

378
00:16:10,580 --> 00:16:14,100
Bien, herencia directa porque sea su padre o bien porque sea su bisabuelo.

379
00:16:14,580 --> 00:16:15,080
Me da igual.

380
00:16:16,340 --> 00:16:24,009
Con lo cual, lo que sí que nos va a dejar hacer el compilador es instanciarlo así.

381
00:16:24,009 --> 00:16:28,940
Y luego ponerle el casting.

382
00:16:29,480 --> 00:16:31,820
Esto sí me deja hacerlo y aquí tan tranquila.

383
00:16:33,220 --> 00:16:33,919
Y aquí lo mismo.

384
00:16:34,659 --> 00:16:36,659
Esto a ver si me lo ofrece directamente.

385
00:16:37,320 --> 00:16:39,379
Y me ahorro tiempo

386
00:16:39,379 --> 00:16:41,139
No, no me lo ofrece directamente

387
00:16:41,139 --> 00:16:41,919
Pues aquí igual

388
00:16:41,919 --> 00:16:45,710
New object

389
00:16:45,710 --> 00:16:50,460
Y ahora le hago el casting

390
00:16:50,460 --> 00:16:53,000
Al apañado

391
00:16:53,000 --> 00:16:54,059
Eso sí me lo deja hacer

392
00:16:54,059 --> 00:16:56,690
¿Vale?

393
00:17:00,179 --> 00:17:02,139
Y ya no tengo más errores de compilación

394
00:17:02,139 --> 00:17:06,930
¿Vale? Cuando hay un casting

395
00:17:06,930 --> 00:17:08,990
El compilador siempre te suele dar

396
00:17:08,990 --> 00:17:11,490
Te da un aviso porque los castings son peligrosos

397
00:17:11,490 --> 00:17:13,309
Te está diciendo

398
00:17:13,309 --> 00:17:14,990
Cuidado, ¿qué estás haciendo?

399
00:17:15,970 --> 00:17:16,950
Estás haciendo

400
00:17:16,950 --> 00:17:19,390
un casting no verificado

401
00:17:19,390 --> 00:17:21,650
es decir, claro que no está

402
00:17:21,650 --> 00:17:23,329
verificado porque yo he hecho el new

403
00:17:23,329 --> 00:17:25,529
para que estar

404
00:17:25,529 --> 00:17:27,369
verificado tendría que haber guardado esto

405
00:17:27,369 --> 00:17:28,789
un objeto y luego hacer

406
00:17:28,789 --> 00:17:31,450
si ese objeto instance of

407
00:17:31,450 --> 00:17:33,410
de no sé qué, entonces

408
00:17:33,410 --> 00:17:35,710
hace el casting, eso sí sería

409
00:17:35,710 --> 00:17:37,529
verificado, vale, pero

410
00:17:37,529 --> 00:17:39,410
me da igual aquí, si es que

411
00:17:39,410 --> 00:17:41,309
sé que yo luego

412
00:17:41,309 --> 00:17:46,259
voy a pasarle el tipo

413
00:17:46,259 --> 00:17:47,480
este de aquí

414
00:17:47,480 --> 00:17:50,119
con lo cual ese casting no va a funcionar, no hay otra.

415
00:17:51,779 --> 00:17:52,059
¿Vale?

416
00:17:52,539 --> 00:17:53,619
Solo que le preguntaba antes,

417
00:17:53,740 --> 00:17:56,380
¿cómo sabíamos

418
00:17:56,380 --> 00:17:57,740
qué parámetros de cuánto?

419
00:17:57,880 --> 00:18:00,200
Claro, es que todavía no estamos creando

420
00:18:00,200 --> 00:18:02,259
nada. Ahora mismo esta es la

421
00:18:02,259 --> 00:18:04,460
clase que dependerá del tipo genérico.

422
00:18:04,460 --> 00:18:06,240
Vale, pues ahora

423
00:18:06,240 --> 00:18:11,059
vámonos a mi main otra vez.

424
00:18:14,759 --> 00:18:14,960
¿Vale?

425
00:18:16,839 --> 00:18:17,819
Vámonos a mi main,

426
00:18:20,539 --> 00:18:21,380
que era este.

427
00:18:21,380 --> 00:18:31,910
vale, nos vamos a mi main

428
00:18:31,910 --> 00:18:34,269
y ahora me voy a crear

429
00:18:34,269 --> 00:18:35,029
una caja

430
00:18:35,029 --> 00:18:37,549
pero para cadenas

431
00:18:37,549 --> 00:18:40,170
porque ahí no tenemos ninguna otra clase

432
00:18:40,170 --> 00:18:41,670
vamos a hacer luego otra clase para hacerlo

433
00:18:41,670 --> 00:18:43,730
venga, pues me voy a hacer

434
00:18:43,730 --> 00:18:45,930
caja cadenas

435
00:18:45,930 --> 00:18:47,869
pues me hago yo

436
00:18:47,869 --> 00:18:50,269
mi new, mi array list chulo

437
00:18:50,269 --> 00:18:51,230
a palo seco

438
00:18:51,230 --> 00:18:58,500
y ahora es cuando tengo que decir

439
00:18:58,500 --> 00:18:59,799
el tipo de dato que quiero

440
00:18:59,799 --> 00:19:02,059
yo no puedo instanciar esto

441
00:19:02,059 --> 00:19:09,710
y no comprometerme con este tipo, ¿vale?

442
00:19:11,710 --> 00:19:14,410
Yo aquí he dicho que depende de un tipo de dato.

443
00:19:16,069 --> 00:19:17,750
Pues ahora, ¿cómo se lo damos?

444
00:19:18,509 --> 00:19:21,910
Ponemos los corchetitos y ponemos el tipo que queremos.

445
00:19:27,759 --> 00:19:30,799
Perdón, aquí que el tipo de dato, ahí.

446
00:19:35,750 --> 00:19:38,849
Es decir, así, ¿vale?

447
00:19:38,849 --> 00:19:46,599
Vale, pues con esto

448
00:19:46,599 --> 00:19:49,039
Estoy diciendo, oye tú

449
00:19:49,039 --> 00:19:51,519
Créate, pero créate

450
00:19:51,519 --> 00:19:53,559
De tal manera que tu T mayúscula

451
00:19:53,559 --> 00:19:54,299
Sea string

452
00:19:54,299 --> 00:19:56,859
Y a partir de ahí

453
00:19:56,859 --> 00:19:57,900
A todos los efectos

454
00:19:57,900 --> 00:19:59,880
La T mayúscula se convierte en string

455
00:19:59,880 --> 00:20:02,440
Luego este caja cadenas

456
00:20:02,440 --> 00:20:04,500
Solo vale para guardar string

457
00:20:04,500 --> 00:20:05,180
Solo

458
00:20:05,180 --> 00:20:07,680
Vale, y si queremos otro

459
00:20:07,680 --> 00:20:09,299
Pues tenemos que hacerlo con int

460
00:20:09,299 --> 00:20:10,119
Claro

461
00:20:10,119 --> 00:20:16,119
Por ejemplo, imaginaos

462
00:20:16,119 --> 00:20:21,009
¿Vale?

463
00:20:21,470 --> 00:20:22,029
¿Puedo cambiar?

464
00:20:22,809 --> 00:20:24,910
Imaginaos que yo quiero trabajar con alumnos

465
00:20:24,910 --> 00:20:27,470
Me voy a crear aquí rápidamente una clase alumno

466
00:20:27,470 --> 00:20:28,230
Cualquiera

467
00:20:28,230 --> 00:20:32,920
Una clase alumno

468
00:20:32,920 --> 00:20:35,700
Con

469
00:20:35,700 --> 00:20:40,220
Nombre

470
00:20:40,220 --> 00:20:49,609
Con nombre nota

471
00:20:52,890 --> 00:21:19,130
Voy a hacerle rápidamente un constructor con parámetros, sí, y unos get y set, y un toString, getter y setter, y toString.

472
00:21:26,400 --> 00:21:33,359
Vale, pues imaginaos que ahora nuestra aplicación lo que va a trabajar es en lugar de con muchos stream, pues con muchos alumnos.

473
00:21:33,940 --> 00:21:35,960
Ahora quiero trabajar con un montón de alumnos.

474
00:21:36,880 --> 00:21:51,640
Pues no pasa nada, me hago mi ArrayList chulo, pero me lo hago para alumnos, pues ya está, comodísimo, ¿vale?

475
00:21:52,259 --> 00:22:00,220
Me vuelvo a mi main, ahora quiero trabajar con alumnos, pues no pasa nada, me hago una caja nueva para mis alumnos

476
00:22:00,220 --> 00:22:27,980
y le digo, oye, que ahora quiero que seas de alumnos, ¿vale?

477
00:22:27,980 --> 00:22:30,019
como

478
00:22:30,019 --> 00:22:32,660
matiz

479
00:22:32,660 --> 00:22:33,059
cosa

480
00:22:33,059 --> 00:22:36,259
como ya hemos puesto aquí el tipo de dato

481
00:22:36,259 --> 00:22:38,180
aquí no hace falta ponerlo ¿vale?

482
00:22:38,579 --> 00:22:40,480
se puede poner, aquí lo he puesto

483
00:22:40,480 --> 00:22:42,400
aquí podría

484
00:22:42,400 --> 00:22:43,720
volver a poner alumno

485
00:22:43,720 --> 00:22:46,740
podría volver a ponerlo, pero es redundante

486
00:22:46,740 --> 00:22:47,960
¿vale? como ya está puesto aquí

487
00:22:47,960 --> 00:22:50,279
entonces podéis ponerlo o no ponerlo

488
00:22:50,279 --> 00:22:52,299
en función de como parezca que queda

489
00:22:52,299 --> 00:22:53,220
más claro el código

490
00:22:53,220 --> 00:22:56,259
¿vale? lo importante es que

491
00:22:56,259 --> 00:22:57,799
esté puesto en la declaración

492
00:22:57,799 --> 00:23:00,039
En la declaración de la variable

493
00:23:00,039 --> 00:23:02,180
En la declaración tiene que estar puesto

494
00:23:02,180 --> 00:23:03,940
Para decir, oye, que esta caja es de alumnos

495
00:23:03,940 --> 00:23:06,380
Y ahora yo ya esa caja la puedo usar

496
00:23:06,380 --> 00:23:08,740
Para meter alumnos tan tranquilamente

497
00:23:08,740 --> 00:23:11,000
En mi caja alumnos

498
00:23:11,000 --> 00:23:12,079
Quiero meter

499
00:23:12,079 --> 00:23:14,859
¿Qué quiero meter?

500
00:23:15,480 --> 00:23:16,779
Pues un nuevo alumno

501
00:23:16,779 --> 00:23:18,299
Que me voy a crear ahora mismo

502
00:23:18,299 --> 00:23:19,500
Mi alumno

503
00:23:19,500 --> 00:23:22,460
Carlos, que tiene un 10

504
00:23:22,460 --> 00:23:23,759
¡Hala! Pues ya está

505
00:23:23,759 --> 00:23:26,519
Mi caja alumnos le he metido un alumno

506
00:23:26,519 --> 00:23:27,460
Que acabo de crear

507
00:23:27,460 --> 00:23:31,890
Vamos a meterle otro

508
00:23:31,890 --> 00:23:34,529
Venga, no pasa nada, le metemos otro

509
00:23:34,529 --> 00:23:42,660
Porque aquí, vale

510
00:23:42,660 --> 00:23:45,039
Entonces he construido

511
00:23:45,039 --> 00:23:47,079
Una clase comodísima para guardar

512
00:23:47,079 --> 00:23:48,920
Cosas y además del tipo

513
00:23:48,920 --> 00:23:49,960
Que a mí me dé la gana

514
00:23:49,960 --> 00:23:51,740
Del que a mí me dé la gana

515
00:23:51,740 --> 00:23:54,700
Que quiero recorrer ahora la caja

516
00:23:54,700 --> 00:23:56,759
Alumnos para ver lo que he metido

517
00:23:56,759 --> 00:23:58,940
Dentro, bueno pues la recorro

518
00:23:58,940 --> 00:24:02,920
Caja alumnos

519
00:24:02,920 --> 00:24:05,039
Punto size

520
00:24:05,039 --> 00:24:06,859
incrementando i

521
00:24:06,859 --> 00:24:10,359
pues vamos a mostrar

522
00:24:10,359 --> 00:24:12,059
caja alumnos

523
00:24:12,059 --> 00:24:14,779
punto get

524
00:24:14,779 --> 00:24:16,279
de i

525
00:24:16,279 --> 00:24:19,789
ala

526
00:24:19,789 --> 00:24:21,609
tan ricamente

527
00:24:21,609 --> 00:24:24,869
con esto estoy recorriendo la caja alumnos

528
00:24:24,869 --> 00:24:26,069
que me acabo de crear

529
00:24:26,069 --> 00:24:30,240
recorro y voy mostrando

530
00:24:30,240 --> 00:24:31,980
el alumno que está en la posición

531
00:24:31,980 --> 00:24:35,420
luego es una clase

532
00:24:35,420 --> 00:24:37,420
que si yo ya la tengo hecha

533
00:24:37,420 --> 00:24:40,099
pues puedo usarla para

534
00:24:40,099 --> 00:24:41,799
guardar cualquier tipo de datos

535
00:24:41,799 --> 00:24:46,170
y manipularlo

536
00:24:46,170 --> 00:24:48,430
insertarlo, borrarlo

537
00:24:48,430 --> 00:24:50,650
si tuviera el delete hecho, que no tengo hecho el delete

538
00:24:50,650 --> 00:24:52,809
con lo cual no tengo hecho el delete, si le doy delete

539
00:24:52,809 --> 00:24:53,589
no va a hacer nada

540
00:24:53,589 --> 00:24:55,849
pero se podría hacer, etc

541
00:24:55,849 --> 00:25:04,160
¿vale? ¿está entendido?

542
00:25:07,529 --> 00:25:09,650
vamos a ejecutarlo, a ver si hemos hecho algo mal

543
00:25:09,650 --> 00:25:17,500
vale, pues aquí están mis dos alumnos

544
00:25:17,500 --> 00:25:19,720
en la caja que acabo de meter

545
00:25:19,720 --> 00:25:25,910
si yo en mi caja

546
00:25:25,910 --> 00:25:27,970
alumnos, intentara

547
00:25:27,970 --> 00:25:29,390
meter algo que no es un alumno,

548
00:25:30,509 --> 00:25:31,809
pues no me dejaría. Si yo

549
00:25:31,809 --> 00:25:33,609
intentara meter una cadena, por ejemplo,

550
00:25:36,660 --> 00:25:38,000
pues lógicamente el

551
00:25:38,000 --> 00:25:39,099
compilador no me deja.

552
00:25:40,759 --> 00:25:42,140
Porque dice, oye, perdona,

553
00:25:42,660 --> 00:25:43,539
caja alumnos

554
00:25:43,539 --> 00:25:45,619
está instanciada

555
00:25:45,619 --> 00:25:48,339
con el tipo alumno. Lo siento.

556
00:25:49,039 --> 00:25:50,079
No puedes meter algo

557
00:25:50,079 --> 00:25:52,119
que no sea un alumno. No puedes.

558
00:25:53,180 --> 00:25:53,420
¿Vale?

559
00:25:55,430 --> 00:25:56,990
Como si en caja cadenas

560
00:25:56,990 --> 00:25:59,230
intentara meter un alumno, me dirían, no, aquí solo

561
00:25:59,230 --> 00:26:00,230
Puedes meter cadenas

562
00:26:00,230 --> 00:26:02,309
¿Vale?

563
00:26:02,950 --> 00:26:04,450
Porque el método add

564
00:26:04,450 --> 00:26:06,430
El método add

565
00:26:06,430 --> 00:26:09,390
Ya ha cogido el tipo de

566
00:26:09,390 --> 00:26:10,930
Dato con el que yo lo creé, lo ha cogido

567
00:26:10,930 --> 00:26:12,930
No puedo meter otra cosa que no sea este

568
00:26:12,930 --> 00:26:14,710
Si yo aquí he puesto alumno

569
00:26:14,710 --> 00:26:16,849
Pues solo puedo meter alumno

570
00:26:16,849 --> 00:26:18,230
Aquí, ¿vale?

571
00:26:19,109 --> 00:26:19,589
Sí

572
00:26:19,589 --> 00:26:24,500
Claro que no te deja

573
00:26:24,500 --> 00:26:26,839
Porque solo hay un pequeñito problema

574
00:26:26,839 --> 00:26:27,940
¿Vale?

575
00:26:33,059 --> 00:26:35,740
Solo podemos meter

576
00:26:35,740 --> 00:26:39,059
del tipo con que se creó.

577
00:26:39,900 --> 00:26:42,880
Vale, bueno, pues entonces lo que íbamos a decir ahora.

578
00:26:43,099 --> 00:26:45,859
Vale, pues esto solo tiene un pequeñísimo,

579
00:26:46,039 --> 00:26:48,880
minimísimo, muy minimísimo y despreciable problema.

580
00:26:49,619 --> 00:26:54,599
Y es que los tipos genéricos

581
00:26:54,599 --> 00:26:58,859
solo se pueden sustituir por tipos objeto.

582
00:26:59,539 --> 00:27:01,859
No se pueden sustituir por tipos primitivos.

583
00:27:02,680 --> 00:27:05,680
No se pueden sustituir ni por byte, short, int, long,

584
00:27:05,680 --> 00:27:07,839
Float, Double, Boolean y Chart

585
00:27:07,839 --> 00:27:09,940
Solo por tipos

586
00:27:09,940 --> 00:27:11,500
Objetos

587
00:27:11,500 --> 00:27:12,920
Con lo cual me diréis

588
00:27:12,920 --> 00:27:15,579
Jolín, por si yo quiero una caja para números

589
00:27:15,579 --> 00:27:16,700
¿Qué hago?

590
00:27:16,980 --> 00:27:19,599
No pasa nada porque tenemos los envolventes

591
00:27:19,599 --> 00:27:21,500
Los wrappers de toda la vida

592
00:27:21,500 --> 00:27:23,460
Que ya los hemos mencionado

593
00:27:23,460 --> 00:27:24,400
Alguna vez así

594
00:27:24,400 --> 00:27:26,339
¿Vale? Que es un

595
00:27:26,339 --> 00:27:28,180
Un envolvente

596
00:27:28,180 --> 00:27:34,980
Pues cada tipo primitivo

597
00:27:34,980 --> 00:27:37,619
Tiene

598
00:27:37,619 --> 00:27:39,579
Un tipo objeto, una clase

599
00:27:39,579 --> 00:27:41,500
declarada por ahí por el mundo, por

600
00:27:41,500 --> 00:27:43,819
Jabalán, que lo envuelve.

601
00:27:44,579 --> 00:27:44,940
Int

602
00:27:44,940 --> 00:27:47,380
tiene el envolvente int

603
00:27:47,380 --> 00:27:49,420
se llaman groupers, clase.

604
00:27:51,259 --> 00:27:51,779
Double

605
00:27:51,779 --> 00:27:54,160
tiene

606
00:27:54,160 --> 00:27:56,700
asociada

607
00:27:56,700 --> 00:27:59,220
una clase double, o sea, hay una

608
00:27:59,220 --> 00:28:01,440
class integer, class double, existen

609
00:28:01,440 --> 00:28:02,099
ahí en la

610
00:28:02,099 --> 00:28:05,039
JRE, en la librería estándar.

611
00:28:05,839 --> 00:28:07,440
¿Para qué sirven estas clases?

612
00:28:07,440 --> 00:28:09,759
sirven exclusivamente

613
00:28:09,759 --> 00:28:11,140
para guardar dentro

614
00:28:11,140 --> 00:28:13,240
un numerito del tipo que sea.

615
00:28:13,940 --> 00:28:16,039
Integer te guarda dentro un int.

616
00:28:16,559 --> 00:28:17,900
Double te guarda dentro un double.

617
00:28:18,259 --> 00:28:19,059
¿Qué es lo que cambia?

618
00:28:19,119 --> 00:28:20,819
Que esto te lo guarda en modo objeto,

619
00:28:21,319 --> 00:28:23,880
como referencia que apunta al numerito

620
00:28:23,880 --> 00:28:25,740
y esto es un tipo primitivo sin más,

621
00:28:25,799 --> 00:28:26,559
sin referencia ni nada.

622
00:28:27,240 --> 00:28:28,299
Entonces, al ser una clase,

623
00:28:28,980 --> 00:28:30,519
los objetos Integer o Double

624
00:28:30,519 --> 00:28:32,920
además te ofrecen métodos

625
00:28:32,920 --> 00:28:33,839
para hacer cosas.

626
00:28:34,480 --> 00:28:36,720
Un tipo primitivo jamás te podría ofrecer un método,

627
00:28:36,720 --> 00:28:42,680
Pero un tipo de estos sí, te ofrece métodos que podéis mirar para ver qué se puede hacer también.

628
00:28:45,259 --> 00:28:55,720
Bueno, pues estos tipos primitivos, estos tipos envolventes, son los que necesitamos cuando tenemos que guardar números en colecciones.

629
00:28:55,720 --> 00:28:59,079
Los tipos

630
00:28:59,079 --> 00:29:01,400
Por ejemplo

631
00:29:01,400 --> 00:29:04,740
Yo me quiero hacer ahora

632
00:29:04,740 --> 00:29:08,039
Una cajita con notas

633
00:29:08,039 --> 00:29:12,339
¿Vale?

634
00:29:12,339 --> 00:29:13,440
¿Puedes subir un poquito?

635
00:29:16,519 --> 00:29:16,779
¿Dónde?

636
00:29:18,000 --> 00:29:18,200
¿Eh?

637
00:29:18,500 --> 00:29:18,960
Ah, no, eh

638
00:29:18,960 --> 00:29:21,940
En algún, o sea, donde has puesto mi

639
00:29:21,940 --> 00:29:22,940
Arraylist chulo

640
00:29:22,940 --> 00:29:23,920
Ah

641
00:29:23,920 --> 00:29:26,940
No, no, no, en el main

642
00:29:26,940 --> 00:29:29,299
Aquí

643
00:29:29,299 --> 00:29:33,720
Sí, porque he dicho que esto

644
00:29:33,720 --> 00:29:34,960
Se puede dejar vacío

645
00:29:34,960 --> 00:29:38,000
O lo podéis poner, da igual, según como da lo mismo

646
00:29:38,000 --> 00:29:39,880
Porque lo que importa es que esté aquí

647
00:29:39,880 --> 00:29:41,079
¿Vale?

648
00:29:41,539 --> 00:29:44,039
Vale, pues entonces, ahora quiero una caja de números

649
00:29:44,039 --> 00:29:45,900
¿Vale? Pues para los

650
00:29:45,900 --> 00:29:46,619
Primitivos

651
00:29:46,619 --> 00:29:48,079
Para los primitivos

652
00:29:48,079 --> 00:29:50,819
Hay que usar

653
00:29:50,819 --> 00:29:56,299
El envolvente

654
00:29:56,299 --> 00:29:58,880
Por ejemplo, quiero la lista de notas

655
00:29:58,880 --> 00:30:03,269
caja notas

656
00:30:03,269 --> 00:30:04,869
quiero que sea

657
00:30:04,869 --> 00:30:08,650
de números sin más

658
00:30:08,650 --> 00:30:10,650
pues le pongo íntegro

659
00:30:10,650 --> 00:30:19,849
y ya está

660
00:30:19,849 --> 00:30:38,160
vale

661
00:30:38,160 --> 00:30:41,039
los envolventes

662
00:30:41,039 --> 00:30:43,799
se pueden usar como si fueran primitivos

663
00:30:43,799 --> 00:30:45,640
a la hora de asignar valores, no hace falta

664
00:30:45,640 --> 00:30:47,740
hacer el new ni nada, es decir, por ejemplo

665
00:30:47,740 --> 00:30:49,599
aquí en

666
00:30:49,599 --> 00:30:50,559
caja notas

667
00:30:50,559 --> 00:30:53,339
yo quiero meter un numerito

668
00:30:53,339 --> 00:30:55,259
tengo que meter un íntegro

669
00:30:55,259 --> 00:30:56,640
no hace falta que haga

670
00:30:56,640 --> 00:30:59,140
new integer porque es un objeto

671
00:30:59,140 --> 00:31:00,740
no, es que de hecho

672
00:31:00,740 --> 00:31:02,839
están deprecados estos constructores

673
00:31:02,839 --> 00:31:04,339
lo podría hacer, pero es feo

674
00:31:04,339 --> 00:31:06,059
es como los string

675
00:31:06,059 --> 00:31:08,680
a un string le asignamos la cadena y no hacemos

676
00:31:08,680 --> 00:31:10,880
new string, pues aquí yo puedo hacer

677
00:31:10,880 --> 00:31:12,559
esto y ya

678
00:31:12,559 --> 00:31:14,480
esto que sería un int primitivo

679
00:31:14,480 --> 00:31:16,319
ya sabéis que si pongo un número en java

680
00:31:16,319 --> 00:31:18,059
se guarda como un int primitivo

681
00:31:18,059 --> 00:31:20,740
pues ya automáticamente la máquina virtual

682
00:31:20,740 --> 00:31:22,740
lo promociona al tipo objeto integer

683
00:31:22,740 --> 00:31:24,619
luego hay un intercambio

684
00:31:24,619 --> 00:31:27,400
automático entre integer e int

685
00:31:27,400 --> 00:31:29,079
no hay ningún problema en eso

686
00:31:29,079 --> 00:31:31,240
vale, es decir

687
00:31:31,240 --> 00:31:32,740
por ejemplo aquí tenéis un double

688
00:31:32,740 --> 00:31:35,319
vale, pues

689
00:31:35,319 --> 00:31:37,000
este es un objeto, este es un tipo objeto

690
00:31:37,000 --> 00:31:39,460
pero ahora de asignarle algo

691
00:31:39,460 --> 00:31:41,339
no hace falta hacerle un new

692
00:31:41,339 --> 00:31:43,259
double, igual que al string no hace falta

693
00:31:43,259 --> 00:31:44,339
hacerle un new string

694
00:31:44,339 --> 00:31:46,599
le podéis asignar directamente

695
00:31:46,599 --> 00:31:49,299
el numerito 3.6

696
00:31:49,299 --> 00:31:51,039
que sería un double

697
00:31:51,039 --> 00:31:53,460
primitivo, pero él ya lo promociona al tipo objeto

698
00:31:53,460 --> 00:31:56,119
¿Vale? O sea, es fácil trabajar con los envolventes

699
00:31:56,119 --> 00:31:57,900
Pero trabaja igual, que si fueran primitivos

700
00:31:57,900 --> 00:31:58,579
Trabaja igual

701
00:31:58,579 --> 00:32:02,259
Con la única diferencia de que tienen

702
00:32:02,259 --> 00:32:02,839
Métodos

703
00:32:02,839 --> 00:32:06,099
La única diferencia, por ejemplo, si yo me hago

704
00:32:06,099 --> 00:32:08,500
Aquí un double de 2

705
00:32:08,500 --> 00:32:09,539
Igual

706
00:32:09,539 --> 00:32:12,059
A 3.6

707
00:32:12,059 --> 00:32:14,160
El dato que tienen

708
00:32:14,160 --> 00:32:15,119
Es el mismo

709
00:32:15,119 --> 00:32:18,099
Pero de 1

710
00:32:18,099 --> 00:32:19,519
Puede llamar a métodos

711
00:32:19,519 --> 00:32:21,779
¿Veis? Double value equals float

712
00:32:21,779 --> 00:32:24,099
pasármelo a float, compararlo con otro

713
00:32:24,099 --> 00:32:25,460
bla bla bla

714
00:32:25,460 --> 00:32:26,859
no es un número

715
00:32:26,859 --> 00:32:29,619
pero sin embargo

716
00:32:29,619 --> 00:32:31,680
D2 no puede llamar a métodos porque es un tipo

717
00:32:31,680 --> 00:32:33,960
primitivo, es la única diferencia

718
00:32:33,960 --> 00:32:34,640
entre uno y otro

719
00:32:34,640 --> 00:32:37,339
pero uno se puede asignar a otro sin problema

720
00:32:37,339 --> 00:32:39,619
a D1 le puedo asignar

721
00:32:39,619 --> 00:32:41,759
D2 y no pasa nada

722
00:32:41,759 --> 00:32:43,400
se asigna a uno el valor del otro

723
00:32:43,400 --> 00:32:46,400
y a D2

724
00:32:46,400 --> 00:32:47,859
le puedo asignar D1

725
00:32:47,859 --> 00:32:49,920
y no pasa nada, el valor de uno pasa al otro

726
00:32:49,920 --> 00:32:51,779
aunque uno esté en primitivo y otro esté en objeto

727
00:32:51,779 --> 00:32:54,039
a la hora de asignarse valores

728
00:32:54,039 --> 00:32:56,319
son indistintos

729
00:32:56,319 --> 00:32:58,339
lo único es que uno puede llamar a métodos

730
00:32:58,339 --> 00:32:58,740
y otro no

731
00:32:58,740 --> 00:33:01,160
¿y por qué son interesantes?

732
00:33:01,700 --> 00:33:04,700
pues porque para los tipos genéricos

733
00:33:04,700 --> 00:33:06,180
para esto que nos hemos

734
00:33:06,180 --> 00:33:06,920
encontrado ahora

735
00:33:06,920 --> 00:33:10,180
un tipo genérico solamente puede ser sustituido

736
00:33:10,180 --> 00:33:11,180
por un tipo objeto

737
00:33:11,180 --> 00:33:14,339
luego yo aquí jamás podría poner

738
00:33:14,339 --> 00:33:14,779
int

739
00:33:14,779 --> 00:33:16,819
¿vale?

740
00:33:16,819 --> 00:33:19,420
porque un tipo primitivo no puede

741
00:33:19,420 --> 00:33:21,400
sustituir a un tipo

742
00:33:21,400 --> 00:33:22,680
genérico, no puede

743
00:33:22,680 --> 00:33:25,359
pero es tan fácil como poner

744
00:33:25,359 --> 00:33:27,380
el envolvente

745
00:33:27,380 --> 00:33:29,119
y como funciona igual que el innormal

746
00:33:29,119 --> 00:33:31,579
pues ya está

747
00:33:31,579 --> 00:33:32,339
vale

748
00:33:32,339 --> 00:33:42,470
y ya por último

749
00:33:42,470 --> 00:33:43,630
y nos vamos

750
00:33:43,630 --> 00:33:46,269
y lo que es todavía más

751
00:33:46,269 --> 00:33:47,369
emocionante

752
00:33:47,369 --> 00:33:50,450
de hecho, podría yo

753
00:33:50,450 --> 00:33:51,670
hacer una clase genérica

754
00:33:51,670 --> 00:33:55,900
Y en este caso

755
00:33:55,900 --> 00:33:57,400
Un array chulo, genérico

756
00:33:57,400 --> 00:33:59,779
Y no decir el tipo de dato

757
00:33:59,779 --> 00:34:01,859
Es decir, no sé si habéis

758
00:34:01,859 --> 00:34:04,220
Intentado hacer esto

759
00:34:04,220 --> 00:34:25,559
Ya, ya, ahora

760
00:34:25,559 --> 00:34:27,480
Me arrepiento, pero en su momento

761
00:34:27,480 --> 00:34:30,159
Es lo que tiene, no prever las cosas

762
00:34:30,159 --> 00:34:33,360
Pero bueno, a ver, que vosotros tenéis

763
00:34:33,360 --> 00:34:34,760
Vuestra propia personalidad

764
00:34:34,760 --> 00:34:36,860
Y no tenéis que copiar todo lo mío tal cual

765
00:34:36,860 --> 00:34:38,420
Lo hacéis, eh

766
00:34:38,420 --> 00:34:40,519
O mucho mejor

767
00:34:40,519 --> 00:34:42,119
Vale

768
00:34:42,119 --> 00:34:45,699
bueno, pues entonces

769
00:34:45,699 --> 00:34:47,280
si habéis cotilleado

770
00:34:47,280 --> 00:34:49,199
habréis visto, anda

771
00:34:49,199 --> 00:34:51,920
pero si me deja crear una caja sin decir

772
00:34:51,920 --> 00:34:52,440
el tipo

773
00:34:52,440 --> 00:34:55,699
eso no va en contra de lo que decimos

774
00:34:55,699 --> 00:34:57,639
que cuando creamos

775
00:34:57,639 --> 00:34:59,719
un objeto, ya ese objeto tiene que tener

776
00:34:59,719 --> 00:35:01,679
el tipo comprometido para poder instanciar

777
00:35:01,679 --> 00:35:03,780
algo, porque hay que hacer un mío en algún sitio

778
00:35:03,780 --> 00:35:05,780
la máquina virtual tiene que saber

779
00:35:05,780 --> 00:35:07,619
qué instancia, pues me está dejando

780
00:35:07,619 --> 00:35:09,900
no comprometerlo, no es que me esté dejando

781
00:35:09,900 --> 00:35:11,019
es que si yo no se lo digo

782
00:35:11,019 --> 00:35:13,280
él coge uno. Y dice, pues

783
00:35:13,280 --> 00:35:15,659
si tú no me lo dices, yo me invento

784
00:35:15,659 --> 00:35:17,320
el que quiera. ¿Se inventa el que quiera?

785
00:35:17,539 --> 00:35:18,780
No, no se inventa el que quiera.

786
00:35:19,099 --> 00:35:20,480
Lo hace como object.

787
00:35:21,559 --> 00:35:23,340
Porque la clase object existe

788
00:35:23,340 --> 00:35:25,079
y yo no puedo instanciar un object.

789
00:35:25,679 --> 00:35:27,460
¿Y qué es un object? Algo en lo que

790
00:35:27,460 --> 00:35:29,480
cabe todo. Porque object

791
00:35:29,480 --> 00:35:31,599
es la superclase divina mundial.

792
00:35:33,280 --> 00:35:33,719
Entonces,

793
00:35:33,960 --> 00:35:35,639
si yo hago una caja, esta caja

794
00:35:35,639 --> 00:35:37,739
se convierte en una caja

795
00:35:37,739 --> 00:35:38,699
muy loca.

796
00:35:38,699 --> 00:35:42,000
porque yo le puedo meter a la caja

797
00:35:42,000 --> 00:35:43,820
loca, le puedo meter

798
00:35:43,820 --> 00:35:45,440
una cadena si me da la gana

799
00:35:45,440 --> 00:35:47,820
y a la caja

800
00:35:47,820 --> 00:35:49,019
loca, esta

801
00:35:49,019 --> 00:35:51,619
le puedo meter un

802
00:35:51,619 --> 00:35:53,340
niño alumno si me da la gana

803
00:35:53,340 --> 00:35:57,320
muy loca

804
00:35:57,320 --> 00:36:00,460
y eso la hace

805
00:36:00,460 --> 00:36:01,380
muy problemática

806
00:36:01,380 --> 00:36:06,590
o sea, en esta caja

807
00:36:06,590 --> 00:36:09,289
cabe todo, porque todo

808
00:36:09,289 --> 00:36:11,269
es subclase de object

809
00:36:11,269 --> 00:36:12,150
todo

810
00:36:12,150 --> 00:36:15,369
entonces todo encaja

811
00:36:15,369 --> 00:36:16,309
en el tipo object

812
00:36:16,309 --> 00:36:19,130
recordad de herencia e implementación

813
00:36:19,130 --> 00:36:21,570
¿vale? cuando tú declaras

814
00:36:21,570 --> 00:36:22,590
algo de una clase

815
00:36:22,590 --> 00:36:25,349
ahí cabe cualquier cosa de esa clase

816
00:36:25,349 --> 00:36:26,289
y de las herederas

817
00:36:26,289 --> 00:36:29,170
con lo cual esto está declarado

818
00:36:29,170 --> 00:36:30,730
como object, porque yo no lo he dicho

819
00:36:30,730 --> 00:36:32,929
luego es object, con lo cual aquí cabe

820
00:36:32,929 --> 00:36:34,429
cualquier heredero de object

821
00:36:34,429 --> 00:36:36,989
y de object hereda todo

822
00:36:36,989 --> 00:36:38,329
luego en esta caja cabe todo

823
00:36:38,329 --> 00:36:39,909
¿es un problema?

824
00:36:39,909 --> 00:36:41,889
hombre, no es que sea

825
00:36:41,889 --> 00:36:44,070
es peligroso, porque si metes

826
00:36:44,070 --> 00:36:45,769
todo en la caja, cuando luego hagas get

827
00:36:45,769 --> 00:36:47,510
no sabes lo que estás sacando

828
00:36:47,510 --> 00:36:50,309
no sabes si estás sacando un alumno, no sabes si estás sacando no sé qué

829
00:36:50,309 --> 00:36:52,210
entonces, se convierte en un

830
00:36:52,210 --> 00:36:53,949
rollo, o sea, si yo saco la posición

831
00:36:53,949 --> 00:36:56,250
cero, la posición cero

832
00:36:56,250 --> 00:36:57,869
tiene que ir a object

833
00:36:57,869 --> 00:36:59,809
porque esto es un object

834
00:36:59,809 --> 00:37:01,269
si yo saco la posición cero

835
00:37:01,269 --> 00:37:03,769
caja.get de cero

836
00:37:03,769 --> 00:37:07,949
y ahora object, como trabajo con

837
00:37:07,949 --> 00:37:09,210
object, le tengo que hacer un casting

838
00:37:09,210 --> 00:37:11,190
Me toca hacer un instance off

839
00:37:11,190 --> 00:37:13,650
If all instance off

840
00:37:13,650 --> 00:37:15,010
No sé qué hace esto

841
00:37:15,010 --> 00:37:18,840
¿Eh?

842
00:37:22,360 --> 00:37:23,639
¿Que por qué pongo aquí object?

843
00:37:24,300 --> 00:37:26,019
Porque eso es lo que me devuelve el get

844
00:37:26,019 --> 00:37:26,519
Object

845
00:37:26,519 --> 00:37:28,539
Porque en la caja cabe de todo

846
00:37:28,539 --> 00:37:29,599
Me arraila, es chulo

847
00:37:29,599 --> 00:37:30,840
Yo le he dicho que esto es object

848
00:37:30,840 --> 00:37:32,639
Luego lo que me devuelve es object

849
00:37:32,639 --> 00:37:33,840
No estoy comprometiendo nada

850
00:37:33,840 --> 00:37:35,079
Me ha cabido cualquier cosa

851
00:37:35,079 --> 00:37:38,000
Entonces el código se convierte en un rollo

852
00:37:38,000 --> 00:37:39,780
Porque con cada get

853
00:37:39,780 --> 00:37:42,159
tendría que hacer aquí tropecientos

854
00:37:42,159 --> 00:37:44,719
instansoft, instansoft alumno

855
00:37:44,719 --> 00:37:45,840
pues haz no sé qué

856
00:37:45,840 --> 00:37:48,639
instansoft stream, haz no sé cuántos

857
00:37:49,239 --> 00:37:51,320
un rollo

858
00:37:51,320 --> 00:37:53,980
¿vale? entonces hombre

859
00:37:53,980 --> 00:37:56,900
no es el uso de una clase genérica

860
00:37:56,900 --> 00:37:58,719
dejar meter cualquier

861
00:37:58,719 --> 00:38:00,559
cosa, porque luego manejarla

862
00:38:00,559 --> 00:38:02,639
es complicado, no sabes lo que

863
00:38:02,639 --> 00:38:04,599
hay en cada sitio, tienes que hacer casting

864
00:38:04,599 --> 00:38:06,579
tienes esos casting para

865
00:38:06,579 --> 00:38:08,420
que no te peten, tienes que hacer instansoft

866
00:38:08,420 --> 00:38:10,440
para adelante, entonces

867
00:38:10,440 --> 00:38:12,260
hombre, podemos usar

868
00:38:12,260 --> 00:38:14,179
los tipos genéricos

869
00:38:14,179 --> 00:38:16,590
¿vale?

870
00:38:17,989 --> 00:38:19,230
esto se llama

871
00:38:19,230 --> 00:38:22,070
que no estamos parametrizando la clase

872
00:38:22,070 --> 00:38:24,150
podemos usar

873
00:38:24,150 --> 00:38:24,829
la clase

874
00:38:24,829 --> 00:38:27,170
sin parametrizarla

875
00:38:27,170 --> 00:38:31,340
parametrizarla es sin darle el parámetro

876
00:38:31,340 --> 00:38:33,460
t, sin parametrizarla

877
00:38:34,280 --> 00:38:38,659
pero

878
00:38:38,659 --> 00:38:40,059
entonces cabe todo

879
00:38:40,059 --> 00:38:42,900
y eso es

880
00:38:42,900 --> 00:38:44,500
pues lógicamente peligroso

881
00:38:44,500 --> 00:38:45,980
porque tengo que tener un cuidado

882
00:38:45,980 --> 00:38:49,469
cada vez que saco algo

883
00:38:49,469 --> 00:38:50,929
de ver lo que es

884
00:38:50,929 --> 00:38:52,670
¿vale?

885
00:38:53,949 --> 00:38:56,070
entonces, usar una clase genérica

886
00:38:56,070 --> 00:38:57,429
sin comprometer el tipo

887
00:38:57,429 --> 00:38:58,409
podemos

888
00:38:58,409 --> 00:39:04,550
¿vale? asume que es object

889
00:39:04,550 --> 00:39:06,570
asume que es object

890
00:39:06,570 --> 00:39:10,789
se pone así porque

891
00:39:10,789 --> 00:39:12,909
todo es un uso específico del eclipse

892
00:39:12,909 --> 00:39:14,289
para subir por código

893
00:39:14,289 --> 00:39:16,789
¿vale?

894
00:39:17,769 --> 00:39:45,449
Entonces, sí, la podemos usar así, pero luego el código que viene después, cuidadín, porque de aquí solo unido que salen son objects, salen objects, salen objects, ¿y qué hago yo con los objects? Un object no tiene métodos de nada. Pues tendré que hacer casting, cuidado con los casting, porque no sé qué tipo de objeto es. Luego, hombre, si tengo un cuidado extremo en mi código, vale, pero si no, ¿qué necesidad? Lo normal es que uno use las cajas para un tipo de datos concreto y sus subclases, por supuesto, y sus subclases.

895
00:39:45,449 --> 00:39:50,070
De hecho, el compilador se nos ha puesto en amarillo

896
00:39:50,070 --> 00:39:51,590
Porque nos avisa

897
00:39:51,590 --> 00:39:53,010
Nos está diciendo

898
00:39:53,010 --> 00:39:56,630
Uy, cuidado que es un tipo genérico, amplio

899
00:39:56,630 --> 00:39:59,610
Deberías, deberías

900
00:39:59,610 --> 00:40:02,849
Ponerle el parámetro, deberías

901
00:40:02,849 --> 00:40:04,409
Porque si no, la lía

902
00:40:04,409 --> 00:40:06,289
El aviso te lo da, ¿vale?

903
00:40:07,309 --> 00:40:08,630
El aviso te lo da

904
00:40:08,630 --> 00:40:14,550
Vale, y ahora ya sí que