1
00:00:00,050 --> 00:00:04,790
Siento un poco de presión

2
00:00:04,790 --> 00:00:09,580
Vale, ahora ya le he dado

3
00:00:09,580 --> 00:00:11,099
¿Ya estás contento?

4
00:00:14,550 --> 00:00:15,769
Venga, pues entonces

5
00:00:15,769 --> 00:00:19,010
Pizarrita

6
00:00:19,010 --> 00:00:22,030
Vale, pues veréis qué precioso es esto

7
00:00:22,030 --> 00:00:22,589
Realmente

8
00:00:22,589 --> 00:00:25,550
Y cómo cambia la visión de las cosas

9
00:00:25,550 --> 00:00:36,070
Vale, pues a ver

10
00:00:36,070 --> 00:00:37,869
Imaginad

11
00:00:37,869 --> 00:00:39,549
Para motivar

12
00:00:39,549 --> 00:00:41,549
La existencia de todo esto

13
00:00:41,549 --> 00:00:43,829
Imaginad, por ejemplo, que estamos haciendo

14
00:00:43,829 --> 00:00:45,990
una clase calculadora para variar

15
00:00:45,990 --> 00:00:46,850
que es la más

16
00:00:46,850 --> 00:00:49,990
ocurrida porque tiene varias

17
00:00:49,990 --> 00:00:51,990
operaciones, varias cosas que

18
00:00:51,990 --> 00:00:53,969
hacer muy parecidas entre sí, como sumar, restar

19
00:00:53,969 --> 00:00:55,789
multiplicar, bueno pues imaginar

20
00:00:55,789 --> 00:00:58,090
que vamos a hacer ahí una calculadora

21
00:00:58,090 --> 00:01:07,540
entonces

22
00:01:07,540 --> 00:01:09,700
tenemos varias operaciones

23
00:01:09,700 --> 00:01:12,379
por ejemplo vamos a quedarnos con sumar y multiplicar

24
00:01:12,379 --> 00:01:13,840
que es lo más sencillo

25
00:01:13,840 --> 00:01:16,180
pues uno haría, venga pues que puede hacer mi calculadora

26
00:01:16,180 --> 00:01:17,599
mi calculadora

27
00:01:17,599 --> 00:01:19,379
puede sumar

28
00:01:19,379 --> 00:01:20,659
pues venga yo me hago

29
00:01:20,659 --> 00:01:22,519
mi primer método

30
00:01:22,519 --> 00:01:35,950
me hago mi primer método

31
00:01:35,950 --> 00:01:37,409
sumar

32
00:01:37,409 --> 00:01:40,810
pues donde le paso los operandos

33
00:01:40,810 --> 00:01:48,920
y aquí

34
00:01:48,920 --> 00:01:51,319
le digo pues nada, return

35
00:01:51,319 --> 00:01:55,180
pues los operandos pueden estar aquí

36
00:01:55,180 --> 00:02:04,439
vale, hasta aquí bien

37
00:02:04,439 --> 00:02:06,920
un método de toda la vida al que le pasamos datos

38
00:02:06,920 --> 00:02:08,800
porque hasta ahora hemos hablado

39
00:02:08,800 --> 00:02:11,439
de que a los métodos les pasamos datos

40
00:02:11,439 --> 00:02:13,020
vale, que le pasamos datos

41
00:02:13,020 --> 00:02:14,580
ahora yo quiero restar

42
00:02:14,580 --> 00:02:16,159
o multiplicar

43
00:02:16,159 --> 00:02:19,039
pues ese método no es igual que este

44
00:02:19,039 --> 00:02:20,719
porque no hace lo mismo

45
00:02:20,719 --> 00:02:23,120
entonces yo aquí haría

46
00:02:23,120 --> 00:02:24,360
pues mi otro método

47
00:02:24,360 --> 00:02:37,069
donde ya este otro método

48
00:02:37,069 --> 00:02:38,909
muy parecido pero no es igual

49
00:02:38,909 --> 00:02:41,349
porque este método me haría esto

50
00:02:41,349 --> 00:02:42,250
por ejemplo

51
00:02:42,250 --> 00:02:45,229
entonces tengo dos métodos distintos

52
00:02:45,229 --> 00:02:47,289
para hacer dos operaciones distintas

53
00:02:47,289 --> 00:02:48,569
muy parecidos entre sí

54
00:02:48,569 --> 00:02:50,969
entonces aquí uno podría

55
00:02:50,969 --> 00:02:53,629
dar ya el primer salto

56
00:02:53,629 --> 00:02:53,990
para

57
00:02:53,990 --> 00:02:57,330
colocar o refactorizar este código

58
00:02:57,330 --> 00:02:58,229
que es, vamos a ver

59
00:02:58,229 --> 00:03:01,509
estos dos métodos solamente

60
00:03:01,509 --> 00:03:03,710
se diferencian en esta cosita de aquí

61
00:03:03,710 --> 00:03:05,569
solo en esto

62
00:03:05,569 --> 00:03:07,590
bueno, pues los voy a meter

63
00:03:07,590 --> 00:03:09,409
en un solo método, por ejemplo, que sea

64
00:03:09,409 --> 00:03:10,030
operar

65
00:03:10,030 --> 00:03:13,830
y yo le paso, aparte de mis datos

66
00:03:13,830 --> 00:03:16,949
le paso la operación de alguna manera

67
00:03:16,949 --> 00:03:18,650
ya veré cómo, le paso la operación

68
00:03:18,650 --> 00:03:20,509
de alguna manera, si es suma si es resta

69
00:03:20,509 --> 00:03:22,469
y en función de la operación que la haga unir

70
00:03:22,469 --> 00:03:24,849
¿vale? bueno, pues sería el primer paso

71
00:03:24,849 --> 00:03:26,590
para a lo mejor cambiar esto un poquito

72
00:03:26,590 --> 00:03:28,889
y que no empezaran a proliferar

73
00:03:28,889 --> 00:03:30,090
ahí propiciando métodos

74
00:03:30,090 --> 00:03:32,590
sumar, multiplicar, restar, dividir

75
00:03:32,590 --> 00:03:33,969
no sé qué, no sé cuántos

76
00:03:33,969 --> 00:03:36,169
sería lo ideal, que esto no proliferara

77
00:03:36,169 --> 00:03:38,370
bueno, pues entonces

78
00:03:38,370 --> 00:03:40,629
podríamos hacer

79
00:03:40,629 --> 00:03:42,830
esa primera

80
00:03:42,830 --> 00:03:54,650
la refactorización y decir, pues ala, voy a llamar a mi método operar, operar, que

81
00:03:54,650 --> 00:04:01,330
es lo que hace una calculadora, la calculadora opera, a mi método le llamo operar y ahora

82
00:04:01,330 --> 00:04:07,949
le tengo que pasar, si no tengo los operandos aquí, eso ya depende de cómo haya hecho

83
00:04:07,949 --> 00:04:09,930
el diseño, pues a lo mejor

84
00:04:09,930 --> 00:04:11,689
le tengo que pasar los operandos

85
00:04:11,689 --> 00:04:15,580
y

86
00:04:15,580 --> 00:04:17,500
necesito un dato más, si o si

87
00:04:17,500 --> 00:04:19,439
necesito un dato más que es

88
00:04:19,439 --> 00:04:21,439
que tipo de operación, para que

89
00:04:21,439 --> 00:04:23,500
en función del tipo de operación haga una cosa

90
00:04:23,500 --> 00:04:25,399
u otra, entonces yo aquí tengo que tomar

91
00:04:25,399 --> 00:04:26,660
una decisión y es

92
00:04:26,660 --> 00:04:29,319
el tipo de operación como lo convierto

93
00:04:29,319 --> 00:04:31,300
a dato, bueno en este caso

94
00:04:31,300 --> 00:04:32,339
a lo mejor lo podría hacer

95
00:04:32,339 --> 00:04:35,439
como un string, le paso

96
00:04:35,439 --> 00:04:37,220
un string con el más o con el menos

97
00:04:37,220 --> 00:04:39,319
o con el por, entonces he hecho ya una cosa

98
00:04:39,319 --> 00:04:41,620
que es medio rara, convertir

99
00:04:41,620 --> 00:04:43,360
una operación en un

100
00:04:43,360 --> 00:04:45,399
dato y para eso me he

101
00:04:45,399 --> 00:04:46,620
inventado, he decidido

102
00:04:46,620 --> 00:04:48,759
que se la voy a pasar en un string

103
00:04:48,759 --> 00:04:49,500
¿vale?

104
00:04:51,079 --> 00:04:52,459
entonces ahora yo aquí

105
00:04:52,459 --> 00:04:55,060
tendría que hacer mi shift, el save

106
00:04:55,060 --> 00:04:57,040
en función de

107
00:04:57,040 --> 00:04:59,079
la operación, si ese

108
00:04:59,079 --> 00:05:00,879
dato operaciones suma

109
00:05:00,879 --> 00:05:02,980
hago lo que sea, si ese dato

110
00:05:02,980 --> 00:05:05,360
operación es resta hago lo que

111
00:05:05,360 --> 00:05:05,920
sea, etc.

112
00:05:07,100 --> 00:05:09,079
pues nada, esto sería otro

113
00:05:09,079 --> 00:05:23,579
planteamiento, que sigue los principios de la programación declarativa de toda la vida.

114
00:05:26,319 --> 00:05:49,970
Pero, teniendo en cuenta que esto es una operación, este dato de aquí que yo le paso es una operación,

115
00:05:49,970 --> 00:05:52,769
podríamos decir, vamos a ver

116
00:05:52,769 --> 00:05:54,509
yo a este tío

117
00:05:54,509 --> 00:05:55,310
a este método

118
00:05:55,310 --> 00:05:58,329
lo que le tengo que decir es

119
00:05:58,329 --> 00:05:59,870
que tiene que hacer

120
00:05:59,870 --> 00:06:01,970
eso es lo que le tengo que decir

121
00:06:01,970 --> 00:06:04,810
si tiene que sumar, si tiene que restar

122
00:06:04,810 --> 00:06:06,689
si tiene que multiplicar, eso es lo que le tengo que decir

123
00:06:06,689 --> 00:06:07,769
que tiene que hacer

124
00:06:07,769 --> 00:06:10,430
luego, lo que realmente le tengo que pasar

125
00:06:10,430 --> 00:06:12,170
a este método es

126
00:06:12,170 --> 00:06:14,009
una acción

127
00:06:14,009 --> 00:06:16,490
un comportamiento, es lo que le tengo que pasar

128
00:06:16,490 --> 00:06:18,529
le tengo que pasar, no unos datos

129
00:06:18,529 --> 00:06:20,769
lo que le tengo que pasar es

130
00:06:20,769 --> 00:06:22,550
oye, haz esto

131
00:06:22,550 --> 00:06:24,610
le tengo que pasar la acción que tiene que hacer

132
00:06:24,610 --> 00:06:25,589
lo que tiene que hacer

133
00:06:25,589 --> 00:06:28,230
le tengo que decir, tú tienes que hacer esto

134
00:06:28,230 --> 00:06:29,870
incluso

135
00:06:29,870 --> 00:06:31,949
con toda la secuencia de instrucciones

136
00:06:31,949 --> 00:06:33,990
tú lo que tienes que hacer es coger unos datos

137
00:06:33,990 --> 00:06:35,790
sumarlos, mostrarlos

138
00:06:35,790 --> 00:06:38,170
incluso le puedo pasar

139
00:06:38,170 --> 00:06:40,490
sería ideal que yo le pudiera

140
00:06:40,490 --> 00:06:41,550
pasar por parámetro

141
00:06:41,550 --> 00:06:43,769
una lista de todo lo que tiene que hacer

142
00:06:43,769 --> 00:06:44,810
una lista de órdenes

143
00:06:44,810 --> 00:06:47,269
sería como a un método

144
00:06:47,269 --> 00:06:50,110
pasarle como parámetro otro método

145
00:06:50,110 --> 00:06:51,730
¿vale? que es algo

146
00:06:51,730 --> 00:06:53,750
distinto a lo que hemos hecho siempre

147
00:06:53,750 --> 00:06:55,889
a un método siempre le hemos pasado

148
00:06:55,889 --> 00:06:58,110
por parámetro datos, punto pelota

149
00:06:58,110 --> 00:07:00,189
datos, y normalmente siempre

150
00:07:00,189 --> 00:07:01,990
en general, pues esa es la idea

151
00:07:01,990 --> 00:07:03,970
con la que programamos, a un método se le pasan

152
00:07:03,970 --> 00:07:05,750
datos, ese método

153
00:07:05,750 --> 00:07:08,009
coge datos y opera

154
00:07:08,009 --> 00:07:09,290
con ellos y me da resultados

155
00:07:09,290 --> 00:07:12,209
vale, pues la programación funcional

156
00:07:12,209 --> 00:07:13,470
te dice, oye

157
00:07:13,470 --> 00:07:15,470
¿y por qué no un comportamiento

158
00:07:15,470 --> 00:07:17,490
o lo que es lo mismo una lista de acciones

159
00:07:17,490 --> 00:07:20,670
porque eso no podría ser también

160
00:07:20,670 --> 00:07:23,189
un dato que pasarle a otro

161
00:07:23,189 --> 00:07:25,329
es decir

162
00:07:25,329 --> 00:07:28,189
yo le puedo pasar a un método

163
00:07:28,189 --> 00:07:30,910
una lista de cosas que tiene que hacer

164
00:07:30,910 --> 00:07:32,470
como si le pasara a otro método

165
00:07:32,470 --> 00:07:37,089
pues ese es el principio básico de la programación funcional

166
00:07:37,089 --> 00:07:40,209
que es una función, una lista de acciones

167
00:07:40,209 --> 00:07:42,029
un método, una lista de cosas

168
00:07:42,029 --> 00:07:44,089
también se puede ver como un dato

169
00:07:44,089 --> 00:07:46,009
también se puede ver como un dato

170
00:07:46,009 --> 00:07:48,389
y ese dato se lo puedo yo pasar

171
00:07:48,389 --> 00:07:49,629
a otro método

172
00:07:49,629 --> 00:07:51,829
y ese otro método

173
00:07:51,829 --> 00:07:53,930
usa eso

174
00:07:53,930 --> 00:07:55,329
que yo le he pasado ahí

175
00:07:55,329 --> 00:07:58,810
y hace lo que yo le he pasado aquí

176
00:07:58,810 --> 00:07:59,589
esa es la idea

177
00:07:59,589 --> 00:08:02,449
ahora hay que ver cómo se concreta

178
00:08:02,449 --> 00:08:03,329
eso en Java

179
00:08:03,329 --> 00:08:06,649
que es parecido a cualquier otro lenguaje

180
00:08:06,649 --> 00:08:08,689
pero la idea tiene que quedar clara

181
00:08:08,689 --> 00:08:10,790
que es una lista de acciones

182
00:08:10,790 --> 00:08:12,569
lo que para nosotros

183
00:08:12,569 --> 00:08:13,769
ha sido un método de toda la vida

184
00:08:13,769 --> 00:08:15,930
y lo que en general se llama función

185
00:08:15,930 --> 00:08:18,550
una lista de acciones tenemos que poder verla

186
00:08:18,550 --> 00:08:20,129
también como un posible dato

187
00:08:20,129 --> 00:08:21,509
todo él, un posible dato

188
00:08:21,509 --> 00:08:23,810
y como tal

189
00:08:23,810 --> 00:08:26,569
lo puedo yo pasar también como argumentos a métodos

190
00:08:26,569 --> 00:08:27,949
¿vale?

191
00:08:29,449 --> 00:08:29,970
entonces

192
00:08:29,970 --> 00:08:31,889
a un método le puedo pasar

193
00:08:31,889 --> 00:08:33,730
los datos de toda la vida

194
00:08:33,730 --> 00:08:36,470
un número, una cadena

195
00:08:36,470 --> 00:08:38,409
un objeto, los datos de toda la vida

196
00:08:38,409 --> 00:08:39,990
pero también le puedo pasar

197
00:08:39,990 --> 00:08:41,269
una lista de acciones

198
00:08:41,269 --> 00:08:43,129
también le puedo pasar una lista de acciones

199
00:08:43,129 --> 00:08:46,590
se abre un poco la filosofía

200
00:08:46,590 --> 00:08:49,929
bueno, pues esa sería la idea

201
00:08:49,929 --> 00:08:51,190
ahora, ¿cómo se concreta?

202
00:08:51,889 --> 00:08:52,870
vamos a intentar

203
00:08:52,870 --> 00:08:56,690
verlo de forma sencilla

204
00:08:56,690 --> 00:08:58,450
en un ejemplo sencillo

205
00:08:58,450 --> 00:08:59,830
a ver, bueno

206
00:08:59,830 --> 00:09:01,110
esto vamos a verlo ya

207
00:09:01,110 --> 00:09:08,269
en la pizarra

208
00:09:08,269 --> 00:09:10,330
en la esta, que se va a entender mejor

209
00:09:10,330 --> 00:09:18,590
vale, bueno, lo que he dicho

210
00:09:18,590 --> 00:09:19,149
hasta ahora

211
00:09:19,149 --> 00:09:22,330
aunque nos cueste

212
00:09:22,330 --> 00:09:24,509
de alguna manera a ver cómo se puede concretar eso

213
00:09:24,509 --> 00:09:26,470
de meter una lista de acciones

214
00:09:26,470 --> 00:09:28,009
como dato

215
00:09:28,009 --> 00:09:30,029
aunque nos cueste, entendemos la idea

216
00:09:30,029 --> 00:09:32,549
vale, vamos a ver cómo se concreta

217
00:09:32,549 --> 00:09:33,929
esto, a ver

218
00:09:33,929 --> 00:09:36,230
pues venga

219
00:09:36,230 --> 00:09:39,519
me voy a hacer aquí

220
00:09:39,519 --> 00:09:41,080
borro todo esto

221
00:09:41,080 --> 00:09:46,500
pues venga, me hago un proyecto normal y corriente

222
00:09:46,500 --> 00:09:52,019
no, porque no vamos a usar dependencias ni nada

223
00:09:52,019 --> 00:09:56,740
ejemplo

224
00:09:56,740 --> 00:09:59,179
interfaces funcionales

225
00:09:59,179 --> 00:10:00,039
vale

226
00:10:00,039 --> 00:10:08,309
bueno pues entonces lo primero que tenemos que pensar

227
00:10:08,309 --> 00:10:10,350
vale

228
00:10:10,350 --> 00:10:12,190
donde

229
00:10:12,190 --> 00:10:13,769
si yo tengo que meter

230
00:10:13,769 --> 00:10:15,850
toda una serie de acciones

231
00:10:15,850 --> 00:10:18,250
toda una serie de acciones en un

232
00:10:18,250 --> 00:10:20,190
dato de que

233
00:10:20,190 --> 00:10:21,570
tipo va a ser ese dato

234
00:10:21,570 --> 00:10:24,230
porque una cadena ya sabemos que va

235
00:10:24,230 --> 00:10:26,289
a un string, un número

236
00:10:26,289 --> 00:10:28,330
ya sabemos que va a un integer, a un double

237
00:10:28,330 --> 00:10:29,389
depende de lo que sea

238
00:10:29,389 --> 00:10:33,570
un objeto alumno, ya sabemos que va a la clase alumno

239
00:10:33,570 --> 00:10:35,929
que alguien habrá declarado, pero

240
00:10:35,929 --> 00:10:39,730
y un conjunto de instrucciones, eso a qué tipo

241
00:10:39,730 --> 00:10:42,289
de objeto va, porque si es un dato también como tal

242
00:10:42,289 --> 00:10:44,850
tendrá que ser declarado de una clase también

243
00:10:44,850 --> 00:10:48,610
si estamos diciendo que una serie de instrucciones

244
00:10:48,610 --> 00:10:51,149
también puede ser tratada como dato

245
00:10:51,149 --> 00:10:54,509
pues también tiene que poder pertenecer a alguna clase

246
00:10:54,509 --> 00:10:57,769
porque todos los datos pertenecen a clases, sea inter, sea alumno

247
00:10:57,769 --> 00:10:59,730
sea la que sea, pues a qué clase

248
00:10:59,730 --> 00:11:01,350
pertenece un montón de

249
00:11:01,350 --> 00:11:03,649
sentencias, bueno pues

250
00:11:03,649 --> 00:11:04,850
pertenece a

251
00:11:04,850 --> 00:11:07,750
algo que se ha tenido que programar como una

252
00:11:07,750 --> 00:11:09,450
cosa que se llama interfaz funcional

253
00:11:09,450 --> 00:11:11,450
las interfaces

254
00:11:11,450 --> 00:11:12,830
sabéis lo que son

255
00:11:12,830 --> 00:11:15,230
son clases con métodos vacíos

256
00:11:15,230 --> 00:11:17,690
esencialmente es eso, con métodos vacíos

257
00:11:17,690 --> 00:11:19,490
que están pensadas para que la gente las

258
00:11:19,490 --> 00:11:21,549
implemente y ya

259
00:11:21,549 --> 00:11:22,870
de cuerpo esos métodos

260
00:11:22,870 --> 00:11:25,929
vale, pues no vamos a hacer una interfaz con un método vacío

261
00:11:25,929 --> 00:11:34,679
venga, nos hacemos

262
00:11:34,679 --> 00:11:39,080
una interfaz con un método vacío, vale, pues esta interfaz

263
00:11:39,080 --> 00:11:44,620
se va a llamar operar, vale, porque estamos ligando

264
00:11:44,620 --> 00:11:47,840
con el ejemplo este nuestro de calculadora, en el cual

265
00:11:47,840 --> 00:11:51,039
lo que le queremos pasar a nuestra calculadora es una serie

266
00:11:51,039 --> 00:11:54,700
de instrucciones que tiene que hacer en el método suyo operar,

267
00:11:54,759 --> 00:11:58,299
el que sea, entonces esa serie de instrucciones que van a ser

268
00:11:58,299 --> 00:12:02,039
la operación que tiene que hacer, la queremos guardar

269
00:12:02,039 --> 00:12:04,620
como objeto, tendremos que declarar

270
00:12:04,620 --> 00:12:06,759
una clase, bueno, pues entonces

271
00:12:06,759 --> 00:12:08,120
yo me declaro una interfaz

272
00:12:08,120 --> 00:12:10,399
que la voy a llamar

273
00:12:10,399 --> 00:12:10,919
operar

274
00:12:10,919 --> 00:12:13,840
vale, a ver, como no he puesto

275
00:12:13,840 --> 00:12:15,580
un paquete, perdón

276
00:12:15,580 --> 00:12:24,379
vale, pues yo que sé, ahora ya sí

277
00:12:24,379 --> 00:12:25,820
me hago mi interfaz

278
00:12:25,820 --> 00:12:27,940
operar

279
00:12:27,940 --> 00:12:36,080
vale, entonces

280
00:12:36,080 --> 00:12:37,980
a esta

281
00:12:37,980 --> 00:12:40,120
interfaz le voy a poner un método

282
00:12:40,120 --> 00:12:41,419
vacío, abierto

283
00:12:41,419 --> 00:12:44,240
por ejemplo este

284
00:12:44,240 --> 00:12:47,059
opera

285
00:12:47,059 --> 00:13:02,960
un método vacío

286
00:13:02,960 --> 00:13:06,250
bueno

287
00:13:06,250 --> 00:13:09,070
pues resulta

288
00:13:09,070 --> 00:13:10,429
que una interfaz

289
00:13:10,429 --> 00:13:13,289
que tiene un único

290
00:13:13,289 --> 00:13:14,309
método

291
00:13:14,309 --> 00:13:16,470
sin declarar

292
00:13:16,470 --> 00:13:19,049
es lo que se llama una interfaz funcional

293
00:13:19,049 --> 00:13:21,070
vale

294
00:13:21,070 --> 00:13:23,110
si esta interfaz tuviera más

295
00:13:23,110 --> 00:13:24,809
métodos vacíos

296
00:13:24,809 --> 00:13:26,850
sería una interfaz normal y corriente

297
00:13:26,850 --> 00:13:28,950
pero no sería una interfaz funcional, es el primer

298
00:13:28,950 --> 00:13:30,889
punto, ahora veremos para qué me

299
00:13:30,889 --> 00:13:32,929
sirve que sea funcional y para qué no me sirve

300
00:13:32,929 --> 00:13:33,870
¿vale?

301
00:13:35,070 --> 00:13:35,590
entonces

302
00:13:35,590 --> 00:13:38,789
una interfaz aparte de

303
00:13:38,789 --> 00:13:40,690
métodos vacíos, uno o muchos

304
00:13:40,690 --> 00:13:41,990
si recordáis

305
00:13:41,990 --> 00:13:44,909
de interfaces, puede tener

306
00:13:44,909 --> 00:13:47,110
métodos con declaraciones por defecto

307
00:13:47,110 --> 00:13:48,629
los que tiene el default

308
00:13:48,629 --> 00:13:50,769
delante, ¿vale? una interfaz

309
00:13:50,769 --> 00:13:52,190
podría tener

310
00:13:52,190 --> 00:13:54,389
un método

311
00:13:54,389 --> 00:13:56,769
¿no? pues yo que

312
00:13:56,769 --> 00:13:58,730
ser cualquier cosa, un método

313
00:13:58,730 --> 00:13:59,429
cualquiera

314
00:13:59,429 --> 00:14:02,409
que hiciera cualquier cosa

315
00:14:02,409 --> 00:14:14,580
vale, esto también lo

316
00:14:14,580 --> 00:14:15,919
admitían las interfaces

317
00:14:15,919 --> 00:14:18,500
también lo admitían, implementaciones por

318
00:14:18,500 --> 00:14:19,679
defecto, vale

319
00:14:19,679 --> 00:14:22,539
entonces esta seguiría siendo una interfaz

320
00:14:22,539 --> 00:14:24,519
funcional, porque sólo

321
00:14:24,519 --> 00:14:26,360
tiene un método abierto

322
00:14:26,360 --> 00:14:27,740
vacío, sólo tiene uno

323
00:14:27,740 --> 00:14:29,820
esta seguiría siendo una interfaz funcional

324
00:14:29,820 --> 00:14:32,279
vale, puede tener muchas

325
00:14:32,279 --> 00:14:34,600
implementaciones por defecto de otros

326
00:14:34,600 --> 00:14:36,600
o puede tener métodos estáticos

327
00:14:36,600 --> 00:14:38,820
recordad que las interfaces también pueden tener

328
00:14:38,820 --> 00:14:39,759
métodos estáticos

329
00:14:39,759 --> 00:14:42,559
¿vale? que el uso

330
00:14:42,559 --> 00:14:44,779
es, pues yo meto ahí código

331
00:14:44,779 --> 00:14:46,720
relacionado con el concepto que se llama

332
00:14:46,720 --> 00:14:48,860
interfaz y lo puedo llamar directamente con el nombre

333
00:14:48,860 --> 00:14:50,879
de interfaz, operar punto, ese método estático

334
00:14:50,879 --> 00:14:52,840
y ya está, los métodos estáticos

335
00:14:52,840 --> 00:14:54,419
sí que tienen que tener cuerpo obligatorio

336
00:14:54,419 --> 00:14:55,879
¿vale? en las interfaces

337
00:14:55,879 --> 00:14:59,019
bueno, pues entonces, tenga lo que

338
00:14:59,019 --> 00:15:01,000
tenga, este que no me sirve

339
00:15:01,000 --> 00:15:02,460
para nada lo quito, tenga lo que tenga

340
00:15:02,460 --> 00:15:04,759
si la interfaz que yo he hecho tiene un único

341
00:15:04,759 --> 00:15:06,620
método vacío, como es el caso

342
00:15:06,620 --> 00:15:08,799
se convierte en interfaz funcional

343
00:15:08,799 --> 00:15:10,779
muy bien, vale, pues ya está

344
00:15:10,779 --> 00:15:12,840
hasta ahora lo único que hemos hecho es cambiarle

345
00:15:12,840 --> 00:15:14,980
la etiqueta, el nombre, se llama interfaz funcional

346
00:15:14,980 --> 00:15:16,500
mira, pues que bien, se llama interfaz funcional

347
00:15:16,500 --> 00:15:17,879
vale

348
00:15:17,879 --> 00:15:20,360
aunque no es obligatorio

349
00:15:20,360 --> 00:15:23,120
a las interfaces funcionales

350
00:15:23,120 --> 00:15:24,980
conviene anotarlas

351
00:15:25,539 --> 00:15:27,399
con esta

352
00:15:27,399 --> 00:15:28,179
anotación

353
00:15:28,179 --> 00:15:37,600
la he escrito mal, funcional

354
00:15:37,600 --> 00:15:39,419
interface

355
00:15:39,419 --> 00:15:40,879
ahora está bien escrita, vale

356
00:15:40,879 --> 00:15:42,860
no es obligatorio

357
00:15:42,860 --> 00:15:46,100
lo que pasa es que en mi aplicación

358
00:15:46,100 --> 00:15:47,940
las que yo tenga como funcionales

359
00:15:47,940 --> 00:15:49,960
que las tendré por alguna razón en particular

360
00:15:49,960 --> 00:15:51,779
si las tengo anotadas mejor

361
00:15:51,779 --> 00:15:53,080
le estoy dando más

362
00:15:53,080 --> 00:15:56,139
más descripción

363
00:15:56,139 --> 00:15:57,139
a toda mi aplicación

364
00:15:57,139 --> 00:15:59,519
aparte tiene otra ventaja, anotarla

365
00:15:59,519 --> 00:16:02,000
que si yo de repente me equivoco

366
00:16:02,000 --> 00:16:04,159
estoy cambiando código, refactorizando código

367
00:16:04,159 --> 00:16:05,379
me equivoco

368
00:16:05,379 --> 00:16:07,320
y pongo aquí otro método vacío

369
00:16:07,320 --> 00:16:10,220
automáticamente se me va a poner esto en rojo

370
00:16:10,220 --> 00:16:13,639
Porque va a decir, oye, tú no eres una interfaz funcional

371
00:16:13,639 --> 00:16:16,940
Si yo me equivoco y pongo aquí otro método cualquiera

372
00:16:16,940 --> 00:16:17,919
Porque me he equivocado

373
00:16:17,919 --> 00:16:21,419
Pues automáticamente me salta el compilador

374
00:16:21,419 --> 00:16:25,879
Y me dice, perdona, me acabas de decir que tú eres una interfaz funcional

375
00:16:25,879 --> 00:16:27,220
Te has comprometido a ello

376
00:16:27,220 --> 00:16:30,000
No te pongas a plantar otros métodos

377
00:16:30,000 --> 00:16:33,159
Sin embargo, si yo no hubiera puesto esta anotación

378
00:16:33,159 --> 00:16:36,320
Aquí el compilador no me avisa

379
00:16:36,320 --> 00:16:39,379
Y a lo mejor yo he puesto este segundo método porque me he equivocado

380
00:16:39,379 --> 00:16:41,700
y no tengo ese primer

381
00:16:41,700 --> 00:16:42,820
aviso del compilador.

382
00:16:43,779 --> 00:16:44,220
¿Vale?

383
00:16:44,960 --> 00:16:46,899
Y puede ser que yo sí que necesite

384
00:16:46,899 --> 00:16:48,980
que sea funcional. ¿Por qué? Pues por lo que vamos a ver

385
00:16:48,980 --> 00:16:51,019
ahora. Vale, pues bueno.

386
00:16:55,759 --> 00:16:57,100
Si tienes el default delante,

387
00:16:57,220 --> 00:16:58,700
sí. Si no, no.

388
00:16:59,580 --> 00:17:03,889
¿Vale? Da una

389
00:17:03,889 --> 00:17:05,990
implementación por defecto para esos métodos.

390
00:17:06,069 --> 00:17:08,210
Y si las clases que implementan la interfaz

391
00:17:08,210 --> 00:17:10,009
no lo sobrescriben, se quedarían con

392
00:17:10,009 --> 00:17:11,329
esa implementación por defecto.

393
00:17:12,450 --> 00:17:13,869
Muy peligroso que haya

394
00:17:13,869 --> 00:17:16,029
métodos default en las interfaces, porque

395
00:17:16,029 --> 00:17:18,089
le estás dando comportamiento a gente

396
00:17:18,089 --> 00:17:20,029
que te implementa que a lo mejor no lo

397
00:17:20,029 --> 00:17:21,930
quieren. Entonces

398
00:17:21,930 --> 00:17:23,750
es algo muy peligroso

399
00:17:23,750 --> 00:17:25,849
porque en una aplicación grande de repente

400
00:17:25,849 --> 00:17:27,690
tú incorporas una entidad nueva

401
00:17:27,690 --> 00:17:29,509
que implemente esa interfaz

402
00:17:29,509 --> 00:17:31,869
y te has quedado con todos

403
00:17:31,869 --> 00:17:33,910
sus defaults y realmente no

404
00:17:33,910 --> 00:17:35,829
sabes que tiene ahí. Entonces vete a

405
00:17:35,829 --> 00:17:37,990
saber el efecto secundario que puede generar

406
00:17:37,990 --> 00:17:39,910
eso. Entonces los defaults se ponen

407
00:17:39,910 --> 00:17:41,869
solo cuando realmente se

408
00:17:41,869 --> 00:17:43,190
sabe que eso no va a perjudicar

409
00:17:43,190 --> 00:17:45,769
a ampliaciones de la aplicación ni a nada.

410
00:17:46,029 --> 00:18:11,809
Bueno, pues en nuestro caso, esta es nuestra interfaz funcional, vale, ahora, pues esta es la clase a la que ahora puede pertenecer cualquier tipo de sentencias que signifiquen opera, es decir, yo ahora puedo hacer sumas, restas, multiplicaciones, lo que yo quiera, todo el código que quiera,

411
00:18:11,809 --> 00:18:13,430
y todo ese código

412
00:18:13,430 --> 00:18:15,789
lo voy a poder declarar

413
00:18:15,789 --> 00:18:17,470
de la clase operar

414
00:18:17,470 --> 00:18:19,710
¿cómo? vamos a verlo

415
00:18:19,710 --> 00:18:22,960
¿vale? pero repito

416
00:18:22,960 --> 00:18:25,140
el haber declarado esta

417
00:18:25,140 --> 00:18:27,440
interfaz funcional me permite

418
00:18:27,440 --> 00:18:27,880
ahora

419
00:18:27,880 --> 00:18:31,000
meter un método

420
00:18:31,000 --> 00:18:32,640
meter sentencias

421
00:18:32,640 --> 00:18:34,480
como dato

422
00:18:34,480 --> 00:18:37,119
y su tipo de dato va a ser

423
00:18:37,119 --> 00:18:38,400
el tipo de dato operar

424
00:18:38,400 --> 00:18:41,059
vamos a verlo ahora

425
00:18:41,059 --> 00:18:42,960
entonces me voy a hacer aquí

426
00:18:42,960 --> 00:19:06,559
yo que sé, un main, vale

427
00:19:06,559 --> 00:19:08,680
pues resulta que yo quiero definir

428
00:19:08,680 --> 00:19:09,440
una operación

429
00:19:09,440 --> 00:19:12,420
pero la quiero definir como dato

430
00:19:12,420 --> 00:19:14,640
es decir

431
00:19:14,640 --> 00:19:16,299
quiero un conjunto de sentencias

432
00:19:16,299 --> 00:19:18,099
meterlas como dato

433
00:19:18,099 --> 00:19:20,740
para que se queden ahí como dato, para pasarlas

434
00:19:20,740 --> 00:19:21,480
luego a otro sitio

435
00:19:21,480 --> 00:19:24,660
vale, pues ese conjunto de sentencias

436
00:19:24,660 --> 00:19:26,740
las voy a poder meter

437
00:19:26,740 --> 00:19:27,859
como dato

438
00:19:27,859 --> 00:19:31,099
imaginaos que hay en secuencia

439
00:19:31,099 --> 00:19:31,940
operaciones

440
00:19:31,940 --> 00:19:34,079
las voy a poder meter

441
00:19:34,079 --> 00:19:36,579
como dato en un objeto

442
00:19:36,579 --> 00:19:38,519
de este tipo, del tipo

443
00:19:38,519 --> 00:19:39,880
interfaz funcional que está aquí

444
00:19:39,880 --> 00:19:45,160
y ahora la pregunta sería

445
00:19:45,160 --> 00:19:47,079
vale, muy bien, ya tengo un objeto

446
00:19:47,079 --> 00:19:49,339
declarado del tipo operar

447
00:19:49,339 --> 00:19:51,619
este objeto

448
00:19:51,619 --> 00:19:53,299
no está pensado para

449
00:19:53,299 --> 00:19:54,740
contener datos como tal

450
00:19:54,740 --> 00:19:57,440
no está pensado para contener números

451
00:19:57,440 --> 00:19:58,599
cadenas, no

452
00:19:58,599 --> 00:20:00,160
este objeto

453
00:20:00,160 --> 00:20:02,539
por pertenecer a una clase

454
00:20:02,539 --> 00:20:04,079
interfaz funcional

455
00:20:04,079 --> 00:20:05,900
está pensado para

456
00:20:05,900 --> 00:20:08,019
contener una secuencia de acciones

457
00:20:08,019 --> 00:20:09,500
ahora

458
00:20:09,500 --> 00:20:11,039
¿qué secuencia de acciones?

459
00:20:11,759 --> 00:20:13,619
se definen en la instanciación

460
00:20:13,619 --> 00:20:15,480
entonces

461
00:20:15,480 --> 00:20:18,319
aquí uno diría

462
00:20:18,319 --> 00:20:19,299
vale, pero espérate

463
00:20:19,299 --> 00:20:21,880
¿cómo instancio yo esto? no puedo hacer

464
00:20:21,880 --> 00:20:23,839
un new operar, porque operar

465
00:20:23,839 --> 00:20:25,720
es una interfaz y las interfaces ya sabemos

466
00:20:25,720 --> 00:20:27,720
que no se pueden instanciar, no tienen

467
00:20:27,720 --> 00:20:29,859
constructores, ¿cómo instancio

468
00:20:29,859 --> 00:20:31,819
yo ese objeto y le doy

469
00:20:31,819 --> 00:20:33,779
su valor? que su valor

470
00:20:33,779 --> 00:20:35,339
va a ser toda una lista de sentencias

471
00:20:35,339 --> 00:20:37,799
hemos quedado, bueno pues entonces

472
00:20:37,799 --> 00:20:39,819
¿qué tengo que hacer yo?

473
00:20:39,940 --> 00:20:41,339
pues antes de instanciarlo

474
00:20:41,339 --> 00:20:43,500
tenemos que crearnos

475
00:20:43,500 --> 00:20:45,180
una clase

476
00:20:45,180 --> 00:20:46,980
que implemente esta

477
00:20:46,980 --> 00:20:48,700
y que ahora ya

478
00:20:48,700 --> 00:20:51,940
meta ese conjunto de sentencias

479
00:20:51,940 --> 00:20:54,059
en la implementación

480
00:20:54,059 --> 00:20:54,740
de este método

481
00:20:54,740 --> 00:20:57,680
es decir

482
00:20:57,680 --> 00:20:59,740
vamos ahora a crearme yo

483
00:20:59,740 --> 00:21:00,559
una clase aquí

484
00:21:00,559 --> 00:21:04,690
por ejemplo sumar

485
00:21:04,690 --> 00:21:10,410
Porque yo ahora quiero implementar esa lista de operaciones como sumar.

486
00:21:10,509 --> 00:21:18,150
Pues venga, new, me hago una clase, sumar.

487
00:21:19,410 --> 00:21:25,130
Esta clase sumar implementa, implements, operar.

488
00:21:31,509 --> 00:21:40,089
Vale, al implementar operar no le queda más remedio que implementar el método que tiene la interfaz funcional, el único que tiene.

489
00:21:40,509 --> 00:21:42,809
Ahí viene la importancia de que sea solo uno.

490
00:21:44,769 --> 00:21:56,789
Bueno, pues es aquí, es aquí, donde yo ya decido qué sentencias quiero que se metan en el objeto que voy a instanciar aquí.

491
00:21:59,480 --> 00:22:00,980
Esto es un poco lio, pero lo repetimos.

492
00:22:02,119 --> 00:22:05,619
Venga, pues a ver, ¿qué quiero yo hacer en este objeto?

493
00:22:05,619 --> 00:22:11,200
Pues lo que yo quiero hacer es sumar, es solo una sentencia, podrían ser mil, pero es solo una.

494
00:22:12,019 --> 00:22:16,140
Retuno operación 1, 1 más operación 2.

495
00:22:16,599 --> 00:22:19,119
Podría ser un código mucho más largo

496
00:22:19,119 --> 00:22:20,700
¿Vale? Podría ser un código larguísimo

497
00:22:20,700 --> 00:22:34,269
Vale, pues ahora que ya tengo esta clase

498
00:22:34,269 --> 00:22:35,869
Yo ahora ya puedo hacer esto

499
00:22:35,869 --> 00:22:38,029
Igual a new

500
00:22:38,029 --> 00:22:40,170
Sumar

501
00:22:40,170 --> 00:22:42,250
Esto ya lo puedo hacer

502
00:22:42,250 --> 00:22:47,799
¿Verdad? Porque sumar

503
00:22:47,799 --> 00:22:49,240
Implemento a operar, luego esto

504
00:22:49,240 --> 00:22:50,400
Esta línea

505
00:22:50,400 --> 00:22:53,940
Ahora mismo es como hemos hecho siempre

506
00:22:53,940 --> 00:22:54,619
Pero no nos han gustado

507
00:22:54,619 --> 00:22:57,759
¿Vale? ¿Pero qué es lo que hay debajo de esto?

508
00:22:58,519 --> 00:22:59,700
Pues lo que hay debajo de esto

509
00:22:59,700 --> 00:23:01,420
es lo que es realmente importante

510
00:23:01,420 --> 00:23:03,759
porque ahora nos va a permitir usarlo

511
00:23:03,759 --> 00:23:05,240
y es, lo que hay debajo de esto es

512
00:23:05,240 --> 00:23:07,319
oye, este objeto

513
00:23:07,319 --> 00:23:09,779
es un dato en realidad

514
00:23:09,779 --> 00:23:11,539
es un dato, porque es un dato que

515
00:23:11,539 --> 00:23:12,880
pertenece a una clase, es un dato

516
00:23:12,880 --> 00:23:15,039
pero que tiene dentro

517
00:23:15,039 --> 00:23:17,740
este dato, no tiene

518
00:23:17,740 --> 00:23:19,460
dentro números

519
00:23:19,460 --> 00:23:21,299
cadenas

520
00:23:21,299 --> 00:23:24,160
como un alumno que tiene número de matrícula

521
00:23:24,160 --> 00:23:25,460
profesores, no

522
00:23:25,460 --> 00:23:27,559
lo que tiene dentro este dato

523
00:23:27,559 --> 00:23:29,640
es esto

524
00:23:29,640 --> 00:23:31,799
lo que yo haya puesto en este método

525
00:23:31,799 --> 00:23:33,859
eso es lo que tiene

526
00:23:33,859 --> 00:23:35,940
luego

527
00:23:35,940 --> 00:23:37,599
cualquier dato que uno declare

528
00:23:37,599 --> 00:23:39,680
cuyo tipo de datos

529
00:23:39,680 --> 00:23:40,980
sea una interfaz funcional

530
00:23:40,980 --> 00:23:43,960
no tiene dentro datos como los entendemos

531
00:23:43,960 --> 00:23:44,500
hasta ahora

532
00:23:44,500 --> 00:23:48,019
pues color de ojos

533
00:23:48,019 --> 00:23:49,240
altura, no sé qué

534
00:23:49,240 --> 00:23:51,059
no tiene datos como entendemos hasta ahora

535
00:23:51,059 --> 00:23:53,119
cualquier objeto declarado

536
00:23:53,119 --> 00:23:54,880
como una interfaz funcional

537
00:23:54,880 --> 00:23:56,920
lo que tiene dentro es

538
00:23:56,920 --> 00:23:59,160
una lista de sentencias

539
00:23:59,160 --> 00:24:01,460
que en ese caso son las sentencias

540
00:24:01,460 --> 00:24:03,380
que están implementando

541
00:24:03,380 --> 00:24:05,140
el único método

542
00:24:05,140 --> 00:24:06,660
que este tiene vacío

543
00:24:06,660 --> 00:24:09,339
de ahí la importancia de que

544
00:24:09,339 --> 00:24:11,299
solo haya un método vacío en la interfaz

545
00:24:11,299 --> 00:24:13,400
funcional, porque en ese único método

546
00:24:13,400 --> 00:24:15,380
vacío es donde se van

547
00:24:15,380 --> 00:24:17,200
a implementar esas instrucciones

548
00:24:17,200 --> 00:24:19,640
que son las que son el verdadero

549
00:24:19,640 --> 00:24:21,259
dato, el verdadero

550
00:24:21,259 --> 00:24:22,299
dato de este objeto

551
00:24:22,299 --> 00:24:23,960
¿vale?

552
00:24:24,819 --> 00:24:26,799
entonces este objeto es de tipo operar

553
00:24:26,799 --> 00:24:29,059
luego automáticamente como operar es una

554
00:24:29,059 --> 00:24:30,980
interfaz funcional, tenemos que verlo

555
00:24:30,980 --> 00:24:32,759
como que no es un dato cualquiera

556
00:24:32,759 --> 00:24:34,519
sino que es una secuencia de instrucciones

557
00:24:34,519 --> 00:24:37,220
vale, esa secuencia

558
00:24:37,220 --> 00:24:38,240
de instrucciones de donde sale

559
00:24:38,240 --> 00:24:40,960
de la implementación que yo he usado para

560
00:24:40,960 --> 00:24:43,119
generarlo, la implementación

561
00:24:43,119 --> 00:24:44,759
que yo he usado para generarlo es sumar

562
00:24:44,759 --> 00:24:47,160
que tiene sumar, tiene esto

563
00:24:47,160 --> 00:24:48,839
vale, muy bien

564
00:24:48,839 --> 00:24:53,500
vale, entonces podría haber otra implementación

565
00:24:53,500 --> 00:24:55,359
por ejemplo, vamos a hacernos multiplicar

566
00:24:55,359 --> 00:24:57,859
Nos hacemos aquí

567
00:24:57,859 --> 00:25:01,180
Una nueva clase

568
00:25:01,180 --> 00:25:04,380
Multiplicar

569
00:25:04,380 --> 00:25:05,660
Vale

570
00:25:05,660 --> 00:25:08,619
Multiplicar va a ser

571
00:25:08,619 --> 00:25:10,779
Otra posible implementación

572
00:25:10,779 --> 00:25:11,900
De mi interfaz funcional

573
00:25:11,900 --> 00:25:13,319
Implements

574
00:25:13,319 --> 00:25:16,819
Multiplicar implementa operar

575
00:25:16,819 --> 00:25:19,019
Al implementar

576
00:25:19,019 --> 00:25:20,660
Operar tiene que implementar el método

577
00:25:20,660 --> 00:25:25,710
Bueno pues aquí lo que a mi me de la gana

578
00:25:25,710 --> 00:25:27,509
En este caso

579
00:25:27,509 --> 00:25:29,329
pues es una sola sentencia

580
00:25:29,329 --> 00:25:30,250
podría ser mil

581
00:25:30,250 --> 00:25:33,289
retuno op1

582
00:25:33,289 --> 00:25:34,390
por op2

583
00:25:34,390 --> 00:25:36,750
ala tan ricamente

584
00:25:36,750 --> 00:25:39,390
entonces podría tener

585
00:25:39,390 --> 00:25:41,230
vale

586
00:25:41,230 --> 00:25:42,869
multiplicar ha implementado eso

587
00:25:42,869 --> 00:25:45,190
ahora ya en mi main por ejemplo

588
00:25:45,190 --> 00:25:47,289
secuencia suma voy a poner

589
00:25:47,289 --> 00:25:49,289
aquí operar suma la voy a cambiar

590
00:25:49,289 --> 00:25:50,069
a llamar suma

591
00:25:50,069 --> 00:25:53,609
operar suma

592
00:25:53,609 --> 00:25:54,970
pues voy a hacerme otro

593
00:25:54,970 --> 00:25:57,369
operar multiplica

594
00:25:57,369 --> 00:26:05,329
igual a new multiplicar

595
00:26:05,329 --> 00:26:10,839
vale, pues estos son

596
00:26:10,839 --> 00:26:12,980
dos objetos, el objeto suma

597
00:26:12,980 --> 00:26:14,119
y el objeto multiplica

598
00:26:14,119 --> 00:26:16,900
¿qué es lo que tienen dentro esos objetos?

599
00:26:17,099 --> 00:26:17,779
¿cuál es su dato?

600
00:26:18,599 --> 00:26:19,880
pues el objeto suma

601
00:26:19,880 --> 00:26:21,660
lo que tiene dentro es

602
00:26:21,660 --> 00:26:25,079
esta secuencia de instrucciones

603
00:26:25,079 --> 00:26:26,180
esa es la que tiene dentro

604
00:26:26,180 --> 00:26:30,809
¿qué tiene dentro el objeto multiplica?

605
00:26:31,509 --> 00:26:32,750
pues lo que tiene dentro el objeto

606
00:26:32,750 --> 00:26:33,910
multiplica es

607
00:26:33,910 --> 00:26:36,769
esta lista de instrucciones, es lo que tiene dentro

608
00:26:36,769 --> 00:26:37,549
¿vale?

609
00:26:37,769 --> 00:26:39,930
luego ya hemos hecho la primera parte

610
00:26:39,930 --> 00:26:41,390
que es crear objetos

611
00:26:41,390 --> 00:26:44,029
que lo que tienen dentro son secuencias

612
00:26:44,029 --> 00:26:46,309
de instrucciones, no datos como tal

613
00:26:46,309 --> 00:26:50,190
ahora habría que ver esto para que me sirve, como lo puedo usar

614
00:26:50,190 --> 00:26:59,490
bueno, vámonos a nuestra calculadora

615
00:26:59,490 --> 00:27:04,470
lo estoy haciendo todo en el main

616
00:27:04,470 --> 00:27:05,890
por facilidad

617
00:27:05,890 --> 00:27:08,809
nuestra calculadora

618
00:27:08,809 --> 00:27:10,650
me hago yo ahora aquí

619
00:27:10,650 --> 00:27:11,970
mi clase calculadora

620
00:27:11,970 --> 00:27:14,390
calculadora

621
00:27:14,390 --> 00:27:21,759
vale, mi clase calculadora va a operar

622
00:27:21,759 --> 00:27:28,460
vale, pues que le voy a pasar

623
00:27:28,460 --> 00:27:31,259
yo a mi calculadora, le voy a pasar directamente

624
00:27:31,259 --> 00:27:34,680
lo que tienes que hacer, no le paso los datos

625
00:27:34,680 --> 00:27:37,559
la operación en forma de string

626
00:27:37,559 --> 00:27:40,799
y luego ella lo saca de dentro y ya se pone a hacer cosas

627
00:27:40,799 --> 00:27:43,339
no, te paso la operación

628
00:27:43,339 --> 00:27:46,039
tal cual, vale, luego te voy a pasar

629
00:27:46,039 --> 00:27:48,380
algún objeto de tipo operar

630
00:27:48,380 --> 00:27:50,279
Esto es lo que te voy a pasar

631
00:27:50,279 --> 00:27:52,420
¿Vale?

632
00:27:52,519 --> 00:27:54,099
Algún objeto de tipo operar

633
00:27:54,099 --> 00:27:57,539
¿Y tú qué vas a hacer?

634
00:27:58,180 --> 00:28:00,059
Pues vas a llamar al método

635
00:28:00,059 --> 00:28:00,859
Opera

636
00:28:00,859 --> 00:28:03,700
De eso de ahí

637
00:28:03,700 --> 00:28:06,140
¿Vale? Y me lo vas a devolver

638
00:28:06,140 --> 00:28:18,869
A ver

639
00:28:18,869 --> 00:28:20,970
¿Cómo se lo podemos pasar?

640
00:28:21,750 --> 00:28:22,230
Opera

641
00:28:22,230 --> 00:28:59,079
¿Vale? Pues entonces

642
00:28:59,079 --> 00:29:00,960
Aunque en este caso

643
00:29:00,960 --> 00:29:03,119
realmente era tan fácil como pasarle

644
00:29:03,119 --> 00:29:05,140
el simbolito y que con el símbolo decidiera

645
00:29:05,140 --> 00:29:06,440
con el if, con el else if

646
00:29:06,440 --> 00:29:08,000
pues es que

647
00:29:08,000 --> 00:29:10,059
ni siquiera hace falta

648
00:29:10,059 --> 00:29:12,900
yo llamo, mi calculadora tiene operar

649
00:29:12,900 --> 00:29:15,319
y le paso directamente

650
00:29:15,319 --> 00:29:17,140
la secuencia que tiene

651
00:29:17,140 --> 00:29:18,980
que hacer, se lo paso directamente

652
00:29:18,980 --> 00:29:21,279
le pasaría un objeto de tipo

653
00:29:21,279 --> 00:29:21,960
operar

654
00:29:21,960 --> 00:29:25,259
el que sea, y ese objeto llamará

655
00:29:25,259 --> 00:29:27,240
a opera, que tendrá lo que sea

656
00:29:27,240 --> 00:29:28,299
y

657
00:29:28,299 --> 00:29:30,940
estellará lo que sea con estos operandos

658
00:29:30,960 --> 00:29:35,440
entonces mi calculadora ahora cambiará

659
00:29:35,440 --> 00:29:37,319
y se declarará de esta manera

660
00:29:37,319 --> 00:29:39,259
¿vale? se declarará así

661
00:29:39,259 --> 00:29:41,660
y ahora

662
00:29:41,660 --> 00:29:42,460
¿cómo la uso yo?

663
00:29:44,019 --> 00:29:45,460
pues a ver este como

664
00:29:45,460 --> 00:29:47,920
vamos a ponerlo

665
00:29:47,920 --> 00:29:49,819
static, como los operandos se los estamos

666
00:29:49,819 --> 00:29:51,539
pasando, le ponemos

667
00:29:51,539 --> 00:29:53,599
static y ahora ya en mi

668
00:29:53,599 --> 00:29:55,059
main ¿vale?

669
00:29:55,579 --> 00:29:57,299
pues yo podría hacer por ejemplo

670
00:29:57,299 --> 00:30:00,619
calculadora

671
00:30:00,619 --> 00:30:03,000
punto opera

672
00:30:03,000 --> 00:30:06,039
le paso el objeto suma

673
00:30:06,039 --> 00:30:07,759
este

674
00:30:07,759 --> 00:30:10,980
y los operandos que sean

675
00:30:10,980 --> 00:30:20,980
que ahora

676
00:30:20,980 --> 00:30:24,200
quiero hacer una multiplicación

677
00:30:24,200 --> 00:30:27,619
operar

678
00:30:27,619 --> 00:30:29,220
le paso

679
00:30:29,220 --> 00:30:31,400
el objeto multiplica

680
00:30:31,400 --> 00:30:35,400
y lo que sea

681
00:30:35,400 --> 00:31:12,289
vale pues entonces

682
00:31:12,289 --> 00:31:13,230
mi calculadora

683
00:31:13,230 --> 00:31:15,950
está recibiendo dos datos estándar

684
00:31:15,950 --> 00:31:17,450
los de toda la vida, dos numeritos

685
00:31:17,450 --> 00:31:19,049
como podían ser cadenas, lo que fuera

686
00:31:19,049 --> 00:31:22,250
y además está recibiendo un objeto

687
00:31:22,250 --> 00:31:24,109
que lo que tiene dentro

688
00:31:24,109 --> 00:31:25,589
en realidad es

689
00:31:25,589 --> 00:31:27,589
toda una ristra de operaciones

690
00:31:27,589 --> 00:31:29,930
que en mi caso esa ristra

691
00:31:29,930 --> 00:31:31,470
en el caso de suma

692
00:31:31,470 --> 00:31:32,829
que sería este objeto

693
00:31:32,829 --> 00:31:35,690
esa ristra se reduce a esto

694
00:31:35,690 --> 00:31:39,700
y en el caso de

695
00:31:39,700 --> 00:31:40,799
este de aquí

696
00:31:40,799 --> 00:31:43,940
multiplica, lo que yo le estoy pasando

697
00:31:43,940 --> 00:31:44,440
es

698
00:31:44,440 --> 00:31:46,119
solamente esto

699
00:31:46,119 --> 00:31:48,240
op1 por op2

700
00:31:48,240 --> 00:31:50,619
pero lo que tenéis que ver

701
00:31:50,619 --> 00:31:51,799
en este ejemplo sencillo

702
00:31:51,799 --> 00:31:54,420
es que yo aquí a este método

703
00:31:54,420 --> 00:31:55,359
le estoy pasando

704
00:31:55,359 --> 00:31:58,539
de estos tres datos

705
00:31:58,539 --> 00:32:00,700
uno de ellos

706
00:32:00,700 --> 00:32:02,519
es un dato especial, porque uno de ellos

707
00:32:02,519 --> 00:32:04,640
no contiene cadenas, números

708
00:32:04,640 --> 00:32:06,900
objetos de toda la vida

709
00:32:06,900 --> 00:32:08,640
con propiedades dentro, no

710
00:32:08,640 --> 00:32:10,519
uno de ellos

711
00:32:10,519 --> 00:32:12,839
este lo que tiene es una secuencia

712
00:32:12,839 --> 00:32:14,460
de operaciones, no tiene datos

713
00:32:14,460 --> 00:32:16,339
tiene secuencia de operaciones

714
00:32:16,339 --> 00:32:19,279
luego la secuencia de operaciones

715
00:32:19,279 --> 00:32:21,039
también se pueden

716
00:32:21,039 --> 00:32:22,079
pasar como parámetro

717
00:32:22,079 --> 00:32:24,859
y esa es la idea de la programación funcional

718
00:32:24,859 --> 00:32:29,809
que se puede

719
00:32:29,809 --> 00:32:32,289
que se integra en el diseño de cualquier aplicación

720
00:32:32,289 --> 00:32:35,759
en realidad, vale, esa sería

721
00:32:35,759 --> 00:32:37,539
la primera parte, lo que quería

722
00:32:37,539 --> 00:32:38,579
que

723
00:32:38,579 --> 00:32:42,000
entiendo que no es fácil, es lioso

724
00:32:42,000 --> 00:32:44,019
porque implica

725
00:32:44,019 --> 00:32:45,259
muchos pasos

726
00:32:45,259 --> 00:32:47,680
tiene que existir una interfaz funcional

727
00:32:47,680 --> 00:32:49,660
obligatorio, con un método vacío

728
00:32:49,660 --> 00:32:52,319
en ese método vacío

729
00:32:52,319 --> 00:32:54,240
es donde en sus implementaciones

730
00:32:54,240 --> 00:32:56,200
en las implementaciones

731
00:32:56,200 --> 00:32:57,900
en todas las que haya, que pueda haber

732
00:32:57,900 --> 00:32:59,759
mil implementaciones distintas de operar

733
00:32:59,759 --> 00:33:02,180
pues en las implementaciones

734
00:33:02,180 --> 00:33:03,980
de operar, en las instancias

735
00:33:03,980 --> 00:33:05,839
de operar, es donde irá

736
00:33:05,839 --> 00:33:07,680
todo ese conjunto de sentencias

737
00:33:07,680 --> 00:33:10,099
que es el propio dato, el conjunto de sentencias

738
00:33:10,099 --> 00:33:12,279
en las una, dos, tres

739
00:33:12,279 --> 00:33:14,019
diez mil implementaciones de operar

740
00:33:14,019 --> 00:33:15,839
que yo quiera hacer, en cada una de ellas irá

741
00:33:15,839 --> 00:33:17,019
un conjunto de sentencias

742
00:33:17,019 --> 00:33:40,960
Y ese conjunto de sentencias es el dato. Y ahora yo ya, en esa implementación que he puesto ese conjunto de sentencias, una, dos o mil, este método podría ser muy largo, pues ese dato, que es este, esto ahora ya es, repito, esto es un conjunto de sentencias, no es un objeto normal.

743
00:33:40,960 --> 00:33:57,519
Es un conjunto de sentencias, este el conjunto de sentencias que están dentro de sumar y este el conjunto de sentencias que están dentro de multiplicar, pues estos dos conjuntos de sentencias pueden ser pasados a cualquier otro método, pueden ser pasados a cualquier otro.

744
00:33:57,519 --> 00:34:01,299
y ahora ese método

745
00:34:01,299 --> 00:34:03,460
que hará aquí el de calculadora

746
00:34:03,460 --> 00:34:05,380
en particular, pues claro, ese método

747
00:34:05,380 --> 00:34:06,940
lo que tiene que hacer es lógicamente

748
00:34:06,940 --> 00:34:07,759
llamar

749
00:34:07,759 --> 00:34:10,920
al método de la interfaz funcional

750
00:34:10,920 --> 00:34:13,159
claro, lo llama y actúa

751
00:34:13,159 --> 00:34:17,460
bueno, esta es

752
00:34:17,460 --> 00:34:18,380
la idea

753
00:34:18,380 --> 00:34:20,719
de la interfaz funcional y la motivación

754
00:34:20,719 --> 00:34:23,119
la arquitectura, ¿está más o menos

755
00:34:23,119 --> 00:34:23,880
claro y entendido?

756
00:34:25,119 --> 00:34:27,199
y ahora diréis, ¿y esto que tiene que ver con las

757
00:34:27,199 --> 00:34:29,199
landas? pues porque

758
00:34:29,199 --> 00:34:31,500
una lambda es una forma rápida

759
00:34:31,500 --> 00:34:33,199
de hacer una

760
00:34:33,199 --> 00:34:35,039
implementación, una instancia

761
00:34:35,039 --> 00:34:37,500
de una interfaz funcional, ahorrándose

762
00:34:37,500 --> 00:34:38,639
este paso que yo he hecho aquí

763
00:34:38,639 --> 00:34:40,760
que es declarando esta clase

764
00:34:40,760 --> 00:34:43,260
es decir, yo para crear

765
00:34:43,260 --> 00:34:44,360
aquí una instancia

766
00:34:44,360 --> 00:34:47,159
de operar adaptada a mis

767
00:34:47,159 --> 00:34:47,800
necesidades

768
00:34:47,800 --> 00:34:51,039
porque yo quería, oye quiero una instancia

769
00:34:51,039 --> 00:34:52,760
de operar que lo que haga sea sumar

770
00:34:52,760 --> 00:34:55,420
pues para crear una instancia de operar

771
00:34:55,420 --> 00:34:57,320
me he hecho una clase sumar

772
00:34:57,320 --> 00:34:58,519
que lo implemente

773
00:34:58,519 --> 00:35:00,179
he implementado el método

774
00:35:00,179 --> 00:35:02,739
vale, pues ya está, puedo trabajar así

775
00:35:02,739 --> 00:35:04,699
pero hombre, tener que estar

776
00:35:04,699 --> 00:35:06,400
creando clases

777
00:35:06,400 --> 00:35:08,679
todo el rato para cada conjunto

778
00:35:08,679 --> 00:35:10,280
de operaciones que queramos hacer

779
00:35:10,280 --> 00:35:12,760
cada vez que queramos crear

780
00:35:12,760 --> 00:35:14,519
uno de estos es un poco pesado

781
00:35:14,519 --> 00:35:16,239
entonces hay un atajo

782
00:35:16,239 --> 00:35:17,719
un atajo

783
00:35:17,719 --> 00:35:19,340
para darle

784
00:35:19,340 --> 00:35:22,099
contenido

785
00:35:22,099 --> 00:35:24,179
a las interfaces funcionales

786
00:35:24,179 --> 00:35:25,039
que es el de las lambdas

787
00:35:25,039 --> 00:35:27,599
entonces, ¿esto en qué se traduciría?

788
00:35:28,519 --> 00:35:31,199
por ejemplo

789
00:35:31,199 --> 00:35:36,559
este código en lugar de hacerlo así

790
00:35:36,559 --> 00:35:38,960
voy a intentar ahorrarme

791
00:35:38,960 --> 00:35:40,780
el tener que hacer el new sumar

792
00:35:40,780 --> 00:35:41,699
voy a intentar ahorrarme

793
00:35:41,699 --> 00:35:43,679
vale, pues venga

794
00:35:43,679 --> 00:35:46,039
operar suma

795
00:35:46,039 --> 00:35:48,059
y ahora

796
00:35:48,059 --> 00:35:49,400
¿cómo lo instancio?

797
00:35:49,840 --> 00:35:52,420
pues me puedo hacer una cosa que se llama función lambda

798
00:35:52,420 --> 00:35:54,519
que es meter ahí

799
00:35:54,519 --> 00:35:56,739
directamente el código que pensaba

800
00:35:56,739 --> 00:35:58,139
meter en el método de sumar

801
00:35:58,139 --> 00:36:00,440
el que pensaba meter en el método de sumar

802
00:36:00,440 --> 00:36:03,039
aquí lo dejo, tan apañado

803
00:36:03,039 --> 00:36:04,219
vale, ahí lo dejo

804
00:36:04,219 --> 00:36:06,940
ahí lo voy a meter

805
00:36:06,940 --> 00:36:09,239
ahí tan apañado

806
00:36:09,239 --> 00:36:11,159
vale, pero como lo meto

807
00:36:11,159 --> 00:36:12,639
alguna sintaxis tendré que seguir

808
00:36:12,639 --> 00:36:14,820
vale, o sea la idea

809
00:36:14,820 --> 00:36:16,360
repito de las landas es

810
00:36:16,360 --> 00:36:18,599
directamente poner aquí

811
00:36:18,599 --> 00:36:20,480
el código del método

812
00:36:20,480 --> 00:36:23,079
que yo he metido dentro de sumar

813
00:36:23,079 --> 00:36:24,920
y así me ahorro crear sumar

814
00:36:24,920 --> 00:36:26,219
lo entendéis, no?

815
00:36:26,780 --> 00:36:28,179
vale, pues como lo método

816
00:36:28,179 --> 00:36:33,719
la sintaxis

817
00:36:33,719 --> 00:36:35,400
de las famosas funciones lambda

818
00:36:35,400 --> 00:36:37,860
que es una forma compacta

819
00:36:37,860 --> 00:36:39,199
de expresar métodos

820
00:36:39,199 --> 00:36:40,719
¿y cómo se expresan?

821
00:36:41,239 --> 00:36:42,780
pues tiene dos partes

822
00:36:42,780 --> 00:36:45,699
separadas por este simbolito

823
00:36:45,699 --> 00:36:49,110
en la primera parte que se pone

824
00:36:49,110 --> 00:36:51,489
los parámetros de entrada

825
00:36:51,489 --> 00:36:52,489
del método

826
00:36:52,489 --> 00:36:55,170
que yo estoy declarando

827
00:36:55,170 --> 00:36:56,090
con la función lambda

828
00:36:56,090 --> 00:36:58,869
pues en este caso el método que yo quiero declarar

829
00:36:58,869 --> 00:37:00,250
tiene dos parámetros de entrada

830
00:37:00,250 --> 00:37:01,889
op1 y op2

831
00:37:01,889 --> 00:37:04,690
pues me pongo aquí x y

832
00:37:04,690 --> 00:37:07,010
los métodos separados por coma

833
00:37:07,010 --> 00:37:08,969
con el nombre que sea, ni tipo de dato ni nada

834
00:37:08,969 --> 00:37:10,829
recordad que lambda

835
00:37:10,829 --> 00:37:12,750
es para simplificar

836
00:37:12,750 --> 00:37:14,989
es hacer un atajo para declarar métodos

837
00:37:14,989 --> 00:37:16,730
directamente

838
00:37:16,730 --> 00:37:18,769
que sean datos de interfaces

839
00:37:18,769 --> 00:37:19,510
funcionales

840
00:37:19,510 --> 00:37:21,690
y ahora esta función lambda

841
00:37:21,690 --> 00:37:23,289
¿qué tiene que hacer?

842
00:37:23,730 --> 00:37:26,489
en este caso tiene que devolverme

843
00:37:26,489 --> 00:37:28,409
la suma de operando1

844
00:37:28,409 --> 00:37:30,030
operando 2, ¿vale?

845
00:37:30,730 --> 00:37:31,849
pues entonces

846
00:37:31,849 --> 00:37:35,369
retun op1

847
00:37:35,369 --> 00:37:37,170
más op2

848
00:37:37,170 --> 00:37:38,989
uy, perdón, x sí, perdón

849
00:37:38,989 --> 00:37:41,329
x más

850
00:37:41,329 --> 00:37:42,829
sí, vale

851
00:37:42,829 --> 00:37:46,949
y cuando son

852
00:37:46,949 --> 00:37:48,989
dos, se ponía entre

853
00:37:48,989 --> 00:37:51,110
paréntesis, ¿verdad

854
00:37:51,110 --> 00:37:51,630
que sí?

855
00:37:52,630 --> 00:37:54,269
sí, y ahora

856
00:37:54,269 --> 00:37:56,789
si tiene un retun

857
00:37:56,789 --> 00:37:58,710
así

858
00:37:58,710 --> 00:38:01,369
x más

859
00:38:01,369 --> 00:38:02,929
a ver, es que la sintaxis de

860
00:38:02,929 --> 00:38:04,489
funciones

861
00:38:04,489 --> 00:38:10,179
vale, a ver que me falta aquí

862
00:38:10,179 --> 00:38:12,579
insert, ah vale, que he puesto un return

863
00:38:12,579 --> 00:38:13,599
me faltaría esto

864
00:38:13,599 --> 00:38:19,880
vale, pues a ver

865
00:38:19,880 --> 00:38:23,079
ya me he hecho

866
00:38:23,079 --> 00:38:24,139
una función lambda

867
00:38:24,139 --> 00:38:26,300
vale, para

868
00:38:26,300 --> 00:38:33,429
entonces repito, una función lambda

869
00:38:33,429 --> 00:38:35,250
es una forma

870
00:38:35,250 --> 00:38:37,389
rápida de expresar

871
00:38:37,389 --> 00:38:39,010
el cuerpo de un método

872
00:38:39,010 --> 00:38:41,949
vale, pues entonces son dos partes

873
00:38:41,949 --> 00:38:43,309
separadas por este simbolito

874
00:38:43,309 --> 00:38:45,250
en la primera parte

875
00:38:45,250 --> 00:38:47,929
tiene los parámetros de entrada al método

876
00:38:47,929 --> 00:38:50,030
sin tipo de

877
00:38:50,030 --> 00:38:51,909
dato y sin nada, ¿por qué? porque eso

878
00:38:51,909 --> 00:38:52,889
se va a inferir

879
00:38:52,889 --> 00:38:55,110
de esta interfaz

880
00:38:55,110 --> 00:38:57,969
si yo a esta función lambda se la estoy asignando

881
00:38:57,969 --> 00:38:59,869
operar suma, es que ya se

882
00:38:59,869 --> 00:39:01,269
infiere, porque operar

883
00:39:01,269 --> 00:39:03,949
tiene int e int

884
00:39:03,949 --> 00:39:05,730
entonces ya se infiere, no los tengo que poner ahí

885
00:39:05,730 --> 00:39:11,000
vale, pues entonces

886
00:39:11,000 --> 00:39:12,739
si no

887
00:39:12,739 --> 00:39:15,119
si solo fuera uno, no hace falta

888
00:39:15,119 --> 00:39:17,280
poner paréntesis, pero bueno, todo eso son detalles

889
00:39:17,280 --> 00:39:19,480
de sintaxis

890
00:39:19,480 --> 00:39:20,260
de función lambda

891
00:39:20,260 --> 00:39:22,599
que se pueden consultar rápidamente

892
00:39:22,599 --> 00:39:24,920
vale, en la segunda parte

893
00:39:24,920 --> 00:39:27,219
si son seis, pues seis

894
00:39:27,219 --> 00:39:27,840
y para abajo el coma

895
00:39:27,840 --> 00:39:29,199
¿cómo se llamaría?

896
00:39:31,719 --> 00:39:33,000
a ver si es más de uno

897
00:39:33,000 --> 00:39:33,900
entre paréntesis

898
00:39:33,900 --> 00:39:37,360
x y z

899
00:39:37,360 --> 00:39:39,059
pepito pérez, comadita de la gana

900
00:39:39,059 --> 00:39:41,840
como tú quieras, lo único que no pones

901
00:39:41,840 --> 00:39:43,679
es el tipo de dato, porque es que ya se infiere

902
00:39:43,679 --> 00:39:44,719
de aquí, de esta interfaz

903
00:39:44,719 --> 00:39:47,059
y en la segunda parte

904
00:39:47,059 --> 00:39:49,579
pones el código del método

905
00:39:49,579 --> 00:39:51,639
y ya está, en este caso

906
00:39:51,639 --> 00:39:52,900
tiene que haber un return

907
00:39:52,900 --> 00:39:55,960
porque operar

908
00:39:55,960 --> 00:39:57,559
tiene aquí swing

909
00:39:57,559 --> 00:39:59,679
¿vale? entonces luego

910
00:39:59,679 --> 00:40:00,760
aquí ya hay diferentes

911
00:40:00,760 --> 00:40:03,360
como la idea de esto es simplificar

912
00:40:03,360 --> 00:40:05,480
ya hay diferentes cosas

913
00:40:05,480 --> 00:40:06,980
si solo hay una sentencia

914
00:40:06,980 --> 00:40:08,699
no hay que poner llaves

915
00:40:08,699 --> 00:40:11,500
si esa sentencia

916
00:40:11,500 --> 00:40:13,420
única tiene un retun

917
00:40:13,420 --> 00:40:14,780
el retun no hace falta

918
00:40:14,780 --> 00:40:17,480
yo aquí lo he puesto así para que

919
00:40:17,480 --> 00:40:18,179
se vea más claro

920
00:40:18,179 --> 00:40:21,699
entre llaves el código con las sentencias

921
00:40:21,699 --> 00:40:23,960
¿vale? pero esta en particular

922
00:40:23,960 --> 00:40:25,780
esta función lambda en particular

923
00:40:25,780 --> 00:40:27,440
se puede simplificar

924
00:40:27,440 --> 00:40:29,860
todavía más porque solo tiene una sentencia

925
00:40:29,860 --> 00:40:31,019
que además es la de retun

926
00:40:31,019 --> 00:40:33,800
entonces se pueden quitar las llaves y el retun incluso

927
00:40:33,800 --> 00:40:34,739
¿verdad que sí?

928
00:40:38,110 --> 00:40:38,670
también

929
00:40:38,670 --> 00:40:43,260
sí, ¿vale?

930
00:40:43,559 --> 00:41:05,090
O sea, si sólo tiene una sentencia, se puede quitar las llaves, si sólo tiene una. Si tiene más de una, llaves y separado por punto y coma, ¿vale? Y si esto te da un valor, ese valor no hace falta que le pongas el return, ya se sobreentiende que es el valor que devuelve el método opera de aquí.

931
00:41:05,090 --> 00:41:09,929
bueno, pues ya está

932
00:41:09,929 --> 00:41:11,909
con esto estoy diciendo

933
00:41:11,909 --> 00:41:13,110
oye, tú a operar

934
00:41:13,110 --> 00:41:17,989
quiero un objeto de esta instancia

935
00:41:17,989 --> 00:41:18,670
operar

936
00:41:18,670 --> 00:41:21,710
cuya implementación del método

937
00:41:21,710 --> 00:41:22,489
sea este

938
00:41:22,489 --> 00:41:24,269
y ya se lo paso aquí

939
00:41:24,269 --> 00:41:27,469
y aquí podría hacer lo mismo

940
00:41:27,469 --> 00:41:28,510
con el otro

941
00:41:28,510 --> 00:41:30,949
operar

942
00:41:30,949 --> 00:41:32,570
multiplica

943
00:41:32,570 --> 00:41:34,730
pues operar multiplica

944
00:41:34,730 --> 00:41:36,630
x y

945
00:41:36,630 --> 00:41:40,480
x por y

946
00:41:40,480 --> 00:41:45,010
¿Veis? Y ya me olvido

947
00:41:45,010 --> 00:41:46,989
de esta clase sumar

948
00:41:46,989 --> 00:41:48,929
de esta clase multiplicar, esto ya no me hace

949
00:41:48,929 --> 00:41:54,869
ninguna falta, y lo que es más

950
00:41:54,869 --> 00:41:56,889
es que ni siquiera

951
00:41:56,889 --> 00:41:58,690
necesito crear

952
00:41:58,690 --> 00:42:00,750
esta variable adicional, es que se lo pongo aquí

953
00:42:00,750 --> 00:42:02,630
directamente, que es el uso

954
00:42:02,630 --> 00:42:04,590
habitual, que es lo que veis vosotros en

955
00:42:04,590 --> 00:42:06,730
chagpt cuando lo veis

956
00:42:06,730 --> 00:42:08,670
¿Vale? Entonces es que

957
00:42:08,670 --> 00:42:10,630
de hecho hasta ni esto me haría

958
00:42:10,630 --> 00:42:12,670
falta, crearlo en variable aparte

959
00:42:12,670 --> 00:42:14,030
podría

960
00:42:14,030 --> 00:42:18,269
Directamente hacer esto

961
00:42:18,269 --> 00:42:26,360
Si no tiene, lo dejas en vacío

962
00:42:26,360 --> 00:42:26,940
Sin parámetros

963
00:42:26,940 --> 00:42:36,309
Esto habría sido

964
00:42:36,309 --> 00:42:37,489
Esto es lo natural

965
00:42:37,489 --> 00:42:42,739
Esto es lo que normalmente nos encontraríamos

966
00:42:42,739 --> 00:42:52,030
¿Veis? O sea, lo he reducido todo mi main

967
00:42:52,030 --> 00:42:54,010
A estas dos líneas

968
00:42:54,010 --> 00:42:57,590
Mi calculadora solo tiene opera

969
00:42:57,590 --> 00:43:00,969
O sea, mi aplicación de calculadora

970
00:43:00,969 --> 00:43:02,650
Se ha reducido una barbaridad

971
00:43:02,650 --> 00:43:04,489
si la revisamos

972
00:43:04,489 --> 00:43:06,909
tiene una interfaz funcional

973
00:43:06,909 --> 00:43:09,349
que marca que hay una operación con parámetros

974
00:43:09,349 --> 00:43:10,969
que hay que hacer, pero no decimos cuál

975
00:43:10,969 --> 00:43:13,909
y ahora tengo una calculadora

976
00:43:13,909 --> 00:43:15,710
que me dice, oye tú dame la operación

977
00:43:15,710 --> 00:43:17,190
que quieras, que ya operaré yo

978
00:43:17,190 --> 00:43:19,630
pero ya está, ahí no hay ninguna

979
00:43:19,630 --> 00:43:21,869
complejidad, es dame la operación

980
00:43:21,869 --> 00:43:23,369
y yo opero

981
00:43:23,369 --> 00:43:25,050
no hay que escribir más código

982
00:43:25,050 --> 00:43:26,829
no hay que escribir más nada

983
00:43:26,829 --> 00:43:29,269
y ahora ya, cuando yo

984
00:43:29,269 --> 00:43:30,969
llame al método de la calculadora

985
00:43:30,969 --> 00:43:32,710
le paso aquí

986
00:43:32,710 --> 00:43:35,550
la operación, que es la instancia

987
00:43:35,550 --> 00:43:36,230
de operar

988
00:43:36,230 --> 00:43:39,030
se la paso aquí como función lambda

989
00:43:39,030 --> 00:43:44,550
y todo esto es una abreviatura

990
00:43:44,550 --> 00:43:46,570
un atajo de todo lo anterior

991
00:43:46,570 --> 00:43:47,250
que hemos hecho

992
00:43:47,250 --> 00:43:49,730
lo que realmente hay debajo es

993
00:43:49,730 --> 00:43:52,489
mi interfaz funcional, una interfaz con un único

994
00:43:52,489 --> 00:43:54,409
método, punto pelota

995
00:43:54,409 --> 00:43:55,329
vale

996
00:43:55,329 --> 00:43:57,349
ahora

997
00:43:57,349 --> 00:43:59,949
puedo crear objetos

998
00:43:59,949 --> 00:44:02,590
de esta clase, esos objetos

999
00:44:02,590 --> 00:44:04,570
lo que van a tener va a ser lista de código

1000
00:44:04,570 --> 00:44:06,989
muy bien, pues entonces me declaro

1001
00:44:06,989 --> 00:44:08,809
mi clase y aquí meto esa lista

1002
00:44:08,809 --> 00:44:09,469
de código

1003
00:44:09,469 --> 00:44:12,849
y ahora ya en mi main yo instanciaría objetos

1004
00:44:12,849 --> 00:44:14,829
de esa clase y ya se los puedo pasar a mi

1005
00:44:14,829 --> 00:44:15,369
calculadora

1006
00:44:15,369 --> 00:44:19,010
pero todo eso lo podemos atajar con las funciones

1007
00:44:19,010 --> 00:44:19,369
lambda

1008
00:44:19,369 --> 00:44:22,349
que directamente

1009
00:44:22,349 --> 00:44:24,989
una función lambda

1010
00:44:24,989 --> 00:44:26,789
se sustituye directamente

1011
00:44:26,789 --> 00:44:27,829
con un objeto

1012
00:44:27,829 --> 00:44:30,409
de la interfaz funcional correspondiente

1013
00:44:30,409 --> 00:44:50,139
bueno, más o menos entendido

1014
00:44:50,139 --> 00:44:57,000
Entonces, vosotros

1015
00:44:57,000 --> 00:44:59,139
Cuando hacéis, por ejemplo

1016
00:44:59,139 --> 00:45:08,210
La típica

1017
00:45:08,210 --> 00:45:09,469
Para recorrer

1018
00:45:09,469 --> 00:45:12,469
A ver, por ejemplo, vamos a ver que tenemos aquí

1019
00:45:12,469 --> 00:45:13,829
Una lista

1020
00:45:13,829 --> 00:45:16,030
De

1021
00:45:16,030 --> 00:45:17,250
Numeritos

1022
00:45:17,250 --> 00:45:31,260
Vale, tengo aquí mi lista

1023
00:45:31,260 --> 00:45:33,159
De numeritos

1024
00:45:33,159 --> 00:45:35,579
Vamos a meterle

1025
00:45:35,579 --> 00:45:36,840
Números al azar

1026
00:45:36,840 --> 00:45:59,650
Y ahora hacemos el

1027
00:45:59,650 --> 00:46:01,670
Casting

1028
00:46:01,670 --> 00:46:06,039
Venga, vale, pues cuando vosotros

1029
00:46:06,039 --> 00:46:07,679
Mostráis esta lista, hasta ahora

1030
00:46:07,679 --> 00:46:09,880
Queremos mostrar la lista

1031
00:46:09,880 --> 00:46:10,400
Bueno, a ver

1032
00:46:10,400 --> 00:46:14,480
Lo típico sería hacer un recorrido

1033
00:46:14,480 --> 00:46:14,719
¿No?

1034
00:46:18,639 --> 00:46:20,539
Es que como lo he declarado como objeto

1035
00:46:20,539 --> 00:46:22,739
Es por referencia

1036
00:46:22,739 --> 00:46:24,320
Entonces yo creo que sí

1037
00:46:24,320 --> 00:46:25,980
No está como int

1038
00:46:25,980 --> 00:46:28,420
No sé si me explico, está como int

1039
00:46:28,420 --> 00:46:31,280
Entonces es la dirección del número, no el propio número

1040
00:46:31,280 --> 00:46:37,340
Ah, perdón, perdón, vale

1041
00:46:37,340 --> 00:46:39,900
Que se lo tengo que añadir, sí, sí, perdón, perdón

1042
00:46:39,900 --> 00:46:41,440
Eh, que sí

1043
00:46:41,440 --> 00:46:41,860
Que

1044
00:46:41,860 --> 00:46:45,000
A ver, que se me ha ido la

1045
00:46:45,000 --> 00:46:47,719
Vale, estaba ya pensando en el recorrido y mezclar las cosas

1046
00:46:47,719 --> 00:46:49,599
Pues venga, entonces

1047
00:46:49,599 --> 00:46:50,880
Para cada

1048
00:46:50,880 --> 00:46:54,639
Igual a cero

1049
00:46:54,639 --> 00:46:55,119
Mientras

1050
00:46:55,119 --> 00:46:58,059
Y sea menor que veinte

1051
00:46:58,059 --> 00:47:01,710
Ah, sí, sí, ¿verdad?

1052
00:47:02,909 --> 00:47:06,550
ahora números.add

1053
00:47:06,550 --> 00:47:09,949
esto, vale, ahora sí

1054
00:47:09,949 --> 00:47:12,630
vale, pues ahora ya sí, ¿cómo la recorremos

1055
00:47:12,630 --> 00:47:13,150
normalmente?

1056
00:47:15,710 --> 00:47:16,510
pues normalmente

1057
00:47:16,510 --> 00:47:18,010
hacemos esto, por cada

1058
00:47:18,010 --> 00:47:40,360
vale, pues que recorremos

1059
00:47:40,360 --> 00:47:41,840
la lista, pues hacemos esto

1060
00:47:41,840 --> 00:47:44,340
que queremos quedarnos con un elemento de la lista

1061
00:47:44,340 --> 00:47:46,019
que cumpla no sé qué, no sé cuántos

1062
00:47:46,019 --> 00:47:48,340
que queremos multiplicar por dos

1063
00:47:48,340 --> 00:47:50,559
todos los de la lista, pues la recorremos

1064
00:47:50,559 --> 00:47:52,260
entonces cada vez que trabajamos con listas

1065
00:47:52,260 --> 00:47:53,780
estamos haciendo for

1066
00:47:53,780 --> 00:47:56,099
todo el rato, estamos haciendo for

1067
00:47:56,099 --> 00:47:57,800
todo el rato para recorrerla, pues vale

1068
00:47:57,800 --> 00:48:00,179
no pasa nada, no es grave hacer un for para recorrer una lista

1069
00:48:00,179 --> 00:48:01,559
pero ahora

1070
00:48:01,559 --> 00:48:03,880
con esto de la programación funcional pues nos podemos

1071
00:48:03,880 --> 00:48:05,019
ahorrar líneas

1072
00:48:05,019 --> 00:48:07,960
porque yo ahora cojo mi lista, números

1073
00:48:07,960 --> 00:48:11,730
números si yo despliego

1074
00:48:11,730 --> 00:48:13,949
tiene un montón de métodos

1075
00:48:13,949 --> 00:48:17,329
y entre ellos

1076
00:48:17,329 --> 00:48:18,070
por ejemplo

1077
00:48:18,070 --> 00:48:20,530
pues tiene

1078
00:48:20,530 --> 00:48:23,510
este

1079
00:48:23,510 --> 00:48:26,670
tiene el forEach

1080
00:48:26,670 --> 00:48:28,110
entonces el forEach

1081
00:48:28,110 --> 00:48:30,230
veo que le hace falta

1082
00:48:30,230 --> 00:48:31,929
un tipo muy raro

1083
00:48:31,929 --> 00:48:33,889
un consumer no sé qué

1084
00:48:33,889 --> 00:48:36,170
¿qué será el consumer?

1085
00:48:37,150 --> 00:48:38,090
pues el consumer

1086
00:48:38,090 --> 00:48:40,369
resulta que es una interfaz funcional

1087
00:48:40,369 --> 00:48:41,389
que ya está hecha

1088
00:48:41,389 --> 00:48:43,829
con un único método

1089
00:48:43,829 --> 00:48:46,829
que recibe un parámetro

1090
00:48:46,829 --> 00:48:48,670
y hace algo con él

1091
00:48:48,670 --> 00:48:49,570
pero no devuelve nada

1092
00:48:49,570 --> 00:48:50,809
eso es un consumer

1093
00:48:50,809 --> 00:48:52,929
una interfaz funcional que ya está hecha

1094
00:48:52,929 --> 00:48:55,789
justo, pues el forEach

1095
00:48:55,789 --> 00:48:58,750
necesita que tú le digas

1096
00:48:58,750 --> 00:49:02,429
oye, dime qué hacer con cada numerito de la colección

1097
00:49:02,429 --> 00:49:03,530
y yo lo hago

1098
00:49:03,530 --> 00:49:06,650
vale, entonces el forEach

1099
00:49:06,650 --> 00:49:08,670
este método de aquí, forEach

1100
00:49:08,670 --> 00:49:13,610
es un método que lo que hay que pasarle precisamente

1101
00:49:13,610 --> 00:49:15,690
es un comportamiento

1102
00:49:15,690 --> 00:49:20,409
y es, qué hay que hacer con cada numerito de la colección

1103
00:49:20,409 --> 00:49:23,130
luego el forEach es un ejemplo

1104
00:49:23,130 --> 00:49:24,690
de método que

1105
00:49:24,690 --> 00:49:27,130
lo que hay que pasarle es

1106
00:49:27,130 --> 00:49:28,869
un método

1107
00:49:28,869 --> 00:49:31,130
o una instancia de una interfaz funcional

1108
00:49:31,130 --> 00:49:33,269
como lo queráis llamar, eso es lo que hay que

1109
00:49:33,269 --> 00:49:35,090
pasarle, lo que tú quieres

1110
00:49:35,090 --> 00:49:36,409
que se haga con cada elemento

1111
00:49:36,409 --> 00:49:37,809
entonces

1112
00:49:37,809 --> 00:49:41,110
en particular, diríamos

1113
00:49:41,110 --> 00:49:43,269
ya, pero ¿qué tipo de método? ¿cuántos parámetros

1114
00:49:43,269 --> 00:49:44,469
recibe? ¿cuántos no?

1115
00:49:44,949 --> 00:49:46,250
ya te lo está diciendo

1116
00:49:46,250 --> 00:49:48,710
la ayuda de forEach

1117
00:49:48,710 --> 00:49:50,489
te está diciendo, oye

1118
00:49:50,489 --> 00:49:53,389
yo la única interfaz funcional que me vale

1119
00:49:53,389 --> 00:49:55,630
es una de tipo consumer

1120
00:49:55,630 --> 00:49:57,630
y la interfaz funcional

1121
00:49:57,630 --> 00:49:59,110
de tipo consumer, si uno entrara

1122
00:49:59,110 --> 00:50:01,550
a jipearla, vería que es una interfaz

1123
00:50:01,550 --> 00:50:03,610
funcional con único método vacío

1124
00:50:03,610 --> 00:50:05,369
que recibe un número

1125
00:50:05,369 --> 00:50:07,730
y hace cosas, pero no devuelve

1126
00:50:07,730 --> 00:50:09,309
nada, pero no devuelve nada

1127
00:50:09,309 --> 00:50:11,670
pues eso es lo que necesita un for each

1128
00:50:11,670 --> 00:50:13,690
que le pases una lambda

1129
00:50:13,690 --> 00:50:15,650
que recibe un único valor

1130
00:50:15,650 --> 00:50:17,550
y hace cosas con él

1131
00:50:17,550 --> 00:50:18,829
pero no devuelve nada

1132
00:50:18,829 --> 00:50:21,449
porque es así

1133
00:50:21,449 --> 00:50:23,690
es un consumer válido

1134
00:50:23,690 --> 00:50:25,429
entonces

1135
00:50:25,429 --> 00:50:27,989
pues por ejemplo, ¿qué quiero hacer yo con cada

1136
00:50:27,989 --> 00:50:28,590
elemento?

1137
00:50:29,789 --> 00:50:31,889
pues por ejemplo, con cada elemento

1138
00:50:31,889 --> 00:50:32,530
quiero

1139
00:50:32,530 --> 00:50:35,050
hacer esto

1140
00:50:35,050 --> 00:50:46,179
soy x

1141
00:50:46,179 --> 00:50:48,239
vale, entonces me

1142
00:50:48,239 --> 00:50:50,599
falta aquí esto

1143
00:50:50,599 --> 00:50:51,800
y me sobra uno de estos, ¿verdad?

1144
00:50:52,719 --> 00:50:53,599
¡hala! pues ya está

1145
00:50:53,599 --> 00:50:56,460
esto es un buen uso del for each

1146
00:50:56,460 --> 00:50:58,780
porque le estoy pasando una lambda

1147
00:50:58,780 --> 00:51:00,300
que recibe

1148
00:51:00,300 --> 00:51:01,659
un único dato

1149
00:51:01,659 --> 00:51:04,599
y no devuelve nada, hace cosas

1150
00:51:04,599 --> 00:51:06,619
lo que uno le dé la gana, como si me merece aquí

1151
00:51:06,619 --> 00:51:08,440
poner 2000 operaciones y 30

1152
00:51:08,440 --> 00:51:10,420
system output del n, con que no haya un return

1153
00:51:10,420 --> 00:51:11,099
es suficiente

1154
00:51:11,099 --> 00:51:14,539
¿vale? bueno y eso es

1155
00:51:14,539 --> 00:51:16,679
así porque el for each está declarado

1156
00:51:16,679 --> 00:51:18,579
así, le tienes que pasar

1157
00:51:18,579 --> 00:51:20,480
una lambda de tipo consumer

1158
00:51:20,480 --> 00:51:22,500
o lo que es lo mismo, único

1159
00:51:22,500 --> 00:51:24,500
dato de entrada y aquí

1160
00:51:24,500 --> 00:51:26,440
lo que tú quieras, pero sin return

1161
00:51:26,440 --> 00:51:28,480
bueno, ¿y qué hace

1162
00:51:28,480 --> 00:51:30,340
el for each? pues el for each

1163
00:51:30,340 --> 00:51:32,760
para cada elemento de esta colección

1164
00:51:32,760 --> 00:51:34,199
para cada elemento

1165
00:51:34,199 --> 00:51:36,360
hace lo que tú le hayas puesto aquí

1166
00:51:36,360 --> 00:51:37,760
luego esto

1167
00:51:37,760 --> 00:51:40,280
sería idéntico al for de arriba

1168
00:51:40,280 --> 00:51:48,579
es decir

1169
00:51:48,579 --> 00:51:51,280
esto y esto hacen lo mismo

1170
00:51:51,280 --> 00:51:53,159
esto y esto hacen lo mismo

1171
00:51:53,159 --> 00:51:55,000
¿vale?

1172
00:51:56,420 --> 00:51:57,139
con esto

1173
00:51:57,139 --> 00:51:58,679
¿qué he hecho? pues me he arreglado un for

1174
00:51:58,679 --> 00:52:03,960
Lo de arriba y lo de abajo

1175
00:52:03,960 --> 00:52:05,179
Hacen exactamente lo mismo

1176
00:52:05,179 --> 00:52:07,860
Claro, yo aquí lo que no podría hacer

1177
00:52:07,860 --> 00:52:10,079
Es pasarle una lambda que no se adapte

1178
00:52:10,079 --> 00:52:11,559
Al tipo consumer este

1179
00:52:11,559 --> 00:52:13,980
Yo no puedo pasarle esta lambda, por ejemplo

1180
00:52:13,980 --> 00:52:16,219
Porque me diría

1181
00:52:16,219 --> 00:52:17,699
Perdona, es que

1182
00:52:17,699 --> 00:52:19,940
El consumer no tiene dos parámetros

1183
00:52:19,940 --> 00:52:21,360
De entrada, tiene solo uno

1184
00:52:21,360 --> 00:52:23,059
¿Vale?

1185
00:52:23,519 --> 00:52:25,940
No, bueno, aparte tendría que ponerlo así

1186
00:52:25,940 --> 00:52:29,179
¿Vale?

1187
00:52:29,340 --> 00:52:31,699
Me diría esto, me diría, eh, perdona

1188
00:52:31,699 --> 00:52:33,079
Pero

1189
00:52:33,079 --> 00:52:35,519
no es aplicable a los argumentos

1190
00:52:35,519 --> 00:52:37,800
lo siento, la lambda expression no se adapta

1191
00:52:37,800 --> 00:52:39,500
te lo estoy diciendo abajo

1192
00:52:39,500 --> 00:52:40,400
lo siento pero no

1193
00:52:40,400 --> 00:52:43,699
no me adapto, esta lambda

1194
00:52:43,699 --> 00:52:45,780
no se adapta a la firma

1195
00:52:45,780 --> 00:52:47,599
del método ACCEPT que es el método

1196
00:52:47,599 --> 00:52:48,619
que tiene el consumer

1197
00:52:48,619 --> 00:52:51,059
tiene un método ACCEPT que recibe un integer

1198
00:52:51,059 --> 00:52:52,579
un integer y devuelve un void

1199
00:52:52,579 --> 00:52:56,059
dice no, perdona, esta lambda no se adapta

1200
00:52:56,059 --> 00:52:58,159
dame una que se adapte

1201
00:52:58,159 --> 00:52:59,820
entonces, pues bueno

1202
00:52:59,820 --> 00:53:01,519
esta sí se adapta

1203
00:53:01,519 --> 00:53:02,639
¿vale?

1204
00:53:03,079 --> 00:53:05,300
x esto

1205
00:53:05,300 --> 00:53:09,869
entonces ahora si ejecutamos esto

1206
00:53:09,869 --> 00:53:15,039
pues tenemos

1207
00:53:15,039 --> 00:53:15,920
dos veces lo mismo

1208
00:53:15,920 --> 00:53:19,139
vale, la primera vez

1209
00:53:19,139 --> 00:53:20,139
en los primeros 20

1210
00:53:20,139 --> 00:53:23,179
y la segunda vez que yo no sé donde está

1211
00:53:23,179 --> 00:53:23,980
pero estará por ahí

1212
00:53:23,980 --> 00:53:28,050
eh

1213
00:53:28,050 --> 00:53:33,030
esto es lo de lo que había abajo

1214
00:53:33,030 --> 00:53:34,449
de la calculadora

1215
00:53:34,449 --> 00:53:36,369
vale

1216
00:53:36,369 --> 00:53:38,110
aquí empezamos

1217
00:53:38,110 --> 00:53:40,369
38

1218
00:53:40,369 --> 00:53:42,369
59, vale, ha hecho lo mismo

1219
00:53:42,369 --> 00:53:43,190
en ambos casos

1220
00:53:43,190 --> 00:53:46,550
¿cómo sabe

1221
00:53:46,550 --> 00:53:47,789
Java que tiene que hacer

1222
00:53:47,789 --> 00:53:50,389
porque así está programado

1223
00:53:50,389 --> 00:53:52,329
el for each por dentro, el for each

1224
00:53:52,329 --> 00:53:54,469
es un método que se aplica a una

1225
00:53:54,469 --> 00:53:56,469
colección, claro, es un

1226
00:53:56,469 --> 00:53:57,150
método de list

1227
00:53:57,150 --> 00:54:00,409
y está programado para

1228
00:54:00,409 --> 00:54:01,809
que a cada elemento

1229
00:54:01,809 --> 00:54:03,570
de la lista

1230
00:54:03,570 --> 00:54:06,230
le haga la acción

1231
00:54:06,230 --> 00:54:07,190
que tú tienes aquí

1232
00:54:07,190 --> 00:54:08,849
vale

1233
00:54:08,849 --> 00:54:12,250
Pero hay otros que también pueden recibir

1234
00:54:12,250 --> 00:54:13,690
Dentro de las listas

1235
00:54:13,690 --> 00:54:15,389
Por ejemplo, números

1236
00:54:15,389 --> 00:54:17,650
Si uno cotillea por aquí, a ver cuáles reciben

1237
00:54:17,650 --> 00:54:19,989
Interfaces funcionales

1238
00:54:19,989 --> 00:54:25,369
Por su nombre

1239
00:54:25,369 --> 00:54:27,809
Porque es consumer o predicate o funcional

1240
00:54:27,809 --> 00:54:29,210
O algo así

1241
00:54:29,210 --> 00:54:32,949
No, comparator

1242
00:54:32,949 --> 00:54:34,670
Bueno, sí, comparator

1243
00:54:34,670 --> 00:54:37,570
También es una interfaz funcional, le puedes pasar como lambda

1244
00:54:37,570 --> 00:54:40,309
vale, yo estaba buscando aquí

1245
00:54:40,309 --> 00:54:44,010
aquí, el predicate

1246
00:54:44,010 --> 00:54:44,769
que se me había escapado

1247
00:54:44,769 --> 00:54:46,289
el removeFif

1248
00:54:46,289 --> 00:54:49,929
tienes que pasarle

1249
00:54:49,929 --> 00:54:52,250
un objeto de tipo predicate

1250
00:54:52,250 --> 00:54:54,130
que resulta que también

1251
00:54:54,130 --> 00:54:55,309
es una interfaz funcional

1252
00:54:55,309 --> 00:54:57,929
pero la interfaz funcional predicate

1253
00:54:57,929 --> 00:55:01,409
¿qué firma tiene en su método?

1254
00:55:02,670 --> 00:55:03,010
pues

1255
00:55:03,010 --> 00:55:06,010
recibe un valor

1256
00:55:06,010 --> 00:55:06,769
un valor

1257
00:55:06,769 --> 00:55:09,650
y te devuelve un boolean, un truco falso

1258
00:55:09,650 --> 00:55:11,469
entonces el predicate

1259
00:55:11,469 --> 00:55:13,829
sobre un elemento te dice si

1260
00:55:13,829 --> 00:55:15,409
cumple algo o si no lo cumple

1261
00:55:15,409 --> 00:55:16,550
lo que ahí te dé la gana

1262
00:55:16,550 --> 00:55:20,289
entonces, el remove if

1263
00:55:20,289 --> 00:55:23,969
yo le tengo que pasar

1264
00:55:23,969 --> 00:55:25,869
una función lambda de tipo

1265
00:55:25,869 --> 00:55:27,610
predicado, como por ejemplo esta

1266
00:55:27,610 --> 00:55:29,210
x

1267
00:55:29,210 --> 00:55:31,969
x entre 2

1268
00:55:32,530 --> 00:55:35,659
igual a

1269
00:55:36,559 --> 00:55:37,480
0

1270
00:55:37,480 --> 00:55:41,900
¿Vale? ¿Veis?

1271
00:55:42,039 --> 00:55:44,400
Esta es una función lambda de tipo predicado

1272
00:55:44,400 --> 00:55:46,280
correcta, recibe

1273
00:55:46,280 --> 00:55:48,559
un único valor y te devuelve

1274
00:55:48,559 --> 00:55:49,179
un boolean

1275
00:55:49,179 --> 00:55:50,800
te devuelve un boolean

1276
00:55:50,800 --> 00:55:54,679
entonces el remove if me la acepta

1277
00:55:54,679 --> 00:55:56,239
porque el remove if necesita

1278
00:55:56,239 --> 00:55:58,280
funciones lambda de tipo predicado

1279
00:55:58,280 --> 00:56:00,559
entonces las de tipo

1280
00:56:00,559 --> 00:56:02,019
ya esas dos nos pueden sonar

1281
00:56:02,019 --> 00:56:04,340
las de tipo consumer, funciones lambda

1282
00:56:04,340 --> 00:56:06,760
que reciben un parámetro y no devuelven

1283
00:56:06,760 --> 00:56:08,679
nada, hacen lo que sea pero no devuelven nada

1284
00:56:08,679 --> 00:56:11,280
funciones lambda de tipo predicado

1285
00:56:11,280 --> 00:56:13,079
reciben un parámetro

1286
00:56:13,079 --> 00:56:14,800
y devuelven un boolean

1287
00:56:14,800 --> 00:56:16,900
esta es de tipo predicado

1288
00:56:16,900 --> 00:56:18,139
vale, ahora la pregunta sería

1289
00:56:18,139 --> 00:56:19,719
¿qué hace el remufif?

1290
00:56:20,340 --> 00:56:22,739
pues a todos y cada uno de los elementos

1291
00:56:22,739 --> 00:56:24,619
de esta colección

1292
00:56:24,619 --> 00:56:26,619
a todos y cada uno los elimina

1293
00:56:26,619 --> 00:56:28,800
si el predicado se cumple

1294
00:56:28,800 --> 00:56:32,309
entonces lo que haríamos con un for

1295
00:56:32,309 --> 00:56:35,929
o con un iterator

1296
00:56:35,929 --> 00:56:36,829
que sería un rollo

1297
00:56:36,829 --> 00:56:39,969
es decir, eliminar los pares

1298
00:56:39,969 --> 00:56:40,769
De la colección

1299
00:56:40,769 --> 00:56:43,050
Sería un rollo

1300
00:56:43,050 --> 00:56:44,630
Sin las funciones lambda

1301
00:56:44,630 --> 00:56:47,550
Pues haríamos esto

1302
00:56:47,550 --> 00:56:48,190
¿Verdad?

1303
00:56:48,849 --> 00:56:51,449
Números.iterator

1304
00:56:51,449 --> 00:56:52,969
Y ahora

1305
00:56:52,969 --> 00:57:01,280
While iterator.next

1306
00:57:01,280 --> 00:57:05,369
No, next

1307
00:57:05,369 --> 00:57:06,289
No, has next

1308
00:57:06,289 --> 00:57:06,829
Era, ¿no?

1309
00:57:07,190 --> 00:57:10,590
Ahora sí

1310
00:57:10,590 --> 00:57:16,579
If it.next

1311
00:57:16,579 --> 00:57:19,719
Por ciento

1312
00:57:19,719 --> 00:57:22,599
por 102

1313
00:57:22,599 --> 00:57:24,539
es igual a 0

1314
00:57:24,539 --> 00:57:28,909
en iterator

1315
00:57:28,909 --> 00:57:30,809
es que no lo he parametrizado, por eso se queja

1316
00:57:30,809 --> 00:57:32,670
el compilador, es un iterator de

1317
00:57:32,670 --> 00:57:33,389
interés

1318
00:57:33,389 --> 00:57:37,530
entonces

1319
00:57:37,530 --> 00:57:40,110
id.remove

1320
00:57:40,110 --> 00:57:40,889
vale

1321
00:57:40,889 --> 00:57:44,190
id.remove, vale

1322
00:57:44,190 --> 00:57:46,190
pues este, sin lambdas y

1323
00:57:46,190 --> 00:57:47,150
programación funcional

1324
00:57:47,150 --> 00:57:50,230
este sería el código para eliminar

1325
00:57:50,230 --> 00:57:51,030
los pares, ¿verdad?

1326
00:57:51,030 --> 00:57:53,489
no lo haríamos con un for each

1327
00:57:53,489 --> 00:57:55,349
porque ya sabemos que es el concurrente exception

1328
00:57:55,349 --> 00:57:58,130
sería el código, itero por la colección

1329
00:57:58,130 --> 00:57:59,309
alguno par

1330
00:57:59,309 --> 00:58:00,170
lo elimino

1331
00:58:00,170 --> 00:58:03,269
con landas

1332
00:58:03,269 --> 00:58:04,329
es esto

1333
00:58:04,329 --> 00:58:07,829
uso el método remove if que me dice

1334
00:58:07,829 --> 00:58:08,710
oye

1335
00:58:08,710 --> 00:58:11,750
tú pásame un predicado

1336
00:58:11,750 --> 00:58:13,550
que yo

1337
00:58:13,550 --> 00:58:15,909
aplicaré a cada elemento de números

1338
00:58:15,909 --> 00:58:16,710
lo aplicaré

1339
00:58:16,710 --> 00:58:18,610
y el que me dé true lo borro

1340
00:58:18,610 --> 00:58:23,380
Pues entonces yo le paso un predicado

1341
00:58:23,380 --> 00:58:25,579
Y un predicado es una interfaz funcional

1342
00:58:25,579 --> 00:58:26,780
Que recibe un valor

1343
00:58:26,780 --> 00:58:28,179
Y devuelve un boolean

1344
00:58:28,179 --> 00:58:38,690
Entonces pues hombre, nos ahorra la vida

1345
00:58:38,690 --> 00:58:40,969
Y ya nos la ahorra mucho más

1346
00:58:40,969 --> 00:58:43,670
Si ahora ya, pero esto ya lo vamos a hacer hoy

1347
00:58:43,670 --> 00:58:47,409
Metemos esa lista en una tubería

1348
00:58:47,409 --> 00:58:48,869
Porque entonces ya

1349
00:58:48,869 --> 00:58:51,469
Los posibles métodos

1350
00:58:51,469 --> 00:58:52,949
Que podemos usar

1351
00:58:52,949 --> 00:58:54,489
Son infinitos

1352
00:58:54,489 --> 00:58:56,489
O sea, trabajar con una colección

1353
00:58:56,489 --> 00:58:58,809
Sin streams

1354
00:58:58,809 --> 00:59:00,889
a trabajar con streams, la diferencia es enorme

1355
00:59:00,889 --> 00:59:02,789
vale, entonces vamos a

1356
00:59:02,789 --> 00:59:04,969
comprobar que ambas cosas nos hacen lo mismo

1357
00:59:04,969 --> 00:59:06,750
bueno

1358
00:59:06,750 --> 00:59:08,710
no hace falta, a ver, os lo digo yo, que lo hará

1359
00:59:08,710 --> 00:59:09,989
y si no lo comprobáis y ya está

1360
00:59:09,989 --> 00:59:14,099
vale, bueno pues

1361
00:59:14,099 --> 00:59:16,000
entonces, cuando

1362
00:59:16,000 --> 00:59:17,199
copiéis y peguéis

1363
00:59:17,199 --> 00:59:19,940
landas relacionadas con colecciones

1364
00:59:19,940 --> 00:59:21,500
de Gemini

1365
00:59:21,500 --> 00:59:23,960
id entendiendo por favor que estáis

1366
00:59:23,960 --> 00:59:25,639
haciendo, que es esto, porque cada uno lo ve

1367
00:59:25,639 --> 00:59:27,840
y dice, ah esto está muy bien para cada

1368
00:59:27,840 --> 00:59:29,280
x, me dice si es par o no

1369
00:59:29,280 --> 00:59:31,639
claro, lo estás leyendo, tal cual

1370
00:59:31,639 --> 00:59:33,000
para KDX me dices para uno

1371
00:59:33,000 --> 00:59:35,579
pero claro, no hay que quedarse en eso, hay que entender

1372
00:59:35,579 --> 00:59:37,539
que esto realmente es un objeto

1373
00:59:37,539 --> 00:59:39,099
¿de quién?

1374
00:59:39,599 --> 00:59:41,460
es un objeto de este

1375
00:59:41,460 --> 00:59:43,519
del predicate

1376
00:59:43,519 --> 00:59:45,519
y predicate que es

1377
00:59:45,519 --> 00:59:47,699
una interfaz funcional, entonces si tú entiendes eso

1378
00:59:47,699 --> 00:59:49,559
cuando tú buscas método dices, ah vale

1379
00:59:49,559 --> 00:59:51,260
este necesita un consumer

1380
00:59:51,260 --> 00:59:53,719
ya sé lo que es un consumer, este necesita

1381
00:59:53,719 --> 00:59:55,420
un

1382
00:59:55,420 --> 00:59:57,340
un predicado

1383
00:59:57,340 --> 00:59:59,559
Pues ya sé lo que es, tengo que darle una landa a predicado

1384
00:59:59,559 --> 01:00:01,480
Pues bueno, ya empezamos a entender un poco

1385
01:00:01,480 --> 01:00:02,900
De qué estamos hablando

1386
01:00:02,900 --> 01:00:04,099
¿Vale?

1387
01:00:08,619 --> 01:00:10,639
Bueno, ¿bonito o no bonito?

1388
01:00:11,940 --> 01:00:12,639
¿Cómo que sí?

1389
01:00:12,679 --> 01:00:14,400
Esto es infinitamente más bonito

1390
01:00:14,400 --> 01:00:16,599
Que el JavaFXS

1391
01:00:16,599 --> 01:00:18,800
Que no tiene más que colores feos

1392
01:00:18,800 --> 01:00:28,099
Claro, tú en el consumer aquí

1393
01:00:28,099 --> 01:00:31,260
Aquí puedes poner

1394
01:00:31,260 --> 01:00:35,460
lo que quieras, por ejemplo, imagínate que yo quiero mostrar

1395
01:00:35,460 --> 01:00:37,639
solamente los pares

1396
01:00:37,639 --> 01:00:41,739
pues podría ser para cada x

1397
01:00:41,739 --> 01:00:46,579
si x por 102

1398
01:00:46,579 --> 01:00:49,599
es igual a 0

1399
01:00:49,599 --> 01:00:55,300
pues ponme aquí

1400
01:00:55,300 --> 01:00:59,079
soy x

1401
01:00:59,079 --> 01:01:02,019
y soy par

1402
01:01:02,019 --> 01:01:08,400
Claro, cualquier método

1403
01:01:08,400 --> 01:01:10,360
Soy x

1404
01:01:10,360 --> 01:01:11,900
Y soy par

1405
01:01:11,900 --> 01:01:15,079
Y si no, pues que no muestre nada

1406
01:01:15,079 --> 01:01:18,780
Entonces, aquí como solo sería

1407
01:01:18,780 --> 01:01:20,119
Una sentencia que es la if

1408
01:01:20,119 --> 01:01:22,599
A mí me dejaría no poner las llaves

1409
01:01:22,599 --> 01:01:26,760
For each if x es igual

1410
01:01:26,760 --> 01:01:28,860
No, yo creo que cuando ya pones una sentencia

1411
01:01:28,860 --> 01:01:29,340
A ver

1412
01:01:29,340 --> 01:01:33,139
Es porque me falta un paréntesis

1413
01:01:33,139 --> 01:01:34,860
No, porque

1414
01:01:34,860 --> 01:01:36,860
Este me dice este

1415
01:01:36,860 --> 01:01:38,679
y este me dice soy x y soy par

1416
01:01:38,679 --> 01:01:40,420
yo creo que es porque aquí ya

1417
01:01:40,420 --> 01:01:42,619
que he puesto un paréntesis de más

1418
01:01:42,619 --> 01:01:46,699
al final de eso tengo que cerrar el for each

1419
01:01:46,699 --> 01:01:48,000
claro

1420
01:01:48,000 --> 01:01:50,559
entonces yo creo es porque al poner ya

1421
01:01:50,559 --> 01:01:51,260
una sentencia

1422
01:01:51,260 --> 01:01:53,360
más

1423
01:01:53,360 --> 01:01:56,519
tocha, no tan sencilla como

1424
01:01:56,519 --> 01:01:58,519
una operación, ya me dice que

1425
01:01:58,519 --> 01:02:03,099
lo cierre así

1426
01:02:03,099 --> 01:02:04,940
¿verdad? porque ni con el punto ni con el

1427
01:02:04,940 --> 01:02:09,250
ya pero es que había

1428
01:02:09,250 --> 01:02:12,250
Vale, entonces ahora ya

1429
01:02:12,250 --> 01:02:14,929
Ahora ya sí, bueno, está muy fea

1430
01:02:14,929 --> 01:02:15,949
A ver cómo la

1431
01:02:15,949 --> 01:02:20,329
Vale, pues entonces este for it

1432
01:02:20,329 --> 01:02:21,570
Solo le mostraría los pares

1433
01:02:21,570 --> 01:02:28,159
Vale, del segundo recorrido

1434
01:02:28,159 --> 01:02:29,639
Solo ha hecho esto

1435
01:02:29,639 --> 01:02:33,340
Puedes meter lo que quieras

1436
01:02:33,340 --> 01:02:35,699
Vale

1437
01:02:35,699 --> 01:02:41,579
Bueno, dudas