1
00:00:00,750 --> 00:00:08,250
Estoy grabando, por lo tanto, si habláis me dais autorización a que se grabe vuestra voz.

2
00:00:09,810 --> 00:00:13,650
Hoy vamos a ver un poquito más del tema de...

3
00:00:13,650 --> 00:00:18,789
Hemos estado repasando, hemos visto las clases astratas, el concepto de polimorfismo,

4
00:00:19,309 --> 00:00:25,210
y ahora vamos hacia otra pieza del puzzle, que son las interfaces.

5
00:00:25,649 --> 00:00:29,670
El discurso es que hasta ahora, cuando hemos hablado de clases astratas,

6
00:00:29,670 --> 00:00:35,109
La clase abstracta es una mezcla entre cosas concretas, ¿vale?

7
00:00:35,109 --> 00:00:41,549
Métodos concretos que yo implemento y otros métodos que no puedo implementar

8
00:00:41,549 --> 00:00:48,390
porque todavía estoy a un nivel demasiado genérico y por lo tanto lo dejo abstracto

9
00:00:48,390 --> 00:00:53,429
y alguien que extenderá esta clase podrá implementarla, ¿vale?

10
00:00:53,429 --> 00:00:57,869
Si llevamos esta cosa al extremo

11
00:00:57,869 --> 00:00:58,210
¿Vale?

12
00:00:58,270 --> 00:01:00,030
Es decir, si tengo una clase

13
00:01:00,030 --> 00:01:01,210
Astrata

14
00:01:01,210 --> 00:01:03,590
Que no tiene nada concreto

15
00:01:03,590 --> 00:01:06,390
Que solo tiene métodos abstractos

16
00:01:06,390 --> 00:01:07,989
Pues ese señor

17
00:01:07,989 --> 00:01:09,109
Es un interfaz

18
00:01:09,109 --> 00:01:10,290
¿Vale?

19
00:01:10,629 --> 00:01:12,109
Entonces, un interfaz al fin y al cabo

20
00:01:12,109 --> 00:01:13,989
Es como una clase abstracta

21
00:01:13,989 --> 00:01:16,129
Donde, pero es talmente abstracta

22
00:01:16,129 --> 00:01:18,049
Que yo no puedo concretar nada

23
00:01:18,049 --> 00:01:19,269
Ni siquiera variable

24
00:01:19,269 --> 00:01:20,409
Ahora veremos luego las variables

25
00:01:20,409 --> 00:01:21,909
Que puedo concretar

26
00:01:21,909 --> 00:01:26,609
Entonces llega un momento en que digo, vale, todos los métodos aquí que estoy declarando son abstractos

27
00:01:26,609 --> 00:01:31,109
Al punto que, a este punto, no me compensa poner abstracto en todos los métodos

28
00:01:31,109 --> 00:01:33,650
Asumo que son todos abstractos, ¿vale?

29
00:01:33,950 --> 00:01:37,670
Entonces, en vez de declarar una clase, declaro una interfaz

30
00:01:37,670 --> 00:01:42,209
Si yo declaro una interfaz, todos los métodos que declararé ahora mismo, que veremos

31
00:01:42,209 --> 00:01:48,129
Pues, sustancialmente, serán prototipos de métodos y serán considerados todos abstractos

32
00:01:48,129 --> 00:01:52,950
No se le pone el cuerpo del método

33
00:01:52,950 --> 00:02:00,030
Una clase lo que podrá hacer es implementar una interfaz

34
00:02:00,030 --> 00:02:03,049
Cuidado, las interfaces no se extenden

35
00:02:03,049 --> 00:02:05,510
Se pueden extender para hacer otras interfaces

36
00:02:05,510 --> 00:02:07,730
O sea, interfaces entre ellos se pueden extender

37
00:02:07,730 --> 00:02:10,710
Pero el concepto es que si creo una clase

38
00:02:10,710 --> 00:02:14,689
Que va a implementar los métodos de esta interfaz

39
00:02:14,689 --> 00:02:18,050
No la extendo la interfaz, la implemento

40
00:02:18,050 --> 00:02:21,469
Tengo una palabra clave que ahora veremos que es implement

41
00:02:21,469 --> 00:02:28,229
La cosa interesante de Java es que tú puedes extender una sola clase

42
00:02:28,229 --> 00:02:32,930
Pero puedes implementar todas las interfaces que quieres

43
00:02:32,930 --> 00:02:44,069
Es un poco, digamos así, una forma de crear en Java una herencia múltiple

44
00:02:44,069 --> 00:02:51,129
Es la forma de cómo en Java podría hacer una herencia múltiple

45
00:02:51,129 --> 00:02:54,849
Hemos dicho que en Java podría dar una sola clase

46
00:02:54,849 --> 00:03:01,810
Por lo tanto, si en un determinado momento debería importar varios conceptos distintos dentro de la misma clase

47
00:03:01,810 --> 00:03:07,030
Lo que puede hacer es extender una clase e importar varias interfaces

48
00:03:07,030 --> 00:03:12,509
Esto es un poquito en general para entender qué es la interfaz

49
00:03:12,509 --> 00:03:13,449
Vamos a ver qué dice

50
00:03:13,449 --> 00:03:16,169
Es un concepto similar a la clase astrata

51
00:03:16,169 --> 00:03:16,530
¿Vale?

52
00:03:16,949 --> 00:03:19,889
Es un molde que define

53
00:03:19,889 --> 00:03:22,430
Una estructura formal de métodos

54
00:03:22,430 --> 00:03:23,349
Para una clase

55
00:03:23,349 --> 00:03:24,909
¿Vale? Es decir, me está diciendo

56
00:03:24,909 --> 00:03:27,050
Mira, esta...

57
00:03:27,050 --> 00:03:29,009
Si tú implementas esta interfaz

58
00:03:29,009 --> 00:03:30,830
Quiere decir que tu clase

59
00:03:30,830 --> 00:03:33,210
Necesariamente tiene que tener

60
00:03:33,210 --> 00:03:34,830
Este método, este método, este método

61
00:03:34,830 --> 00:03:35,990
¿Vale?

62
00:03:36,389 --> 00:03:38,810
Que devuelva esto, que pille este parámetro

63
00:03:38,810 --> 00:03:40,669
Que se llame así, etc, etc

64
00:03:40,669 --> 00:03:42,830
Es un contrato

65
00:03:42,830 --> 00:03:44,810
Que yo hago contigo

66
00:03:44,810 --> 00:03:46,610
Diciendo en el momento en que implementas

67
00:03:46,610 --> 00:03:49,050
Mi interfaz

68
00:03:49,050 --> 00:03:50,509
Esta interfaz aquí concreta

69
00:03:50,509 --> 00:03:53,250
Yo sé que tu clase tendrá este método

70
00:03:53,250 --> 00:03:54,889
Y por lo tanto hasta si

71
00:03:54,889 --> 00:03:56,930
Yo no sé como está implementado

72
00:03:56,930 --> 00:03:58,370
Esto lo implementarás tú

73
00:03:58,370 --> 00:04:00,449
Dependiendo de tus casos específicos

74
00:04:00,449 --> 00:04:01,729
Pero yo podré utilizar

75
00:04:01,729 --> 00:04:04,930
Tú has creado el método

76
00:04:04,930 --> 00:04:05,909
X

77
00:04:05,909 --> 00:04:07,330
Dentro de

78
00:04:07,330 --> 00:04:10,330
Dentro de una interfaz

79
00:04:10,330 --> 00:04:12,050
Yo no sé como está implementado

80
00:04:12,050 --> 00:04:14,270
Pero sé que si tu clase

81
00:04:14,270 --> 00:04:15,669
Implementa esta interfaz

82
00:04:15,669 --> 00:04:17,889
Yo puedo llamar sobre tus objetos

83
00:04:17,889 --> 00:04:18,670
Método X

84
00:04:18,670 --> 00:04:22,209
Y que devolverá lo que te he dicho

85
00:04:22,209 --> 00:04:23,350
Que devuelva

86
00:04:23,350 --> 00:04:26,310
Claramente la idea es que el contrato

87
00:04:26,310 --> 00:04:27,310
También explique

88
00:04:27,310 --> 00:04:29,870
Que tiene que hacer este método

89
00:04:29,870 --> 00:04:31,870
¿Vale? Entonces normalmente

90
00:04:31,870 --> 00:04:33,930
Va asociado la interfaz

91
00:04:33,930 --> 00:04:35,769
Con sus varios métodos

92
00:04:35,769 --> 00:04:37,449
Que tiene que implementar y cada método

93
00:04:37,449 --> 00:04:39,970
Una descripción de lo que se espera de este método

94
00:04:39,970 --> 00:04:41,850
¿Vale? Haremos un ejemplo concreto

95
00:04:41,850 --> 00:04:44,009
Con la interfaz comparable

96
00:04:44,009 --> 00:04:45,910
Dentro de un rato

97
00:04:45,910 --> 00:04:47,170
¿Sí?

98
00:04:48,350 --> 00:04:50,029
Sirven para presentar un mecanismo

99
00:04:50,029 --> 00:04:51,810
Similar a la herencia múltiple

100
00:04:51,810 --> 00:04:52,610
De otros objetos

101
00:04:52,610 --> 00:04:54,910
De lenguajes orientados a objetos

102
00:04:54,910 --> 00:04:56,910
T++, por ejemplo

103
00:04:56,910 --> 00:04:59,129
Que es otro lenguaje orientado a objetos

104
00:04:59,129 --> 00:05:01,610
Sí que admite herencia múltiple

105
00:05:01,610 --> 00:05:03,629
Puedes hacer una extend, entre comillas

106
00:05:03,629 --> 00:05:04,670
De varias clases

107
00:05:04,670 --> 00:05:08,410
Ellos lo permiten

108
00:05:08,410 --> 00:05:10,750
Se parecen a clases abstractas

109
00:05:10,750 --> 00:05:12,730
Pero la diferencia es que

110
00:05:12,730 --> 00:05:14,889
sus métodos son obligatoriamente

111
00:05:14,889 --> 00:05:16,790
abstractos, o sea, no puede

112
00:05:16,790 --> 00:05:18,589
hacer métodos concretos, en realidad

113
00:05:18,589 --> 00:05:19,829
sí, ahora lo veremos, pero

114
00:05:19,829 --> 00:05:22,930
los métodos por defecto de una interfaz

115
00:05:22,930 --> 00:05:23,810
se consideran

116
00:05:23,810 --> 00:05:26,810
abstractos, y por lo tanto

117
00:05:26,810 --> 00:05:28,750
no voy a escribir abstracto por

118
00:05:28,750 --> 00:05:30,730
todo lado, porque sé que si lo

119
00:05:30,730 --> 00:05:32,449
declaro así normalmente, pues

120
00:05:32,449 --> 00:05:34,730
ese es abstracto

121
00:05:35,290 --> 00:05:35,449
¿no?

122
00:05:38,269 --> 00:05:40,129
En Java, en vez de utilizar

123
00:05:40,129 --> 00:05:42,529
class para crear una interfaz

124
00:05:42,529 --> 00:05:44,149
Utilizo la palabra interface

125
00:05:44,149 --> 00:05:45,329
Si habéis notado

126
00:05:45,329 --> 00:05:47,189
Si os habéis parado alguna vez a mirar

127
00:05:47,189 --> 00:05:49,410
Cuando en Eclipse pinchamos botón derecho

128
00:05:49,410 --> 00:05:51,730
Y normalmente elegimos

129
00:05:51,730 --> 00:05:54,490
O project, o package, o class

130
00:05:54,490 --> 00:05:56,029
Lo que hemos utilizado hasta ahora

131
00:05:56,029 --> 00:05:57,730
Pues también da la opción

132
00:05:57,730 --> 00:05:59,230
Interface

133
00:05:59,230 --> 00:06:01,750
En ese caso si pincháis allí

134
00:06:01,750 --> 00:06:04,250
En vez de salir un public class no se que

135
00:06:04,250 --> 00:06:06,350
Os saldrá un public interface

136
00:06:06,350 --> 00:06:06,910
No se que

137
00:06:06,910 --> 00:06:08,050
Si

138
00:06:08,050 --> 00:06:11,480
Y para

139
00:06:11,480 --> 00:06:26,540
Para enlazar una clase con otra, o con una interfaz, en vez de decir que la clase extiende la otra clase, que es lo que se usa para la herencia, se dice que la clase implements esa interfaz.

140
00:06:29,959 --> 00:06:34,220
Y lo que hemos dicho es que se puede extender una sola, se puede implementar varias.

141
00:06:36,480 --> 00:06:40,160
Se pueden declarar referencias a objetos cuyo tipo sea una interfaz.

142
00:06:40,160 --> 00:06:41,920
¿Vale? En lugar de una clase

143
00:06:41,920 --> 00:06:44,120
O sea que si yo tengo la interfaz

144
00:06:44,120 --> 00:06:52,170
Comparable

145
00:06:52,170 --> 00:06:53,750
¿Vale? Comparable

146
00:06:53,750 --> 00:06:56,170
¿Vale? Yo puedo crear

147
00:06:56,170 --> 00:06:56,769
Una

148
00:06:56,769 --> 00:06:59,850
Una variable

149
00:06:59,850 --> 00:07:01,990
Comparable, para hacer comparable

150
00:07:01,990 --> 00:07:04,009
X es igual a new

151
00:07:04,009 --> 00:07:05,610
Algo, este

152
00:07:05,610 --> 00:07:08,209
New algo que hago, esta nueva clase

153
00:07:08,209 --> 00:07:09,610
Que estoy creando, esta instancia

154
00:07:09,610 --> 00:07:11,750
Tendrá que ser una instancia que

155
00:07:11,750 --> 00:07:13,149
Implementa comparable

156
00:07:13,149 --> 00:07:14,709
Si no, no lo puedo hacer

157
00:07:14,709 --> 00:07:17,370
Entonces si yo tengo

158
00:07:17,370 --> 00:07:19,290
Las clases A, B y C

159
00:07:19,290 --> 00:07:21,389
Y las tres clases

160
00:07:21,389 --> 00:07:22,930
Implementan comparables

161
00:07:22,930 --> 00:07:24,569
La clase A, B y C

162
00:07:24,569 --> 00:07:26,870
Y las tres implementan comparables

163
00:07:26,870 --> 00:07:29,430
Yo puedo crear tranquilamente un comparable

164
00:07:29,430 --> 00:07:31,990
X es igual a

165
00:07:31,990 --> 00:07:33,310
New A

166
00:07:33,310 --> 00:07:33,970
Por ejemplo

167
00:07:33,970 --> 00:07:36,790
Porque como A implementa comparables

168
00:07:36,790 --> 00:07:37,449
Pues lo puedo hacer

169
00:07:37,449 --> 00:07:40,430
Es parecido al concepto

170
00:07:40,430 --> 00:07:41,990
Que hemos visto de

171
00:07:41,990 --> 00:07:43,509
Upcasting en

172
00:07:43,509 --> 00:07:47,509
En las clases abstractas

173
00:07:47,509 --> 00:07:49,790
Si yo esta la pienso como una clase abstracta

174
00:07:49,790 --> 00:07:51,310
Pues esto es una cosa

175
00:07:51,310 --> 00:07:53,029
Que se podría hacer

176
00:07:53,029 --> 00:07:55,509
O sea, puedo crear un nuevo A

177
00:07:55,509 --> 00:07:57,230
Que extienda comparables

178
00:07:57,230 --> 00:07:58,629
Y puede comparar el poder abstracto

179
00:07:58,629 --> 00:08:00,870
Como hemos dicho que esto de la interfaz

180
00:08:00,870 --> 00:08:03,670
Es como un paso más hacia la abstracción

181
00:08:03,670 --> 00:08:05,389
Con respecto a la clase abstracta

182
00:08:05,389 --> 00:08:06,949
La clase abstracta puede tener todavía

183
00:08:06,949 --> 00:08:08,889
Algunos métodos implementados

184
00:08:08,889 --> 00:08:09,629
Mientras esta no

185
00:08:09,629 --> 00:08:13,970
El concepto es el mismo

186
00:08:13,970 --> 00:08:16,110
¿Sí? ¿Dudas?

187
00:08:16,709 --> 00:08:16,870
Sí

188
00:08:16,870 --> 00:08:25,860
Yo puedo hacer que A extenda de animal

189
00:08:25,860 --> 00:08:28,079
Y implemente con parámetros

190
00:08:28,079 --> 00:08:35,320
Su función principal

191
00:08:35,320 --> 00:08:36,960
Es establecer

192
00:08:36,960 --> 00:08:39,039
Y estabilizar

193
00:08:39,039 --> 00:08:39,899
¿Qué quiere decir?

194
00:08:39,980 --> 00:08:42,480
Las interfaces por tipo de métodos

195
00:08:42,480 --> 00:08:43,039
¿Vale?

196
00:08:44,139 --> 00:08:45,779
Es que una clase puede ser de la realidad

197
00:08:45,779 --> 00:08:47,740
Y así coordinar varios equipos de trabajo

198
00:08:47,740 --> 00:08:50,580
¿Para qué sirve una interfaz de verdad?

199
00:08:52,120 --> 00:08:56,279
La idea es que cuando yo tengo un proyecto relativamente complejo

200
00:08:56,279 --> 00:09:00,860
Necesito de alguna forma organizar los varios equipos de trabajo

201
00:09:00,860 --> 00:09:02,639
Que están trabajando sobre el sistema

202
00:09:02,639 --> 00:09:06,980
Es muy ineficiente pillar un grupo de trabajadores

203
00:09:06,980 --> 00:09:08,480
De 50 trabajadores y decir

204
00:09:08,480 --> 00:09:11,299
Vosotros desarrolláis todos, ahí va, todos juntos, venga

205
00:09:11,299 --> 00:09:16,799
Necesito repartir estos trabajadores en varios módulos

206
00:09:16,799 --> 00:09:18,240
De mi sistema

207
00:09:18,240 --> 00:09:20,200
Y que cada uno de estos trabajadores

208
00:09:20,200 --> 00:09:22,899
Se ocupe de desarrollar ese módulo en concreto

209
00:09:22,899 --> 00:09:24,379
El problema surge

210
00:09:24,379 --> 00:09:27,159
Cuando estos módulos tienen que comunicar entre ellos

211
00:09:27,159 --> 00:09:28,460
Y yo tengo que utilizar

212
00:09:28,460 --> 00:09:31,159
Objetos que están siendo desarrollados

213
00:09:31,159 --> 00:09:32,340
Por otro equipo

214
00:09:32,340 --> 00:09:33,379
¿Vale?

215
00:09:33,600 --> 00:09:36,460
Para estar seguro de que puede

216
00:09:36,460 --> 00:09:38,179
Mi equipo

217
00:09:38,179 --> 00:09:40,779
Utilizar sobre los otros

218
00:09:40,779 --> 00:09:42,600
Objetos, lo que puedo utilizar

219
00:09:42,600 --> 00:09:43,440
Es una interfaz

220
00:09:43,440 --> 00:09:46,759
Yo no te estoy diciendo como se hará

221
00:09:46,759 --> 00:09:48,919
estas cosas. Te estoy diciendo

222
00:09:48,919 --> 00:09:51,120
que un objeto que implemente

223
00:09:51,120 --> 00:09:52,940
esta interfaz, seguramente

224
00:09:52,940 --> 00:09:54,539
tendrá el método calcular

225
00:09:54,539 --> 00:09:55,759
y calcular perímetro.

226
00:09:57,700 --> 00:09:58,919
Entonces, tú puedes

227
00:09:58,919 --> 00:10:00,519
crear los objetos que quieras

228
00:10:00,519 --> 00:10:02,580
de este tipo, de tipo comparable,

229
00:10:03,019 --> 00:10:04,759
utilizar métodos que

230
00:10:04,759 --> 00:10:07,019
llamen, que pillen como parámetro

231
00:10:07,019 --> 00:10:08,659
un objeto comparable

232
00:10:08,659 --> 00:10:10,799
y tú sabes que sobre el método

233
00:10:10,799 --> 00:10:12,279
comparable, sobre el objeto comparable,

234
00:10:12,679 --> 00:10:14,279
podrás llamar calcular

235
00:10:14,279 --> 00:10:16,279
y calcular perímetro.

236
00:10:16,279 --> 00:10:18,600
¿Cómo está hecho? No lo sé

237
00:10:18,600 --> 00:10:21,039
Lo implementará el otro equipo

238
00:10:21,039 --> 00:10:22,519
Pero yo estoy seguro

239
00:10:22,519 --> 00:10:24,419
Que puedo llamar esta lista

240
00:10:24,419 --> 00:10:25,820
De métodos

241
00:10:25,820 --> 00:10:28,679
Y sé que hace cada uno de estos métodos

242
00:10:28,679 --> 00:10:30,740
Porque la interfaz me lo explica

243
00:10:30,740 --> 00:10:32,399
Cuando tú usas estos métodos

244
00:10:32,399 --> 00:10:34,259
Le pasarás este parámetro

245
00:10:34,259 --> 00:10:36,519
Y obtendrás de vuelta este valor

246
00:10:36,519 --> 00:10:38,200
Calculado o no se sabe cómo

247
00:10:38,200 --> 00:10:39,539
Eso lo implementarán ellos

248
00:10:39,539 --> 00:10:42,440
A lo mejor para calcularlo tengo que acceder a una base de datos

249
00:10:42,440 --> 00:10:44,759
Acceder a un fichero, mezclar la base de datos

250
00:10:44,759 --> 00:10:45,519
El fichero

251
00:10:45,519 --> 00:10:48,179
Ir a hacer una conexión con otro servidor

252
00:10:48,179 --> 00:10:49,419
No lo sé, no me interesa

253
00:10:49,419 --> 00:10:51,179
Yo sé solo que si amo este método

254
00:10:51,179 --> 00:10:53,159
Me resuelve lo que tiene que resolver

255
00:10:53,159 --> 00:10:59,000
Esto tiene una potencia tremenda

256
00:10:59,000 --> 00:11:01,500
A la hora de modulizar mi sistema

257
00:11:01,500 --> 00:11:04,179
Yo tengo que poner de acuerdo

258
00:11:04,179 --> 00:11:06,500
Los varios grupos de trabajo

259
00:11:06,500 --> 00:11:08,220
Sobre lo que es la interfaz

260
00:11:08,220 --> 00:11:11,379
Donde son los puntos, digamos, de contacto

261
00:11:11,379 --> 00:11:13,080
Entre un módulo y otro

262
00:11:13,080 --> 00:11:15,080
Entre unas clases y otras

263
00:11:15,080 --> 00:11:17,379
Y explicarles

264
00:11:17,379 --> 00:11:19,360
Qué pueden hacer con estos objetos

265
00:11:19,360 --> 00:11:20,820
Luego ellos

266
00:11:20,820 --> 00:11:22,639
Lo llamarán sin problemas

267
00:11:22,639 --> 00:11:25,139
¿Vale? Cuando luego todo será

268
00:11:25,139 --> 00:11:27,720
Organizado y será creado

269
00:11:27,720 --> 00:11:29,620
Pues entonces yo al llamar

270
00:11:29,620 --> 00:11:31,179
Los métodos, en vez de llamarlos

271
00:11:31,179 --> 00:11:33,240
Pasándole un objeto comparable

272
00:11:33,240 --> 00:11:35,740
Que no existe el objeto comparable porque es una interfaz

273
00:11:35,740 --> 00:11:37,799
Le pasaré uno de los objetos

274
00:11:37,799 --> 00:11:39,240
Que implementan comparable

275
00:11:39,240 --> 00:11:41,139
Y en automático ello funcionará

276
00:11:41,139 --> 00:11:42,879
No sé si

277
00:11:42,879 --> 00:11:45,519
Luego hacemos ejemplos

278
00:11:45,519 --> 00:11:47,139
Pero por ahora

279
00:11:47,139 --> 00:11:49,820
Si os interesa

280
00:11:49,820 --> 00:11:50,320
¿Vale?

281
00:11:52,120 --> 00:11:54,080
El equipo que debe utilizar objetos

282
00:11:54,080 --> 00:11:56,600
Este es más o menos la explicación de lo que acabo de decir ahora

283
00:11:56,600 --> 00:11:58,519
Que implemente dicha interfaz

284
00:11:58,519 --> 00:12:00,259
Basta con que declare en su código

285
00:12:00,259 --> 00:12:01,759
Una referencia a dicha interfaz

286
00:12:01,759 --> 00:12:03,539
Si yo tengo esta interfaz

287
00:12:03,539 --> 00:12:05,639
No necesito crear un objeto

288
00:12:05,639 --> 00:12:08,259
Que implemente esa interfaz

289
00:12:08,259 --> 00:12:10,639
Sino que declaro una referencia

290
00:12:10,639 --> 00:12:11,980
A esa interfaz

291
00:12:11,980 --> 00:12:14,299
Ante la interfaz, como por ejemplo comparableX

292
00:12:14,299 --> 00:12:15,120
¿Vale?

293
00:12:15,360 --> 00:12:17,299
Y en automático puedo llamar sobre X

294
00:12:17,299 --> 00:12:18,899
Todos los métodos de la interfaz

295
00:12:18,899 --> 00:12:20,720
¿Dónde estará su implementación?

296
00:12:21,100 --> 00:12:23,399
Pues su implementación dependerá que luego

297
00:12:23,399 --> 00:12:25,200
Cuando yo asocio esta referencia

298
00:12:25,200 --> 00:12:27,159
A un objeto que implementa

299
00:12:27,159 --> 00:12:28,820
Esa interfaz

300
00:12:28,820 --> 00:12:30,659
Tendrá un

301
00:12:30,659 --> 00:12:32,399
El método

302
00:12:32,399 --> 00:12:35,139
Especificado e implementado

303
00:12:35,139 --> 00:12:37,340
Y por polimorfismo, cuando yo llamo

304
00:12:37,340 --> 00:12:39,639
Este método, no se llamará sobre la interfaz

305
00:12:39,639 --> 00:12:41,379
Que no existe, sino se llamará

306
00:12:41,379 --> 00:12:43,220
sobre la instancia, que será

307
00:12:43,220 --> 00:12:45,279
un objeto que sí tiene

308
00:12:45,279 --> 00:12:47,200
implementado ese método. Entonces

309
00:12:47,200 --> 00:12:49,399
funcionará. Es más de

310
00:12:49,399 --> 00:12:51,779
lo mismo de lo que hemos visto con las clases abstractas.

311
00:12:52,019 --> 00:12:53,279
¿Vale? Utilizando el

312
00:12:53,279 --> 00:12:54,799
polimorfismo, esto funciona.

313
00:12:55,159 --> 00:12:57,100
Si no hubiese polimorfismo, tendríamos

314
00:12:57,100 --> 00:12:59,600
un problema. Los equipos

315
00:12:59,600 --> 00:13:01,220
que creen clases que

316
00:13:01,220 --> 00:13:03,320
implementen dicha interfaz

317
00:13:03,320 --> 00:13:05,259
están a su vez desacoplados

318
00:13:05,259 --> 00:13:07,279
de los equipos que lo utilizan. ¿Vale?

319
00:13:07,860 --> 00:13:09,220
Esto es un concepto

320
00:13:09,220 --> 00:13:11,139
de desacoplar el trabajo. O sea,

321
00:13:11,139 --> 00:13:13,139
separar, individualizar

322
00:13:13,139 --> 00:13:15,639
e independizar en un cierto sentido

323
00:13:15,639 --> 00:13:17,480
el trabajo de un equipo

324
00:13:17,480 --> 00:13:18,360
de trabajo y de otro

325
00:13:18,360 --> 00:13:21,340
la ventaja de poner una interfaz

326
00:13:21,340 --> 00:13:23,100
en el medio es que por un lado

327
00:13:23,100 --> 00:13:25,360
puedo trabajar la implementación de esa

328
00:13:25,360 --> 00:13:27,120
interfaz y eso es un equipo de trabajo

329
00:13:27,120 --> 00:13:29,179
y por otro lado ya utilizar

330
00:13:29,179 --> 00:13:31,440
esa interfaz sin necesidad de tener

331
00:13:31,440 --> 00:13:33,600
una implementación

332
00:13:33,600 --> 00:13:33,980
real

333
00:13:33,980 --> 00:13:37,559
que me proporcionará más adelante

334
00:13:37,559 --> 00:13:39,019
¿se entiende?

335
00:13:39,019 --> 00:13:46,559
La idea es que podría haber un caso específico o casos específicos

336
00:13:46,559 --> 00:13:53,279
En que el equipo A, que es el que implementa la interfaz, está haciendo su trabajo

337
00:13:53,279 --> 00:13:58,419
Y que haya un equipo B que quiere utilizar esa interfaz

338
00:13:58,419 --> 00:14:03,039
Y por lo tanto está utilizando Comparable en general y está utilizando sus métodos

339
00:14:03,039 --> 00:14:09,360
Pero este equipo B necesita realmente un objeto para poder funcionar

340
00:14:09,360 --> 00:14:19,200
¿Vale? Porque algunos de los métodos no se basan solo sobre comparable, sino que tienen que llamarlos estos métodos y funcionar.

341
00:14:19,200 --> 00:14:31,919
¿Vale? Entonces, en casos como estos, Java proporciona los objetos mock, que nosotros por ahora no veremos, a lo mejor lo veremos más adelante, pero que os suelen como concepto.

342
00:14:31,919 --> 00:14:35,240
Un objeto mock es un objeto falso

343
00:14:35,240 --> 00:14:38,620
Es un objeto que no es verdad

344
00:14:38,620 --> 00:14:42,159
No es un objeto real que luego voy a utilizar

345
00:14:42,159 --> 00:14:47,399
Es un objeto falso que implementa en un cierto sentido

346
00:14:47,399 --> 00:14:52,340
La interfaz

347
00:14:52,340 --> 00:14:55,539
Pero me devuelve por ejemplo valores fijos

348
00:14:55,539 --> 00:14:57,120
O valores muy sencillos

349
00:14:57,120 --> 00:14:59,840
En vez de estar haciendo el acceso a la base de datos

350
00:14:59,840 --> 00:15:01,940
el acceso al fichero

351
00:15:01,940 --> 00:15:04,179
que decíamos antes, combinarlos y cosas por estilo

352
00:15:04,179 --> 00:15:05,779
que no tengo todavía listo

353
00:15:05,779 --> 00:15:07,039
porque todavía en eso está

354
00:15:07,039 --> 00:15:09,779
trabajando el otro equipo de desarrollo

355
00:15:09,779 --> 00:15:11,840
pues hago que

356
00:15:11,840 --> 00:15:13,620
si tú llamas este método te devuelvo 3

357
00:15:13,620 --> 00:15:16,240
y ya está

358
00:15:16,240 --> 00:15:18,000
claramente cada vez que lo utilizaré

359
00:15:18,000 --> 00:15:19,139
recibiré 3

360
00:15:19,139 --> 00:15:22,039
pero recibiré un posible

361
00:15:22,039 --> 00:15:23,799
valor real

362
00:15:23,799 --> 00:15:26,299
de esa

363
00:15:26,299 --> 00:15:27,980
interfaz

364
00:15:27,980 --> 00:15:28,659
de ese método

365
00:15:28,659 --> 00:15:32,080
Entonces es un poquito más complejo que esto

366
00:15:32,080 --> 00:15:34,059
Pero a esta altura

367
00:15:34,059 --> 00:15:35,500
Tampoco tiene mucho sentido

368
00:15:35,500 --> 00:15:37,320
Meter ese tipo de complejidad

369
00:15:37,320 --> 00:15:39,620
Porque por ahora esto no lo vamos a utilizar nosotros

370
00:15:39,620 --> 00:15:41,580
Esto simplemente para que os suene

371
00:15:41,580 --> 00:15:43,539
El concepto de mock object

372
00:15:43,539 --> 00:15:44,799
Que en un futuro

373
00:15:44,799 --> 00:15:46,899
Estáis trabajando y alguien dice

374
00:15:46,899 --> 00:15:48,820
Que aquí para poder

375
00:15:48,820 --> 00:15:51,860
Hacer el trabajo tenemos que hacer un objeto mock

376
00:15:51,860 --> 00:15:53,940
Y que vosotros no sabáis hacerlo

377
00:15:53,940 --> 00:15:55,340
Pero que sepáis que existe

378
00:15:55,340 --> 00:15:57,220
Y digáis, si me acuerdo de una vez

379
00:15:57,220 --> 00:15:58,580
Un tío que hablaba mal

380
00:15:58,580 --> 00:16:00,059
Me ha comentado algo de eso

381
00:16:00,059 --> 00:16:00,899
¿Vale?

382
00:16:02,440 --> 00:16:04,879
Si tenemos tiempo más adelante

383
00:16:04,879 --> 00:16:05,379
A lo mejor

384
00:16:05,379 --> 00:16:08,980
Ejemplo de interfaz

385
00:16:08,980 --> 00:16:09,879
¿Vale? Por ejemplo

386
00:16:09,879 --> 00:16:12,720
Un ejemplo muy interesante de interfaz

387
00:16:12,720 --> 00:16:14,340
Es la interfaz comparable

388
00:16:14,340 --> 00:16:16,320
¿Vale? Esta interfaz

389
00:16:16,320 --> 00:16:17,100
No la he creado yo

390
00:16:17,100 --> 00:16:19,620
Existe en Java

391
00:16:19,620 --> 00:16:21,139
Si vosotros os vais

392
00:16:21,139 --> 00:16:24,320
Si vosotros os vais a LAPI

393
00:16:24,320 --> 00:16:25,879
Y buscáis comparable

394
00:16:25,879 --> 00:16:28,519
Os sale la interfaz comparable

395
00:16:28,519 --> 00:16:31,100
Que incluye toda la información

396
00:16:31,100 --> 00:16:34,100
Sobre qué es la interfaz comparable

397
00:16:34,100 --> 00:16:36,320
Cómo se utiliza, para qué sirve, etc.

398
00:16:37,019 --> 00:16:39,360
El concepto es que una interfaz comparable

399
00:16:39,360 --> 00:16:40,480
Tiene un método

400
00:16:40,480 --> 00:16:42,279
Este método de aquí

401
00:16:42,279 --> 00:16:45,779
int compareToObjecto

402
00:16:45,779 --> 00:16:49,039
Esto es un método que

403
00:16:49,039 --> 00:16:50,399
Te devuelve un entero

404
00:16:50,399 --> 00:16:52,259
Se llama compareTo

405
00:16:52,259 --> 00:16:54,279
Y recibe otro objeto

406
00:16:54,279 --> 00:16:55,980
Tú lo llamarás sobre un objeto

407
00:16:55,980 --> 00:16:59,980
Y luego le pasas otro objeto como parámetro

408
00:16:59,980 --> 00:17:02,799
Entonces, aquí hay dos objetos en el medio

409
00:17:02,799 --> 00:17:05,819
El objeto que llama este método

410
00:17:05,819 --> 00:17:07,440
Mi objeto actual

411
00:17:07,440 --> 00:17:09,900
Y el objeto que le paso para comparar

412
00:17:09,900 --> 00:17:11,180
Porque claramente comparar tú

413
00:17:11,180 --> 00:17:12,579
Estoy comparando

414
00:17:12,579 --> 00:17:15,740
¿Y qué me dice que tiene que hacer este método?

415
00:17:16,140 --> 00:17:18,119
Este método tiene que devolver un entero

416
00:17:18,119 --> 00:17:19,779
Y este entero tiene que ser

417
00:17:19,779 --> 00:17:21,519
Un número negativo

418
00:17:21,519 --> 00:17:22,880
Por ejemplo, menos uno

419
00:17:22,880 --> 00:17:26,960
Si el objeto dis

420
00:17:26,960 --> 00:17:29,480
El objeto sobre el que le estoy llamando

421
00:17:29,480 --> 00:17:30,680
Es menor

422
00:17:30,680 --> 00:17:33,059
Que este objeto que le he pasado como parámetro

423
00:17:33,059 --> 00:17:36,660
Devuelve cero

424
00:17:36,660 --> 00:17:39,220
Si los dos son iguales

425
00:17:39,220 --> 00:17:42,440
Y devuelve un número positivo

426
00:17:42,440 --> 00:17:43,660
Por ejemplo uno

427
00:17:43,660 --> 00:17:45,079
Si dis

428
00:17:45,079 --> 00:17:47,319
El objeto sobre el que estoy llamando

429
00:17:47,319 --> 00:17:49,640
Es mayor

430
00:17:49,640 --> 00:17:51,039
Que el objeto

431
00:17:51,039 --> 00:17:59,619
En cuanto a tu definición de mayor y menor

432
00:17:59,619 --> 00:18:02,319
Tú tienes el objeto gato

433
00:18:02,319 --> 00:18:11,039
¿Cuándo el objeto gato1 que has creado tú es menor que el objeto gato2?

434
00:18:11,960 --> 00:18:13,900
Lo tienes que definir tú

435
00:18:13,900 --> 00:18:16,279
Oye, pero los gatos no son comparables

436
00:18:16,279 --> 00:18:19,019
Pues entonces no implementas la interfaz comparable

437
00:18:19,019 --> 00:18:22,079
Si tú implementas la interfaz comparable

438
00:18:22,079 --> 00:18:28,920
Implicitamente le estás diciendo que tu clase está adquiriendo una nueva propiedad

439
00:18:28,920 --> 00:18:34,920
En un cierto sentido que es comparable entre objetos de esa clase

440
00:18:34,920 --> 00:18:38,539
Y como son comparables los objetos de otra clase

441
00:18:38,539 --> 00:18:42,720
Tú tendrás que tener en tu mente una idea para poderlo comparar

442
00:18:42,720 --> 00:18:45,180
¿Cómo se comparan dos gatos?

443
00:18:45,859 --> 00:18:46,460
No lo sé

444
00:18:46,460 --> 00:18:47,579
¿Vale?

445
00:18:47,920 --> 00:18:48,460
¿Su edad?

446
00:18:48,460 --> 00:18:52,539
Pues entonces un gato más viejo es mayor que un gato más joven

447
00:18:52,539 --> 00:18:53,539
Vale, fenomenal

448
00:18:53,539 --> 00:18:56,920
Y entonces ahora ya tienes una forma de implementar esto

449
00:18:56,920 --> 00:19:02,539
En tu implementación de Compartoo mirarás el disk que será un gato

450
00:19:02,539 --> 00:19:04,000
¿Cuántos años tiene?

451
00:19:04,539 --> 00:19:10,140
El objeto los downcastarás a un gato siempre y cuando sea un gato

452
00:19:10,140 --> 00:19:13,180
Y mirarás su edad

453
00:19:13,180 --> 00:19:16,079
Y a ese punto devolverás menos uno

454
00:19:16,079 --> 00:19:18,180
si la edad del tuyo es

455
00:19:18,180 --> 00:19:19,759
menor que la edad de O

456
00:19:19,759 --> 00:19:21,519
le devolverás

457
00:19:21,519 --> 00:19:23,859
0 si la edad es la misma

458
00:19:23,859 --> 00:19:26,339
puede ser más complejo

459
00:19:26,339 --> 00:19:27,740
puede ser que un gato sea

460
00:19:27,740 --> 00:19:29,180
mayor si

461
00:19:29,180 --> 00:19:31,640
es más joven

462
00:19:31,640 --> 00:19:34,299
o menor, es más joven y es más pequeño

463
00:19:34,299 --> 00:19:35,900
porque hay también talla

464
00:19:35,900 --> 00:19:37,400
y allí hay varias cosas

465
00:19:37,400 --> 00:19:39,839
tú puedes complicar esta

466
00:19:39,839 --> 00:19:41,839
convertu, cuanto te dé la gana

467
00:19:41,839 --> 00:19:44,099
en la base de cómo

468
00:19:44,099 --> 00:19:45,920
tú ordenas los objetos

469
00:19:45,920 --> 00:19:49,599
¿Y cualquier objeto tiene que ser ordenable?

470
00:19:49,920 --> 00:19:50,259
No

471
00:19:50,259 --> 00:19:52,019
¿Vale?

472
00:19:52,019 --> 00:19:55,339
Todos los objetos que hemos estado haciendo hasta ahora

473
00:19:55,339 --> 00:19:57,960
No implementaban este comparable

474
00:19:57,960 --> 00:19:59,660
Por lo tanto, ¿cómo los ordenamos?

475
00:19:59,980 --> 00:20:01,480
No lo sé, no tengo ni idea

476
00:20:01,480 --> 00:20:02,099
¿Vale?

477
00:20:02,440 --> 00:20:02,819
Ahora

478
00:20:02,819 --> 00:20:06,819
Si yo quiero implementar este compareTo

479
00:20:06,819 --> 00:20:08,720
Entonces implementar compareable

480
00:20:08,720 --> 00:20:09,299
¿Vale?

481
00:20:10,720 --> 00:20:13,839
Necesito que en mi clase

482
00:20:13,839 --> 00:20:15,500
esté definida

483
00:20:15,500 --> 00:20:18,460
una idea de cómo se ordenan

484
00:20:18,460 --> 00:20:19,359
estos objetos

485
00:20:19,359 --> 00:20:22,400
¿vale? por ejemplo, una persona

486
00:20:22,400 --> 00:20:24,380
pues lo ordeno por su DNI

487
00:20:24,380 --> 00:20:25,660
miro el DNI

488
00:20:25,660 --> 00:20:28,279
y si el DNI pasado a

489
00:20:28,279 --> 00:20:30,339
número es menor

490
00:20:30,339 --> 00:20:31,900
que el otro, pues entonces

491
00:20:31,900 --> 00:20:34,180
declararé que es menor el objeto

492
00:20:34,180 --> 00:20:35,880
y si no es mayor, no lo sé

493
00:20:35,880 --> 00:20:38,579
depende de vosotros y de lo que estáis implementando

494
00:20:38,579 --> 00:20:40,200
¿vale? puede que haya

495
00:20:40,200 --> 00:20:42,259
cosas, si yo estoy haciendo la clase

496
00:20:42,259 --> 00:20:43,079
integer

497
00:20:43,079 --> 00:20:45,180
Que representa interos

498
00:20:45,180 --> 00:20:47,319
Que existe, está en Java

499
00:20:47,319 --> 00:20:47,859
¿Vale?

500
00:20:48,279 --> 00:20:50,559
Y que es un objeto que dentro tiene un int

501
00:20:50,559 --> 00:20:52,140
Y que sustantivamente hace

502
00:20:52,140 --> 00:20:53,940
Como un wrapping

503
00:20:53,940 --> 00:20:56,259
Hace como un

504
00:20:56,259 --> 00:20:57,079
Un

505
00:20:57,079 --> 00:20:59,720
Un vectorio

506
00:20:59,720 --> 00:21:03,000
De el número int

507
00:21:03,000 --> 00:21:05,000
Como primitivo y lo transforma en un objeto

508
00:21:05,000 --> 00:21:06,640
Integer que representa

509
00:21:06,640 --> 00:21:08,500
Ese número

510
00:21:08,500 --> 00:21:09,980
¿Vale? Lo veremos

511
00:21:09,980 --> 00:21:12,799
Bueno, lo hemos usado una vez con integer.parse

512
00:21:12,799 --> 00:21:14,619
Debe sonar

513
00:21:14,619 --> 00:21:16,119
Esa es la clase integer

514
00:21:16,119 --> 00:21:19,200
Que es un objeto que representa un entero

515
00:21:19,200 --> 00:21:20,059
¿Sí?

516
00:21:20,400 --> 00:21:22,200
¿Cómo ordeno los enteros?

517
00:21:22,519 --> 00:21:23,359
Es muy fácil

518
00:21:23,359 --> 00:21:25,140
Miro su valor

519
00:21:25,140 --> 00:21:27,920
Y su valor, si es menor que el otro entero

520
00:21:27,920 --> 00:21:29,680
Pues es menor

521
00:21:29,680 --> 00:21:31,059
Si es mayor, es mayor

522
00:21:31,059 --> 00:21:33,259
Y si son iguales, pues es cero

523
00:21:33,259 --> 00:21:36,440
Ordenar un entero es muy fácil

524
00:21:36,440 --> 00:21:38,420
Ordenar un gato

525
00:21:38,420 --> 00:21:39,660
O ordenar un animal

526
00:21:39,660 --> 00:21:41,059
Puede ser más complejo

527
00:21:41,059 --> 00:21:43,640
Y a lo mejor no tiene sentido

528
00:21:43,640 --> 00:21:45,440
Ordenar un animal

529
00:21:45,440 --> 00:21:48,619
¿Dudas?

530
00:21:50,059 --> 00:21:50,900
Entonces

531
00:21:50,900 --> 00:21:53,279
¿Y por qué debería yo

532
00:21:53,279 --> 00:21:55,140
Molestarme con

533
00:21:55,140 --> 00:21:57,519
La interfaz comparable

534
00:21:57,519 --> 00:21:58,059
E

535
00:21:58,059 --> 00:22:00,400
¿Cómo se dice?

536
00:22:00,559 --> 00:22:03,160
Implementarla y perder tiempo en crear

537
00:22:03,160 --> 00:22:05,079
Este objeto aquí cuando podría

538
00:22:05,079 --> 00:22:07,079
Tranquilamente crearme mi propio

539
00:22:07,079 --> 00:22:09,200
Comparar gatos

540
00:22:09,200 --> 00:22:10,460
Y ponerla ahí

541
00:22:10,460 --> 00:22:18,539
Porque en el ecosistema de Java, en el API, en todas las clases ya creadas que tenéis vosotros

542
00:22:18,539 --> 00:22:24,640
Hay clases que funcionan sobre objetos Convertible

543
00:22:24,640 --> 00:22:33,480
Es decir, que funcionan sabiendo que sobre los objetos de tipo Convertible pueden llamar el Convertu

544
00:22:33,480 --> 00:22:38,900
Y entonces si tú te haces una clase que implementa Convertible

545
00:22:38,900 --> 00:22:43,599
Automáticamente puedes utilizar todos esos métodos ya creados

546
00:22:43,599 --> 00:22:45,900
Sobre objetos de tu clase

547
00:22:45,900 --> 00:22:49,259
Si en vez tú no la implementas, no

548
00:22:49,259 --> 00:22:52,559
El ejemplo típico que haremos dentro de un rato

549
00:22:52,559 --> 00:22:53,559
El sort

550
00:22:53,559 --> 00:22:57,119
El sort sirve para ordenar

551
00:22:57,119 --> 00:23:00,039
Imaginamos que vosotros tenéis un array de objetos

552
00:23:00,039 --> 00:23:01,759
Y los queréis ordenar

553
00:23:01,759 --> 00:23:06,779
Para ordenarlos necesitáis un orden

554
00:23:06,779 --> 00:23:10,559
Que sean posibles de comparar entre ellos

555
00:23:10,559 --> 00:23:12,440
Si no, puedes comparar como los dos

556
00:23:12,440 --> 00:23:17,279
Entonces, existen métodos ya hechos

557
00:23:17,279 --> 00:23:20,240
Arrays.sort, por ejemplo

558
00:23:20,240 --> 00:23:22,019
Que te pillan un array

559
00:23:22,019 --> 00:23:23,440
Y te devuelven un array

560
00:23:23,440 --> 00:23:25,000
El mismo array ordenado

561
00:23:25,000 --> 00:23:28,400
Pero el objeto que te pillan

562
00:23:28,400 --> 00:23:30,259
Para poder hacer eso

563
00:23:30,259 --> 00:23:33,180
Necesariamente tiene que ser de tipo comparable

564
00:23:33,180 --> 00:23:36,220
Con eso ellos se aseguran

565
00:23:36,220 --> 00:23:39,339
Que para poder funcionar el ordenamiento

566
00:23:39,339 --> 00:23:41,000
Ellos pueden llamar

567
00:23:41,000 --> 00:23:42,079
Dentro el compareTo

568
00:23:42,079 --> 00:23:45,000
Y empezar a comparar los objetos

569
00:23:45,000 --> 00:23:46,779
Que están dentro de esta array

570
00:23:46,779 --> 00:23:48,480
Con el fin de decir

571
00:23:48,480 --> 00:23:50,299
Al final de todo este trabajo

572
00:23:50,299 --> 00:23:51,859
Pues te he ordenado la array

573
00:23:51,859 --> 00:23:54,900
Si no se pueden comparar entre ellos

574
00:23:54,900 --> 00:23:57,039
¿Qué puedo hacer?

575
00:23:58,319 --> 00:23:59,119
¿Me explico?

576
00:24:00,240 --> 00:24:00,720
Es más

577
00:24:00,720 --> 00:24:03,420
Si yo en vez de haber utilizado la interfaz compareMode

578
00:24:03,420 --> 00:24:05,240
Utilizo mi propio método

579
00:24:05,240 --> 00:24:06,359
Comparar gatos

580
00:24:06,359 --> 00:24:08,299
Que nadie conoce

581
00:24:08,299 --> 00:24:10,700
Pues la función sort

582
00:24:10,700 --> 00:24:12,680
Creada ya por otros desarrolladores

583
00:24:12,680 --> 00:24:14,400
No puede

584
00:24:14,400 --> 00:24:16,799
Adivinar que yo he creado

585
00:24:16,799 --> 00:24:17,740
Comparar gatos

586
00:24:17,740 --> 00:24:19,759
No me va a funcionar

587
00:24:19,759 --> 00:24:22,380
Pero lo que puede hacer es decir

588
00:24:22,380 --> 00:24:24,859
Mira, oye, yo me baso sobre una interfaz

589
00:24:24,859 --> 00:24:26,539
Esta interfaz de aquí, comparable

590
00:24:26,539 --> 00:24:28,599
Y sé que si tú implementas

591
00:24:28,599 --> 00:24:30,599
Esta comparable, habrás tenido

592
00:24:30,599 --> 00:24:32,940
Que implementar el compareTo

593
00:24:32,940 --> 00:24:34,339
Que dará

594
00:24:34,339 --> 00:24:36,380
exactamente este tipo de resultados

595
00:24:36,380 --> 00:24:38,720
negativo, cero

596
00:24:38,720 --> 00:24:40,460
o positivo, y yo podré

597
00:24:40,460 --> 00:24:41,380
entender

598
00:24:41,380 --> 00:24:44,500
estos números que me das

599
00:24:44,500 --> 00:24:46,579
para poder ayudarte

600
00:24:46,579 --> 00:24:48,980
a ordenar, independientemente

601
00:24:48,980 --> 00:24:50,900
de cual sea

602
00:24:50,900 --> 00:24:52,019
tu objeto

603
00:24:52,019 --> 00:24:54,599
si tú has hecho el objeto animal que implementas

604
00:24:54,599 --> 00:24:56,220
con parable, yo te lo puedo ordenar

605
00:24:56,220 --> 00:24:59,019
si tú has hecho el objeto vehículo que implementas

606
00:24:59,019 --> 00:25:00,839
con parable, yo te lo puedo ordenar

607
00:25:00,839 --> 00:25:02,400
porque tú al fin y al cabo

608
00:25:02,400 --> 00:25:04,200
Cuando implementas comparable

609
00:25:04,200 --> 00:25:06,539
Lo que me estás dando es un criterio

610
00:25:06,539 --> 00:25:07,339
Para ordenar

611
00:25:07,339 --> 00:25:10,720
Una forma de comparar dos objetos

612
00:25:10,720 --> 00:25:12,279
De tu clase y decir

613
00:25:12,279 --> 00:25:14,240
Cuál viene antes y cuál viene después

614
00:25:14,240 --> 00:25:16,759
Y sobre esta base yo puedo hacer

615
00:25:16,759 --> 00:25:18,119
Ordenación

616
00:25:18,119 --> 00:25:21,299
Este es un ejemplo

617
00:25:21,299 --> 00:25:24,700
Muy importante de cómo funcionan

618
00:25:24,700 --> 00:25:25,400
Las interfaces

619
00:25:25,400 --> 00:25:28,099
Yo he creado toda una serie de métodos

620
00:25:28,099 --> 00:25:29,559
Que se basan sobre el hecho que

621
00:25:29,559 --> 00:25:32,099
Tú me has dado un criterio de comparación

622
00:25:32,099 --> 00:25:34,500
Y yo hago todos mis métodos

623
00:25:34,500 --> 00:25:35,779
Basándome sobre ese criterio

624
00:25:35,779 --> 00:25:38,359
Cualquier método que implemente

625
00:25:38,359 --> 00:25:40,380
Esa interfaz, también podrá utilizar

626
00:25:40,380 --> 00:25:42,400
Todos mis métodos

627
00:25:42,400 --> 00:25:45,950
¿Dudas?

628
00:25:49,000 --> 00:25:51,500
Hay varias interfaces ya existentes

629
00:25:52,099 --> 00:25:53,200
Y algunas de ellas

630
00:25:53,200 --> 00:25:54,839
La iremos viendo, ¿vale?

631
00:25:55,220 --> 00:25:57,700
Por ejemplo, con Parable lo utilizaremos

632
00:25:57,700 --> 00:25:59,420
También está otra que se llama

633
00:25:59,420 --> 00:26:01,500
Serializable

634
00:26:02,559 --> 00:26:03,500
Serializable

635
00:26:04,420 --> 00:26:05,380
¿Vale?

636
00:26:05,380 --> 00:26:07,819
Serializable quiere decir que tú puedes

637
00:26:07,819 --> 00:26:10,240
Pillar un objeto y trocearlos

638
00:26:10,240 --> 00:26:11,200
En byte

639
00:26:11,200 --> 00:26:14,220
Y mandarlo byte a byte

640
00:26:14,220 --> 00:26:16,319
La cosa interesante de eso

641
00:26:16,319 --> 00:26:18,319
Es que luego puedes guardar objetos

642
00:26:18,319 --> 00:26:19,259
En un fichero

643
00:26:19,259 --> 00:26:21,599
O mandar objetos

644
00:26:21,599 --> 00:26:23,960
En internet

645
00:26:23,960 --> 00:26:25,099
A otro ordenador

646
00:26:25,099 --> 00:26:26,799
¿Vale?

647
00:26:27,160 --> 00:26:29,940
Si la clase que tú haces implementa

648
00:26:29,940 --> 00:26:32,359
Serializable, entonces yo le enseño

649
00:26:32,359 --> 00:26:34,039
Cómo se puede

650
00:26:34,039 --> 00:26:35,619
Trocear a byte

651
00:26:35,619 --> 00:26:37,019
Mi objeto

652
00:26:37,019 --> 00:26:39,660
Pues entonces automáticamente

653
00:26:39,660 --> 00:26:42,279
Aquí te da la posibilidad de ser guardado en un fichero

654
00:26:42,279 --> 00:26:45,079
No los carácteres

655
00:26:45,079 --> 00:26:46,140
El objeto

656
00:26:46,140 --> 00:26:47,599
No sé si entendéis la diferencia

657
00:26:47,599 --> 00:26:49,980
Que luego puede llegar otro programa

658
00:26:49,980 --> 00:26:52,220
Y pillarse el objeto

659
00:26:52,220 --> 00:26:54,900
No los carácteres que representa

660
00:26:54,900 --> 00:26:56,079
O no el gasto

661
00:26:56,079 --> 00:26:57,859
El objeto que tú has guardado

662
00:26:57,859 --> 00:27:05,099
Si tu clase es serializable

663
00:27:05,099 --> 00:27:07,140
Es decir que luego tú podrás utilizar

664
00:27:07,140 --> 00:27:08,579
El método que sea

665
00:27:08,579 --> 00:27:10,500
Para poder escribir un fichero y leerlo

666
00:27:10,500 --> 00:27:12,059
Pero el objeto es serializable

667
00:27:12,059 --> 00:27:13,140
Es la misma clase

668
00:27:13,140 --> 00:27:15,980
Si tienes un gato serializable

669
00:27:15,980 --> 00:27:17,140
Y guardas el gato

670
00:27:17,140 --> 00:27:19,920
Pues para sacarlo tendrás que tener la misma clase

671
00:27:19,920 --> 00:27:22,059
Y decir, oye mira saco un objeto de esta clase

672
00:27:22,059 --> 00:27:22,779
¿Vale?

673
00:27:23,000 --> 00:27:25,180
Aún así, esto es cosas avanzadas

674
00:27:25,180 --> 00:27:27,519
Las veremos cuando veremos persistencia de objetos

675
00:27:27,519 --> 00:27:30,279
Y veremos como se guardan las cosas en ficheros

676
00:27:30,279 --> 00:27:30,799
¿Vale?

677
00:27:31,059 --> 00:27:32,920
Y será cosa que es de tercero

678
00:27:32,920 --> 00:27:36,359
¿Vale?

679
00:27:42,640 --> 00:27:49,140
Otra cosilla, ¿os acordáis que en Object existía un método que se llama Equals?

680
00:27:49,579 --> 00:27:50,259
¿Vale?

681
00:27:50,599 --> 00:27:53,440
Que era para ver si dos objetos son iguales

682
00:27:53,440 --> 00:27:56,559
Cuidado, que si yo implemento Comparable

683
00:27:56,559 --> 00:28:02,059
Y entonces doy una definición de cuando dos objetos son iguales

684
00:28:02,059 --> 00:28:05,000
Porque tengo que devolver un cero cuando son iguales

685
00:28:05,000 --> 00:28:12,279
Pues esta definición tiene que ser consistente con la implementación del Equals

686
00:28:12,279 --> 00:28:17,759
Equals me tiene que dar true

687
00:28:17,759 --> 00:28:21,099
Cuando esto me da cero

688
00:28:21,099 --> 00:28:23,519
Y solo cuando esto me da cero

689
00:28:23,519 --> 00:28:27,400
No puedo tener casos en el que esto me dice

690
00:28:27,400 --> 00:28:29,279
Si son iguales y luego voy al equals

691
00:28:29,279 --> 00:28:30,059
Y me dice falso

692
00:28:30,059 --> 00:28:32,160
Sería un problema

693
00:28:32,160 --> 00:28:35,480
Crearía inconsistencias en que si estoy comparando

694
00:28:35,480 --> 00:28:36,759
Dos objetos que lo compares tú

695
00:28:36,759 --> 00:28:37,880
Me dice si son el mismo

696
00:28:37,880 --> 00:28:39,779
Y si lo intento comparar con el equals

697
00:28:39,779 --> 00:28:40,759
Me dice no son distintos

698
00:28:40,759 --> 00:28:43,619
Entonces cuidado también

699
00:28:43,619 --> 00:28:44,680
Que como

700
00:28:44,680 --> 00:28:47,400
Os acordáis que el equals por defecto

701
00:28:47,400 --> 00:28:48,759
El equals de object

702
00:28:48,759 --> 00:28:51,880
Compara las referencias

703
00:28:51,880 --> 00:28:54,099
Si yo voy a implementar

704
00:28:54,099 --> 00:28:55,880
El comparable con compareTo

705
00:28:55,880 --> 00:28:57,779
Entonces estoy implementando esto de aquí

706
00:28:57,779 --> 00:28:59,319
Pues lo más probable

707
00:28:59,319 --> 00:29:01,819
Que tendré también que sobre escribir

708
00:29:01,819 --> 00:29:04,079
Override el equals

709
00:29:04,079 --> 00:29:05,839
Para que sea consistente

710
00:29:05,839 --> 00:29:09,779
Si dejo el equals de object

711
00:29:09,779 --> 00:29:12,079
Y implemento el compareTo

712
00:29:12,079 --> 00:29:13,759
Para mis objetos

713
00:29:13,759 --> 00:29:16,779
Lo más probable es que luego no sean consistentes

714
00:29:16,779 --> 00:29:19,400
Porque estoy comparando cosas distintas

715
00:29:19,400 --> 00:29:21,640
Habíamos dicho que los gatos comparaban su edad

716
00:29:21,640 --> 00:29:23,900
Mientras el equals de object

717
00:29:23,900 --> 00:29:25,660
Compara si son la misma referencia

718
00:29:25,660 --> 00:29:27,940
Por lo tanto, darían cosas distintas

719
00:29:27,940 --> 00:29:29,619
Si yo tengo dos gatos de la misma edad

720
00:29:29,619 --> 00:29:31,000
Que son dos objetos distintos

721
00:29:31,000 --> 00:29:32,900
CompareTo me daría cero

722
00:29:32,900 --> 00:29:34,079
Porque tienen la misma edad

723
00:29:34,079 --> 00:29:36,759
Y equals me daría falso porque son objetos distintos

724
00:29:36,759 --> 00:29:39,160
Eso no puede pasar

725
00:29:39,160 --> 00:29:54,430
Un ejemplo práctico de interfaz

726
00:29:54,430 --> 00:29:55,569
Vamos a verlo

727
00:29:55,569 --> 00:29:57,309
Entonces aquí tenemos

728
00:29:57,309 --> 00:30:00,809
Una interfaz animal

729
00:30:00,809 --> 00:30:02,410
Aquí

730
00:30:02,410 --> 00:30:05,990
Mi interfaz animal

731
00:30:05,990 --> 00:30:07,329
Que estará en un fichero

732
00:30:07,329 --> 00:30:10,569
Tiene el método habla

733
00:30:10,569 --> 00:30:12,670
Que devuelve nada

734
00:30:12,670 --> 00:30:14,289
Aquí debería explicar

735
00:30:14,289 --> 00:30:15,410
Que hace habla

736
00:30:15,410 --> 00:30:16,690
Que cuando habla un animal

737
00:30:16,690 --> 00:30:18,349
Pues hace su sonido

738
00:30:18,349 --> 00:30:19,329
Sea cual sea

739
00:30:19,329 --> 00:30:22,450
Entonces

740
00:30:22,450 --> 00:30:26,089
Esto quiere decir que cualquier

741
00:30:26,089 --> 00:30:29,130
Clase que implemente animal

742
00:30:29,130 --> 00:30:31,150
Tiene que implementar

743
00:30:31,150 --> 00:30:31,549
Habla

744
00:30:31,549 --> 00:30:33,910
Si no, me da un error

745
00:30:33,910 --> 00:30:36,789
Entonces me voy a crear perro

746
00:30:36,789 --> 00:30:40,650
Public class perro

747
00:30:40,650 --> 00:30:43,049
Implements animal

748
00:30:43,049 --> 00:30:44,130
Este es otro fichero

749
00:30:44,130 --> 00:30:47,549
Si os fijáis aquí no pongo extends

750
00:30:47,549 --> 00:30:48,710
Pongo implements

751
00:30:48,710 --> 00:30:54,970
Se puede extender una cosa

752
00:30:54,970 --> 00:30:57,009
Y implements varias cosas

753
00:30:57,009 --> 00:30:59,490
Mientras extends

754
00:30:59,490 --> 00:31:00,890
Siempre es una sola clase

755
00:31:00,890 --> 00:31:02,430
Extendo una clase

756
00:31:02,430 --> 00:31:05,190
Pero puedo implementar cuantas clases me da la gana

757
00:31:05,190 --> 00:31:08,009
Cuantas interfaces

758
00:31:08,009 --> 00:31:09,910
Entonces aquí dentro

759
00:31:09,910 --> 00:31:11,890
Yo puedo hacer lo que me da la gana con perro

760
00:31:11,890 --> 00:31:13,910
Poner todas las variables que quiera

761
00:31:14,130 --> 00:31:15,710
Todos los métodos que quiero

762
00:31:15,710 --> 00:31:18,230
Pero necesariamente tendré que tener

763
00:31:18,230 --> 00:31:19,569
Una implementación de

764
00:31:19,569 --> 00:31:21,190
Habla

765
00:31:21,190 --> 00:31:23,430
Igual a la de anterior, ¿vale?

766
00:31:23,490 --> 00:31:26,390
En concreto, esto puede cambiar el public

767
00:31:26,390 --> 00:31:28,170
¿Vale? No puede ser

768
00:31:28,170 --> 00:31:30,230
Más restrictivo

769
00:31:30,950 --> 00:31:32,309
¿Vale?

770
00:31:32,670 --> 00:31:34,049
O sea que public lo puedo poner

771
00:31:34,049 --> 00:31:36,289
Pero si intento poner aquí algo como

772
00:31:36,289 --> 00:31:37,750
Private, me va a decir no

773
00:31:37,750 --> 00:31:40,150
Porque la definición arriba no ponía

774
00:31:40,150 --> 00:31:41,470
Public o no ponía private

775
00:31:41,470 --> 00:31:42,150
¿Vale?

776
00:31:42,150 --> 00:31:47,470
Entonces, ¿qué hace el método habla cuando es un perro?

777
00:31:47,569 --> 00:31:48,789
Pues se escribe guau

778
00:31:48,789 --> 00:31:52,650
Una fantástica implementación

779
00:31:52,650 --> 00:31:54,730
Por otro lado, tengo gato

780
00:31:54,730 --> 00:31:59,990
Que cuando implementa habla, porque él implementa animals

781
00:31:59,990 --> 00:32:02,769
Por lo tanto, tiene que implementar el método habla

782
00:32:02,769 --> 00:32:05,329
Y lo que hace es escribir miau

783
00:32:05,329 --> 00:32:07,250
Cada animal dice lo suyo

784
00:32:07,250 --> 00:32:09,190
¿Cómo se usa esto?

785
00:32:09,190 --> 00:32:12,670
Entonces aquí tenemos una clase

786
00:32:12,670 --> 00:32:14,289
Main

787
00:32:14,289 --> 00:32:15,109
¿Vale?

788
00:32:15,990 --> 00:32:17,630
En el que el main dice

789
00:32:17,630 --> 00:32:19,670
Me creo un animal

790
00:32:19,670 --> 00:32:21,250
¿Lo puede hacer esto?

791
00:32:22,849 --> 00:32:23,609
Sí

792
00:32:23,609 --> 00:32:25,490
¿Perro qué es?

793
00:32:27,069 --> 00:32:28,269
Una clase

794
00:32:28,269 --> 00:32:30,150
Y new perro es un

795
00:32:30,150 --> 00:32:34,259
Instancia de tipo perro

796
00:32:34,259 --> 00:32:35,240
Es un objeto

797
00:32:35,240 --> 00:32:36,099
¿Sí?

798
00:32:36,680 --> 00:32:37,619
¿Animal qué es?

799
00:32:38,299 --> 00:32:41,150
Es una interfaz

800
00:32:41,150 --> 00:32:47,109
Si os fijáis, aquí estoy utilizando el tipo de la interfaz como si fuera una variable

801
00:32:47,109 --> 00:32:50,730
Interfaz no es ni siquiera una clase, ¿vale?

802
00:32:51,230 --> 00:32:54,410
Pero lo hemos visto ya con las clases abstractas

803
00:32:54,410 --> 00:32:57,950
Aquí lo que estamos utilizando es dando un tipo a esta interfaz

804
00:32:57,950 --> 00:33:00,589
Que es un tipo más genérico de lo que es de verdad

805
00:33:00,589 --> 00:33:05,190
Pero un perro cuando implementa un animal, ¿vale?

806
00:33:05,250 --> 00:33:08,769
Cuando implementa la interfaz animal, un perro puede ser un animal

807
00:33:08,769 --> 00:33:14,009
En este sentido lo que estamos diciendo es que cuando yo utilizo animal dog, por ejemplo aquí

808
00:33:14,009 --> 00:33:21,170
Quiere decir que el objeto referenciado por dog implementa esa interfaz

809
00:33:21,170 --> 00:33:29,789
Y por lo tanto, cuando usaré dog, podré usar todos los métodos que están definidos en la interfaz animal

810
00:33:29,789 --> 00:33:35,769
No podré utilizar lo que está definido solo en perro

811
00:33:35,769 --> 00:33:39,089
Si perro tuviera también otro

812
00:33:39,089 --> 00:33:41,269
Método que es

813
00:33:41,269 --> 00:33:42,130
Correr

814
00:33:42,130 --> 00:33:44,630
Pues no lo podría utilizar

815
00:33:44,630 --> 00:33:46,690
Porque desde animal

816
00:33:46,690 --> 00:33:47,849
Correr no existe

817
00:33:47,849 --> 00:33:50,789
Debería hacer un downcasting a perro

818
00:33:50,789 --> 00:33:52,210
Y lo puede utilizar

819
00:33:52,210 --> 00:33:53,369
Justo

820
00:33:53,369 --> 00:33:56,170
Entonces

821
00:33:56,170 --> 00:33:58,670
Yo quiero animal dog perro

822
00:33:58,670 --> 00:33:59,890
Y animal dog gato

823
00:33:59,890 --> 00:34:01,450
He creado dos animales

824
00:34:01,450 --> 00:34:04,390
Y como tanto perro como gato

825
00:34:04,390 --> 00:34:05,509
Implementan animal

826
00:34:05,509 --> 00:34:06,750
Pues lo puedo crear así

827
00:34:06,750 --> 00:34:10,090
Cuando llamaré dog.habla

828
00:34:10,090 --> 00:34:11,050
Me escribirá

829
00:34:11,050 --> 00:34:16,989
Cuando llamaré cat.habla

830
00:34:16,989 --> 00:34:18,170
Me escribirá

831
00:34:18,170 --> 00:34:21,369
Pero estos dos son animales

832
00:34:21,369 --> 00:34:23,050
¿Cómo descubre

833
00:34:23,050 --> 00:34:25,150
Cuáles de los métodos que tiene que utilizar?

834
00:34:26,349 --> 00:34:27,210
Gracias al

835
00:34:27,210 --> 00:34:30,969
Polimorfismo, nuestro mejor amigo

836
00:34:30,969 --> 00:34:32,869
Vamos a ver

837
00:34:32,869 --> 00:34:35,329
Otra cosa interesante

838
00:34:35,329 --> 00:34:37,389
¿Vale? Me creo un array

839
00:34:37,389 --> 00:34:39,250
De animales, esto ya lo hemos hecho

840
00:34:39,250 --> 00:34:41,170
Es muy parecido a lo que hemos hecho con las

841
00:34:41,170 --> 00:34:43,469
Trastes abstractas

842
00:34:43,469 --> 00:34:45,590
¿No? Hasta ahora hemos estado trabajando más o menos así

843
00:34:45,590 --> 00:34:47,570
Pongo

844
00:34:47,570 --> 00:34:49,610
Dog en posición 0

845
00:34:49,610 --> 00:34:50,829
Y cat en posición 1

846
00:34:50,829 --> 00:34:53,289
Lo puedo hacer, fijaos que estoy

847
00:34:53,289 --> 00:34:54,710
En un array de animal

848
00:34:54,710 --> 00:34:56,989
Donde he metido dentro una referencia animal

849
00:34:56,989 --> 00:34:58,329
Que en realidad es un perro

850
00:34:58,329 --> 00:35:01,469
Y una referencia cat que es un animal

851
00:35:01,469 --> 00:35:02,969
Que en realidad es un gato

852
00:35:02,969 --> 00:35:05,309
Pero los puedo poner todo en animal

853
00:35:05,309 --> 00:35:06,829
Porque tanto perros como gatos

854
00:35:06,829 --> 00:35:09,449
Implementan la interfaz

855
00:35:09,449 --> 00:35:12,030
Y luego lo que hago es

856
00:35:12,030 --> 00:35:13,530
Que hablen todos

857
00:35:13,530 --> 00:35:15,130
Y le paso este

858
00:35:15,130 --> 00:35:17,070
Array

859
00:35:17,070 --> 00:35:19,710
Que hables todo que es

860
00:35:19,710 --> 00:35:22,610
Como

861
00:35:22,610 --> 00:35:30,579
Estático

862
00:35:30,579 --> 00:35:32,059
Cursiva

863
00:35:32,059 --> 00:35:32,780
¿Cómo se llama?

864
00:35:33,880 --> 00:35:34,739
Lo llamamos loco

865
00:35:34,739 --> 00:35:36,460
¿Sí?

866
00:35:37,500 --> 00:35:40,019
Este es un método estático porque estoy en el main

867
00:35:40,019 --> 00:35:42,400
Para llamarlo, bueno, podría no ser estático

868
00:35:42,400 --> 00:35:44,360
Si esto fuera un objeto, no pasaría nada

869
00:35:44,360 --> 00:35:45,880
¿Vale? Lo que me interesa

870
00:35:45,880 --> 00:35:48,519
Es que entendáis que le estoy pasando un qué

871
00:35:48,519 --> 00:35:51,559
Un rey de qué

872
00:35:51,559 --> 00:35:53,780
Un rey de animales

873
00:35:53,780 --> 00:35:56,659
¿Sí? Aquí no hay gatos ni perros

874
00:35:56,659 --> 00:35:57,659
Un rey de animales

875
00:35:57,659 --> 00:36:00,219
Y de hecho, si os fijáis aquí

876
00:36:00,219 --> 00:36:01,840
Lo que recibe él

877
00:36:01,840 --> 00:36:03,239
Es un rey de animales

878
00:36:03,239 --> 00:36:06,500
Me da igual que haya dentro

879
00:36:06,500 --> 00:36:09,219
Esta cosa de aquí

880
00:36:09,219 --> 00:36:11,519
Animal, array de animales

881
00:36:11,519 --> 00:36:14,360
Me está diciendo que me van a pasar

882
00:36:14,360 --> 00:36:15,880
Un array de objetos

883
00:36:15,880 --> 00:36:18,360
Y los objetos que están ahí dentro

884
00:36:18,360 --> 00:36:20,760
Todos cumplen con un requisito

885
00:36:20,760 --> 00:36:21,199
¿Qué es?

886
00:36:26,559 --> 00:36:28,559
Todos los que están ahí dentro

887
00:36:28,559 --> 00:36:30,960
Tienen un requisito

888
00:36:30,960 --> 00:36:32,780
Todos los arrays que estarán

889
00:36:32,780 --> 00:36:34,900
Dentro de este array

890
00:36:34,900 --> 00:36:37,039
Todos los objetos que estarán

891
00:36:37,039 --> 00:36:37,840
Dentro de este array

892
00:36:37,840 --> 00:36:39,179
Cumplen con un requisito

893
00:36:39,179 --> 00:36:39,579
¿Qué es?

894
00:36:39,579 --> 00:36:42,920
Implementan

895
00:36:42,920 --> 00:36:45,360
La interfaz animal

896
00:36:45,360 --> 00:36:47,480
¿Vale? Entonces en cualquier

897
00:36:47,480 --> 00:36:49,000
Objeto de

898
00:36:49,000 --> 00:36:51,679
Este array, ¿qué podré hacer yo?

899
00:36:55,119 --> 00:36:55,619
Llamar

900
00:36:55,619 --> 00:36:57,699
Los métodos de la interfaz animal

901
00:36:57,699 --> 00:37:01,099
Y entonces aquí

902
00:37:01,099 --> 00:37:04,039
Puedo tranquilamente hacer un for

903
00:37:04,039 --> 00:37:05,440
¡Uy! ¿Qué es esto?

904
00:37:05,440 --> 00:37:07,079
Sí, es una cosa que hemos visto

905
00:37:07,079 --> 00:37:09,079
Y que se os ha olvidado porque no utilizáis nunca

906
00:37:09,079 --> 00:37:11,360
¿Vale? Puedo pillar

907
00:37:11,360 --> 00:37:13,539
Cada uno de los animales

908
00:37:13,539 --> 00:37:14,900
Que están dentro de animales

909
00:37:14,900 --> 00:37:16,559
Y decirle que hable

910
00:37:16,559 --> 00:37:19,940
Este es equivalente a poner

911
00:37:19,940 --> 00:37:22,199
Porinte igual a cero

912
00:37:22,199 --> 00:37:24,059
Y menor que

913
00:37:24,059 --> 00:37:25,840
Animales punto lente

914
00:37:25,840 --> 00:37:26,699
Y más más

915
00:37:26,699 --> 00:37:30,059
Y aquí poner animales de i

916
00:37:30,059 --> 00:37:31,460
Punto habla

917
00:37:31,460 --> 00:37:37,880
Fijaos que

918
00:37:37,880 --> 00:37:40,179
Imaginaos que esta cosa

919
00:37:40,179 --> 00:37:42,460
no lo hayáis creado vosotros

920
00:37:42,460 --> 00:37:44,119
ma otro equipo de trabajo

921
00:37:44,119 --> 00:37:46,320
necesitaba

922
00:37:46,320 --> 00:37:48,579
el haber implementado

923
00:37:48,579 --> 00:37:50,460
el método habla

924
00:37:50,460 --> 00:37:52,280
para poder

925
00:37:52,280 --> 00:37:53,079
hacer este código

926
00:37:53,079 --> 00:37:55,739
no

927
00:37:55,739 --> 00:37:58,199
vale, yo no sé

928
00:37:58,199 --> 00:37:59,860
como se hace este método

929
00:37:59,860 --> 00:38:02,300
yo lo único que sé es que como estoy

930
00:38:02,300 --> 00:38:04,280
utilizando animal que es una

931
00:38:04,280 --> 00:38:06,280
una interfaz y tú me has dado

932
00:38:06,280 --> 00:38:08,280
la interfaz que es solo el prototipo

933
00:38:08,280 --> 00:38:10,760
Yo sé que puedo llamar habla

934
00:38:10,760 --> 00:38:13,420
Sobre todos los objetos de este array

935
00:38:13,420 --> 00:38:14,780
Y lo llamo

936
00:38:14,780 --> 00:38:16,900
Luego lo que hará

937
00:38:16,900 --> 00:38:19,340
Cómo se hará y por qué se hará

938
00:38:19,340 --> 00:38:20,480
Pues eso a mí no me importa

939
00:38:20,480 --> 00:38:22,460
Lo está desarrollando otro equipo

940
00:38:22,460 --> 00:38:28,380
Pero estoy seguro que lo puedo utilizar

941
00:38:28,380 --> 00:38:30,300
Porque todos los objetos

942
00:38:30,300 --> 00:38:31,500
Que están en este array

943
00:38:31,500 --> 00:38:32,659
Son de tipo animal

944
00:38:32,659 --> 00:38:35,760
Que quiere decir que están implementando la interfaz animal

945
00:38:35,760 --> 00:38:42,260
Esto, sobre todo a nivel de diseño

946
00:38:42,260 --> 00:38:44,219
Es una cosa muy potente

947
00:38:44,219 --> 00:38:44,880
Muy interesante

948
00:38:44,880 --> 00:38:48,440
Como nosotros nos centramos más en la implementación

949
00:38:48,440 --> 00:38:49,820
Que en el diseño, muchas veces

950
00:38:49,820 --> 00:38:51,480
En los exámenes o en los ejercicios

951
00:38:51,480 --> 00:38:52,940
El diseño se lo doy yo

952
00:38:52,940 --> 00:38:54,199
Os doy

953
00:38:54,199 --> 00:38:57,760
Hacer tres clases, esta clase, esta clase

954
00:38:57,760 --> 00:38:59,460
Os he dado ya el diseño

955
00:38:59,460 --> 00:39:00,599
Pues entonces

956
00:39:00,599 --> 00:39:03,760
A lo mejor os cuesta un poquito más

957
00:39:03,760 --> 00:39:05,460
Ver la potencia de esta cosa

958
00:39:05,460 --> 00:39:06,920
Pero en la realidad

959
00:39:06,920 --> 00:39:08,440
Pues no lo tengo

960
00:39:08,440 --> 00:39:11,780
Tanto para las interfaces que puedo crear yo

961
00:39:11,780 --> 00:39:13,780
como es aquí, esta interfaz la he creado yo

962
00:39:13,780 --> 00:39:15,820
como puede ser para interfaces

963
00:39:15,820 --> 00:39:17,420
ya existentes a Java

964
00:39:17,420 --> 00:39:20,059
como Compatible, Serializable

965
00:39:20,059 --> 00:39:21,159
no sé cómo se dice en inglés

966
00:39:21,159 --> 00:39:23,340
o Serializable o lo que sea

967
00:39:23,340 --> 00:39:24,579
y hay muchas

968
00:39:24,579 --> 00:39:27,300
también

969
00:39:27,300 --> 00:39:30,019
repito un poquito lo que he dicho

970
00:39:30,019 --> 00:39:31,820
antes, la cosa interesante es que

971
00:39:31,820 --> 00:39:33,380
luego en el ecosistema de Java

972
00:39:33,380 --> 00:39:35,139
en todas las clases que ya existen

973
00:39:35,139 --> 00:39:37,380
que son muchas, muchas, muchas clases

974
00:39:37,380 --> 00:39:40,039
muchas veces yo no sé

975
00:39:40,039 --> 00:39:41,699
el objeto que vas a utilizar tú

976
00:39:41,699 --> 00:39:43,440
Pero voy a utilizar

977
00:39:43,440 --> 00:39:45,619
Interfaces ya existentes

978
00:39:45,619 --> 00:39:47,380
Asumiendo que si tú

979
00:39:47,380 --> 00:39:49,059
Implementas esa interfaz

980
00:39:49,059 --> 00:39:51,679
Entonces, obviamente, a mí me estás dando herramientas

981
00:39:51,679 --> 00:39:53,579
De algunos métodos que puedo llamar

982
00:39:53,579 --> 00:39:55,019
Y por lo tanto yo puedo hacer

983
00:39:55,019 --> 00:39:56,980
Un programa

984
00:39:56,980 --> 00:40:00,039
General, como es este método

985
00:40:00,039 --> 00:40:01,940
De aquí, el método que hablen todos

986
00:40:01,940 --> 00:40:03,739
Basado sobre el hecho que

987
00:40:03,739 --> 00:40:05,900
Tú habrás dado una implementación

988
00:40:05,900 --> 00:40:06,559
De ese método

989
00:40:06,559 --> 00:40:09,039
No sé cuál es, pero sé que lo tendrás

990
00:40:09,039 --> 00:40:10,219
Y todo lo puedo utilizar

991
00:40:10,219 --> 00:40:12,039
Y sé lo que tiene que hacer

992
00:40:12,039 --> 00:40:15,019
La descripción de habla es que haga su sonido

993
00:40:15,019 --> 00:40:17,219
Hay que calcular el área del triángulo

994
00:40:17,219 --> 00:40:20,980
Entonces, basándome sobre eso

995
00:40:20,980 --> 00:40:22,360
Puedo hacer cosas muy interesantes

996
00:40:22,360 --> 00:40:24,360
Cuando yo entro en este mundo

997
00:40:24,360 --> 00:40:26,440
Y tengo mi nuevo objeto nuevo

998
00:40:26,440 --> 00:40:27,900
Que tengo que hacer algo con él

999
00:40:27,900 --> 00:40:30,820
Y tengo un montón de herramientas que ya me hacen

1000
00:40:30,820 --> 00:40:33,019
Cosas potentes y optimizadas

1001
00:40:33,019 --> 00:40:34,800
Para poder utilizar

1002
00:40:34,800 --> 00:40:36,400
Lo que ya me proponen los demás

1003
00:40:36,400 --> 00:40:38,760
Realmente lo único que tengo que hacer es implementar

1004
00:40:38,760 --> 00:40:40,460
determinadas interfaces

1005
00:40:40,460 --> 00:40:41,739
pillo mi objeto

1006
00:40:41,739 --> 00:40:44,320
implemento la interfaz comparable

1007
00:40:44,320 --> 00:40:47,059
y ahora ya puedo utilizar todos los métodos

1008
00:40:47,059 --> 00:40:48,559
que trabajan sobre eso como comparable

1009
00:40:48,559 --> 00:40:51,219
entonces no tengo que volver a implementar

1010
00:40:51,219 --> 00:40:53,019
un método para ordenar

1011
00:40:53,019 --> 00:40:54,940
mis arrays, sino utilizo

1012
00:40:54,940 --> 00:40:56,880
los métodos que ordenan

1013
00:40:56,880 --> 00:40:59,039
arrays que me han hecho otros basándose

1014
00:40:59,039 --> 00:40:59,800
sobre comparable

1015
00:40:59,800 --> 00:41:04,039
dudas?

1016
00:41:09,579 --> 00:41:10,260
sigamos

1017
00:41:10,260 --> 00:41:13,880
y aquí

1018
00:41:13,880 --> 00:41:16,199
me contradí

1019
00:41:16,199 --> 00:41:20,599
Hemos dicho que una interfaz

1020
00:41:20,599 --> 00:41:22,719
Es una clase abstracta

1021
00:41:22,719 --> 00:41:24,300
Que no tiene métodos

1022
00:41:24,300 --> 00:41:26,480
Implementados

1023
00:41:26,480 --> 00:41:27,699
No es mentira

1024
00:41:27,699 --> 00:41:29,980
Yo puedo pillar una interfaz

1025
00:41:29,980 --> 00:41:31,880
Implementar un método

1026
00:41:31,880 --> 00:41:33,159
¿Vale?

1027
00:41:33,519 --> 00:41:36,960
Existe el concepto de método por default

1028
00:41:36,960 --> 00:41:38,599
Método por defecto

1029
00:41:39,280 --> 00:41:39,500
¿Vale?

1030
00:41:39,780 --> 00:41:42,320
Es decir, que si yo tengo una interfaz

1031
00:41:42,320 --> 00:41:44,860
Vale, la interfaz, cada uno la implementará como sea

1032
00:41:44,860 --> 00:41:46,599
Pero quiero poder proporcionar

1033
00:41:46,599 --> 00:41:57,760
proporcionar un método ya implementado para decir mira por defecto esto en la

1034
00:41:57,760 --> 00:42:03,059
mayoría de la mayoría de los casos se implementa si te lo doy ya implementado

1035
00:42:03,059 --> 00:42:06,360
luego tú eliges si lo quieres sobreescribir si no lo quieres

1036
00:42:06,360 --> 00:42:12,940
implementar lo que sea pero yo te doy ya una versión por defecto como es el caso

1037
00:42:12,940 --> 00:42:14,559
Aquí, ¿vale?

1038
00:42:15,239 --> 00:42:17,300
Aquí he cambiado un poquito

1039
00:42:17,300 --> 00:42:21,860
La interfaz de animal

1040
00:42:21,860 --> 00:42:22,840
Y le he puesto

1041
00:42:22,840 --> 00:42:24,699
La interfaz de animal tiene habla

1042
00:42:24,699 --> 00:42:26,940
Habla es abstracto

1043
00:42:26,940 --> 00:42:28,199
¿Vale? No pone abstract

1044
00:42:28,199 --> 00:42:29,460
Pero hemos dicho que la interfaz

1045
00:42:29,460 --> 00:42:30,940
Si no pongo nada es abstracto

1046
00:42:30,940 --> 00:42:33,059
Lo tendrás que implementar tú sí o sí

1047
00:42:33,059 --> 00:42:37,219
Y por otro lado te doy default void

1048
00:42:37,219 --> 00:42:38,199
Corre

1049
00:42:38,199 --> 00:42:39,460
Default es otra palabra

1050
00:42:39,460 --> 00:42:40,440
Lo es en rojo

1051
00:42:40,440 --> 00:42:43,300
Es una palabra reservada

1052
00:42:43,300 --> 00:42:45,239
Te estoy diciendo que esto

1053
00:42:45,239 --> 00:42:47,219
Es un método de mi interfaz

1054
00:42:47,219 --> 00:42:49,139
Pero es un método al que te doy

1055
00:42:49,139 --> 00:42:50,840
Una implementación por defecto

1056
00:42:50,840 --> 00:42:53,119
Si tú no lo implementas

1057
00:42:53,119 --> 00:42:54,440
Me vale igual

1058
00:42:54,440 --> 00:42:57,159
Heredarás esta, en un cierto sentido

1059
00:42:57,159 --> 00:42:59,599
Cuidado que no estamos en herencia, estamos en implementación

1060
00:42:59,599 --> 00:43:03,059
Y por lo tanto, te digo

1061
00:43:03,059 --> 00:43:04,559
Mira, si tú

1062
00:43:04,559 --> 00:43:06,820
No haces nada con este señor

1063
00:43:06,820 --> 00:43:08,659
En automático, él escribirá

1064
00:43:08,659 --> 00:43:09,780
El animal corre

1065
00:43:09,780 --> 00:43:12,820
Es su implementación por defecto

1066
00:43:13,300 --> 00:43:24,800
¿Vale? Entonces, ¿qué puedo hacer? Pues puedo hacer que en perro implementa animal y decirle, oye, mira, implemento habla, pero no hago nada con corre.

1067
00:43:25,880 --> 00:43:38,000
Entonces, corre utilizará la implementación por defecto de la interfaz. Es decir, que si un perro corre, me escribirá el animal corre. ¿Vale? La implementación que viene aquí.

1068
00:43:38,000 --> 00:43:41,280
Sin embargo, para hacer un ejemplo distinto

1069
00:43:41,280 --> 00:43:43,260
Aquí, en gato

1070
00:43:43,260 --> 00:43:45,980
Implemento habla

1071
00:43:45,980 --> 00:43:48,659
Y vuelvo a sobrescribir

1072
00:43:48,659 --> 00:43:50,780
Reimplementar también corre

1073
00:43:50,780 --> 00:43:53,920
Donde en vez de utilizar la entrevista en arriba

1074
00:43:53,920 --> 00:43:56,280
Escribo que tiene que escribir el gato corre

1075
00:43:56,280 --> 00:44:00,219
Por hacer las dos cosas

1076
00:44:00,219 --> 00:44:01,619
Resultado

1077
00:44:01,619 --> 00:44:05,239
Que cuando yo llamo dog.corre

1078
00:44:05,239 --> 00:44:08,500
Me saldrá el animal corre

1079
00:44:08,500 --> 00:44:10,460
cuando llamo cat.corre

1080
00:44:10,460 --> 00:44:11,760
el gato corre

1081
00:44:11,760 --> 00:44:17,650
y aquí la pregunta es obvia

1082
00:44:17,650 --> 00:44:29,619
es obvia, tan obvia que

1083
00:44:29,619 --> 00:44:32,000
está aquí la respuesta

1084
00:44:32,000 --> 00:44:35,179
¿no? es decir, vale

1085
00:44:35,179 --> 00:44:36,760
yo tengo las clases abstractas

1086
00:44:36,760 --> 00:44:39,199
las clases abstractas pueden implementar métodos

1087
00:44:39,199 --> 00:44:41,539
o hacer métodos abstractos, vale, es fenomenal

1088
00:44:41,539 --> 00:44:42,820
y luego tengo las interfaces

1089
00:44:42,820 --> 00:44:45,059
que pueden hacer métodos abstractos

1090
00:44:45,059 --> 00:44:46,659
o puedo implementarlos

1091
00:44:46,659 --> 00:44:52,670
entonces, aquí

1092
00:44:52,670 --> 00:44:56,449
Algunas pistas de la diferencia

1093
00:44:56,449 --> 00:44:56,829
¿Vale?

1094
00:44:57,849 --> 00:44:58,349
¿Qué son?

1095
00:44:58,530 --> 00:44:59,530
Primero el propósito

1096
00:44:59,530 --> 00:45:02,829
Una clase estrata se utiliza para proporcionar

1097
00:45:02,829 --> 00:45:05,489
Una estructura básica para una jerarquía de clases

1098
00:45:05,489 --> 00:45:06,170
¿Vale?

1099
00:45:06,170 --> 00:45:07,769
Cuando yo uso una clase estrata

1100
00:45:07,769 --> 00:45:10,190
Estoy construyendo una jerarquía de clases

1101
00:45:10,190 --> 00:45:12,190
Estoy en un cierto sentido

1102
00:45:12,190 --> 00:45:14,610
Organizando mis clases

1103
00:45:14,610 --> 00:45:15,329
Entre ellas

1104
00:45:15,329 --> 00:45:18,409
Tengo persona que debajo tiene empleado

1105
00:45:18,409 --> 00:45:20,530
Y tiene debajo

1106
00:45:20,530 --> 00:45:21,710
De empleado profesor

1107
00:45:21,710 --> 00:45:23,750
Debajo de persona también está estudiante

1108
00:45:23,750 --> 00:45:26,170
Estoy creando toda una jerarquía de clases

1109
00:45:26,170 --> 00:45:27,869
Que se interrelacionan entre ellos

1110
00:45:27,869 --> 00:45:30,070
Y alguna de estas puede ser astrata

1111
00:45:30,070 --> 00:45:34,670
Mientras que cuando defino una interfaz

1112
00:45:34,670 --> 00:45:36,309
No estoy tanto definiendo

1113
00:45:36,309 --> 00:45:38,030
Esta jerarquía de clase

1114
00:45:38,030 --> 00:45:39,530
Podría ser que alguna clase

1115
00:45:39,530 --> 00:45:41,489
Se implemente en la interfaz o no

1116
00:45:41,489 --> 00:45:44,130
Independientemente de donde están en esta jerarquía

1117
00:45:44,130 --> 00:45:46,170
Sino que estoy haciendo un contrato

1118
00:45:46,829 --> 00:45:47,969
Estoy diciendo

1119
00:45:47,969 --> 00:45:50,070
Mira, cuando tú vas a implementar

1120
00:45:50,070 --> 00:45:53,449
Esta clase

1121
00:45:53,449 --> 00:45:54,829
Que implementa

1122
00:45:54,829 --> 00:45:56,489
Mi interfaz

1123
00:45:56,489 --> 00:45:57,590
Determinada

1124
00:45:57,590 --> 00:46:00,389
Te estás pillando el

1125
00:46:00,389 --> 00:46:03,329
Deber de implementar

1126
00:46:03,329 --> 00:46:04,769
Todos los métodos que te he dado yo

1127
00:46:04,769 --> 00:46:06,909
O sea, te estás pillando

1128
00:46:06,909 --> 00:46:08,550
El contrato de decir

1129
00:46:08,550 --> 00:46:09,809
Vale, cuando yo implemento

1130
00:46:09,809 --> 00:46:11,710
Estos métodos que me has dicho tú

1131
00:46:11,710 --> 00:46:13,989
Los tienen que estar en la base de la ley

1132
00:46:13,989 --> 00:46:16,789
Independientemente de cual sea mi jerarquía

1133
00:46:16,789 --> 00:46:17,469
De clases

1134
00:46:17,469 --> 00:46:19,909
Son dos propósitos distintos

1135
00:46:19,909 --> 00:46:28,110
En uno estoy dando una herramienta para estar seguro que si alguien implementa mi interfaz

1136
00:46:28,110 --> 00:46:29,610
Está implementando esos métodos

1137
00:46:29,610 --> 00:46:34,869
Es un contrato entre varios desarrolladores, entre varias partes de mi programa

1138
00:46:34,869 --> 00:46:41,829
Sin embargo cuando utilizo una clase abstracta la estoy utilizando para hacer un diseño de cómo es mi estructura

1139
00:46:41,829 --> 00:46:44,230
De la estructura de mi sistema

1140
00:46:44,230 --> 00:46:47,969
Y a eso da una pizca de diferencia

1141
00:46:47,969 --> 00:46:50,650
Segunda implementación de métodos

1142
00:46:50,650 --> 00:46:52,289
Bueno, esto es reactivo

1143
00:46:52,289 --> 00:46:54,170
Una clase abstracta normalmente

1144
00:46:54,170 --> 00:46:56,530
Tiene una parte concreta

1145
00:46:56,530 --> 00:46:57,869
Y una parte abstracta, ¿vale?

1146
00:46:57,889 --> 00:47:00,170
Algunos métodos concretos y algunos métodos abstractos

1147
00:47:00,170 --> 00:47:01,889
Mientras que la interfaz

1148
00:47:01,889 --> 00:47:04,969
Por lo general tiene solo abstractos

1149
00:47:04,969 --> 00:47:06,849
¿Vale? Y aquí añade a colete

1150
00:47:06,849 --> 00:47:08,630
Ella, a menos que no se utilice

1151
00:47:08,630 --> 00:47:09,429
Un método default

1152
00:47:09,429 --> 00:47:11,610
¿Vale? Que es lo que hemos visto ahora

1153
00:47:11,610 --> 00:47:13,369
Y la razón de por qué no se ha movido la técnica

1154
00:47:13,369 --> 00:47:15,170
Dos razones más

1155
00:47:15,170 --> 00:47:17,230
Herencia, y este es fuerte

1156
00:47:17,230 --> 00:47:20,389
¿Cuántas clases puede heredar?

1157
00:47:20,889 --> 00:47:21,150
Una

1158
00:47:21,150 --> 00:47:22,989
¿Cuántas interfaces puede implementar?

1159
00:47:23,150 --> 00:47:23,670
Infinitas

1160
00:47:23,670 --> 00:47:26,550
Pues ya tenéis la diferencia suficiente

1161
00:47:26,550 --> 00:47:27,849
Para las dos cosas

1162
00:47:27,849 --> 00:47:28,110
¿Vale?

1163
00:47:28,449 --> 00:47:29,429
Si tengo una clase de strata

1164
00:47:29,429 --> 00:47:31,929
Puede heredar solo de esa clase de strata

1165
00:47:31,929 --> 00:47:34,210
Y si necesito algunas cosas más

1166
00:47:34,210 --> 00:47:36,789
Pues tiro de interfaz

1167
00:47:36,789 --> 00:47:37,730
¿Vale?

1168
00:47:38,670 --> 00:47:40,929
Entonces, ¿por qué no anulamos la clase de strata

1169
00:47:40,929 --> 00:47:42,349
Y la destruimos la clase de strata?

1170
00:47:42,489 --> 00:47:44,070
Bueno, en realidad, en mi experiencia

1171
00:47:44,070 --> 00:47:45,289
La clase de strata se usa menos

1172
00:47:45,289 --> 00:47:48,670
Pero es este punto de aquí

1173
00:47:48,670 --> 00:47:50,690
La clase abstracta

1174
00:47:50,690 --> 00:47:52,710
Me crea esta organización

1175
00:47:52,710 --> 00:47:54,869
Que la interfaz no me crea

1176
00:47:54,869 --> 00:47:59,340
Y...

1177
00:47:59,340 --> 00:48:01,760
Entonces, herencia múltiple en un lado

1178
00:48:01,760 --> 00:48:02,659
Y símbolo en otro

1179
00:48:02,659 --> 00:48:05,199
Y también hay una cosa sobre las variables

1180
00:48:05,199 --> 00:48:06,980
Esto es también interesante

1181
00:48:06,980 --> 00:48:09,300
Las variables en una clase abstracta

1182
00:48:09,300 --> 00:48:11,599
Pueden ser estáticas o no estáticas

1183
00:48:11,599 --> 00:48:13,679
O sea, yo en una clase abstracta

1184
00:48:13,679 --> 00:48:16,239
Puedo crear variables del objeto

1185
00:48:16,239 --> 00:48:19,539
Sin embargo, en una interfaz

1186
00:48:19,539 --> 00:48:22,539
No puedo crear variables de un objeto

1187
00:48:22,539 --> 00:48:24,380
¿Vale?

1188
00:48:24,460 --> 00:48:25,360
Porque no la he dado

1189
00:48:25,360 --> 00:48:27,059
Implemento

1190
00:48:27,059 --> 00:48:30,800
Entonces, una interfaz sí puede tener variables estáticas

1191
00:48:30,800 --> 00:48:33,559
Que se referen a esa interfaz

1192
00:48:33,559 --> 00:48:35,239
En la que daré la misma forma

1193
00:48:35,239 --> 00:48:38,659
Pero no pueden tener variables no estáticas

1194
00:48:38,659 --> 00:48:40,860
Entonces, si yo quiero hacer

1195
00:48:40,860 --> 00:48:43,719
Algo parecido a esto que estamos viendo ahora

1196
00:48:43,719 --> 00:48:44,059
¿Vale?

1197
00:48:44,059 --> 00:48:46,320
En general y necesito

1198
00:48:46,320 --> 00:48:47,760
En mi jerarquía

1199
00:48:47,760 --> 00:48:49,960
Utilizar una clase

1200
00:48:49,960 --> 00:48:52,480
Que tenga variables no estáticas

1201
00:48:52,480 --> 00:48:54,059
Y de allí extender

1202
00:48:54,059 --> 00:48:55,559
Parte de esa que parte

1203
00:48:55,559 --> 00:48:57,599
Ostrata y parte no

1204
00:48:57,599 --> 00:48:59,760
Pues no puedo hacerlo con una interfaz

1205
00:48:59,760 --> 00:49:02,619
Necesito la clase

1206
00:49:02,619 --> 00:49:03,159
Ostrata

1207
00:49:03,159 --> 00:49:05,739
Y esto es un punto que me dice

1208
00:49:05,739 --> 00:49:07,059
Vale, a este punto pues

1209
00:49:07,059 --> 00:49:10,179
No puedo destruir

1210
00:49:10,179 --> 00:49:12,139
La clase ostrata y decir algo todo con una interfaz

1211
00:49:12,139 --> 00:49:17,300
Hay casos particulares en los que necesito todavía el concepto de concepto

1212
00:49:17,300 --> 00:49:22,179
Y esto si lo pensáis un poco, habéis sentido un poco el concepto de instancias, etc, etc, etc

1213
00:49:22,179 --> 00:49:23,340
¿Entendéis por qué?

1214
00:49:23,800 --> 00:49:25,840
La interfaz no es una clase

1215
00:49:25,840 --> 00:49:27,000
¿Vale?

1216
00:49:27,139 --> 00:49:29,480
La interfaz no genera instancias

1217
00:49:29,480 --> 00:49:30,320
¿Vale?

1218
00:49:30,699 --> 00:49:32,199
Puede generar referencias

1219
00:49:32,199 --> 00:49:34,460
Pero nunca de un new comparable

1220
00:49:34,460 --> 00:49:39,349
¿Vale?

1221
00:49:40,030 --> 00:49:41,389
Siempre hay una letra pequeña

1222
00:49:41,389 --> 00:49:44,949
Es que esto de la programación

1223
00:49:44,949 --> 00:49:46,150
es un mundo

1224
00:49:46,150 --> 00:49:49,030
y luego está la cosa

1225
00:49:49,030 --> 00:49:50,969
más compleja de este curso

1226
00:49:50,969 --> 00:49:51,650
hasta ahora

1227
00:49:51,650 --> 00:49:53,730
la interfaz funcional

1228
00:49:53,730 --> 00:49:55,389
¿qué es?

1229
00:49:58,400 --> 00:50:00,559
momento de falta de

1230
00:50:00,559 --> 00:50:01,739
respiración

1231
00:50:01,739 --> 00:50:03,880
y de broad your mind

1232
00:50:03,880 --> 00:50:06,019
porque

1233
00:50:06,019 --> 00:50:08,500
llegamos a una cosa que no hemos visto hasta ahora

1234
00:50:08,500 --> 00:50:10,119
y que veremos aquí en un momento

1235
00:50:10,119 --> 00:50:12,639
pero no estará muy por la noche

1236
00:50:12,639 --> 00:50:14,300
te expectaré diciendo

1237
00:50:14,300 --> 00:50:15,579
la interfaz funcional

1238
00:50:15,579 --> 00:50:20,030
Imaginaos una interfaz

1239
00:50:20,030 --> 00:50:22,769
Donde yo pongo esta anotación de aquí

1240
00:50:22,769 --> 00:50:24,349
Que es lo que me crea

1241
00:50:24,349 --> 00:50:25,710
Una interfaz funcional

1242
00:50:25,710 --> 00:50:28,670
Y luego digo

1243
00:50:28,670 --> 00:50:29,530
Vale, muy bien

1244
00:50:29,530 --> 00:50:33,150
Tengo la interfaz

1245
00:50:33,150 --> 00:50:34,550
Esta es declaración

1246
00:50:34,550 --> 00:50:35,969
Como class

1247
00:50:35,969 --> 00:50:37,449
Operación

1248
00:50:37,449 --> 00:50:40,070
Este es el nombre de la interfaz

1249
00:50:40,070 --> 00:50:41,230
¿Qué tiene dentro?

1250
00:50:41,630 --> 00:50:43,889
Tiene un método

1251
00:50:43,889 --> 00:50:45,530
El método ejecutar

1252
00:50:45,530 --> 00:50:47,730
Que recibe un A y un B

1253
00:50:47,730 --> 00:50:55,579
Vamos a ver cómo se usa esta cosa

1254
00:50:55,579 --> 00:50:56,760
Mira adelante

1255
00:50:56,760 --> 00:51:00,579
Creo un objeto operación

1256
00:51:00,579 --> 00:51:04,320
Y en vez de definir aquí

1257
00:51:04,320 --> 00:51:06,380
Su ño o no sé qué

1258
00:51:06,380 --> 00:51:08,500
Lo que le estoy pasando

1259
00:51:08,500 --> 00:51:10,039
Es

1260
00:51:10,039 --> 00:51:12,940
Cómo se hace esta operación

1261
00:51:12,940 --> 00:51:16,420
No le estoy pasando un valor

1262
00:51:16,420 --> 00:51:18,199
Le estoy pasando

1263
00:51:18,199 --> 00:51:19,559
Una función

1264
00:51:19,559 --> 00:51:23,079
No estoy almacenando

1265
00:51:23,079 --> 00:51:24,019
En una variable

1266
00:51:24,019 --> 00:51:25,860
El valor 3

1267
00:51:25,860 --> 00:51:28,579
Más estoy almacenando en una variable

1268
00:51:28,579 --> 00:51:30,960
Un procedimiento

1269
00:51:30,960 --> 00:51:33,019
Que me dice

1270
00:51:33,019 --> 00:51:33,920
Dame a y b

1271
00:51:33,920 --> 00:51:36,280
Y el resultado es a más b

1272
00:51:36,280 --> 00:51:38,019
Y esta es la operación suma

1273
00:51:38,019 --> 00:51:42,760
Cuando llamaré suma.ejecutar

1274
00:51:42,760 --> 00:51:43,639
De a, b

1275
00:51:43,639 --> 00:51:44,800
¿Os acordáis de esto?

1276
00:51:46,280 --> 00:51:47,159
¿Qué me hará?

1277
00:51:47,159 --> 00:51:54,760
Si yo hago suma.ejecutar de 3,5

1278
00:51:54,760 --> 00:51:55,460
¿Qué me hace?

1279
00:51:58,579 --> 00:52:02,119
Aplica esta operación, hace 3 más 5 y el resultado es 8

1280
00:52:02,119 --> 00:52:07,280
Pero puedo crear una operación multiplicación

1281
00:52:07,280 --> 00:52:12,119
Donde le paso como parámetro, como valor

1282
00:52:12,119 --> 00:52:14,599
Otra distinta operación

1283
00:52:14,599 --> 00:52:16,159
Que es dame A y B

1284
00:52:16,159 --> 00:52:18,139
Y el resultado es A por B

1285
00:52:18,139 --> 00:52:22,170
Entonces ahora

1286
00:52:22,170 --> 00:52:23,929
He usado la misma

1287
00:52:23,929 --> 00:52:26,789
Objeto

1288
00:52:26,789 --> 00:52:28,789
Pero no le estoy pasando un valor

1289
00:52:28,789 --> 00:52:30,210
Le estoy pasando una función

1290
00:52:30,210 --> 00:52:32,849
Y esto

1291
00:52:32,849 --> 00:52:40,760
Todo esto es basado

1292
00:52:40,760 --> 00:52:42,719
Sobre un concepto teórico

1293
00:52:42,719 --> 00:52:44,840
Que es el lambda cálculo

1294
00:52:44,840 --> 00:52:50,440
Que se da en quinto de

1295
00:52:50,440 --> 00:52:52,099
Carrera

1296
00:52:52,099 --> 00:52:56,909
¿Vale?

1297
00:52:56,909 --> 00:52:57,989
Para poder

1298
00:52:57,989 --> 00:53:01,050
para poder especificar todas estas cosas

1299
00:53:01,050 --> 00:53:02,010
este señor de aquí

1300
00:53:02,010 --> 00:53:04,889
el let in y cosas por el estilo

1301
00:53:04,889 --> 00:53:06,889
pues hay todo un lenguaje entre comillas

1302
00:53:06,889 --> 00:53:08,030
que es el lambda cálculo

1303
00:53:08,030 --> 00:53:12,809
que me permitiría

1304
00:53:12,809 --> 00:53:14,590
aquí hacer cosas

1305
00:53:14,590 --> 00:53:15,929
muy potentes

1306
00:53:15,929 --> 00:53:18,610
¿os acordáis al principio de curso?

1307
00:53:18,969 --> 00:53:20,510
porque seguramente estáis repasando

1308
00:53:20,510 --> 00:53:21,969
cada 15 días

1309
00:53:21,969 --> 00:53:24,889
cuando hicimos una clasificación de los lenguajes

1310
00:53:24,889 --> 00:53:26,369
y vimos que había lenguajes

1311
00:53:26,369 --> 00:53:30,309
Y había lenguajes funcionales

1312
00:53:30,309 --> 00:53:35,070
Cuya característica era que podía pasar como parámetros

1313
00:53:35,070 --> 00:53:40,050
Y como variables a funciones en vez de valores

1314
00:53:40,050 --> 00:53:45,070
Pues este es el intento que ha hecho Java

1315
00:53:45,070 --> 00:53:50,670
Para incluir dentro de Java mismo algo de lenguaje funcional

1316
00:53:50,670 --> 00:53:58,210
En realidad tiene sus matices

1317
00:53:58,210 --> 00:54:00,570
¿Vale? Porque para que sea funcional de verdad

1318
00:54:00,570 --> 00:54:02,489
Debería ser implementado de otra forma

1319
00:54:02,489 --> 00:54:03,190
Y cosas por el estilo

1320
00:54:03,190 --> 00:54:05,510
Pero lo que está intentando hacer aquí

1321
00:54:05,510 --> 00:54:08,570
Es acercarse a lo que son los lenguajes funcionales

1322
00:54:08,570 --> 00:54:09,530
¿Y esto por qué?

1323
00:54:11,110 --> 00:54:12,510
Porque hay problemas

1324
00:54:12,510 --> 00:54:14,389
Que los lenguajes orientados a objetos

1325
00:54:14,389 --> 00:54:16,389
Y lenguajes interactivos

1326
00:54:16,389 --> 00:54:18,030
Normales que conocemos nosotros

1327
00:54:18,030 --> 00:54:20,869
Se permiten solucionar

1328
00:54:20,869 --> 00:54:21,849
Súper fácilmente

1329
00:54:21,849 --> 00:54:23,389
O sea que hay cosas que

1330
00:54:23,389 --> 00:54:25,550
Funcionan muy bien

1331
00:54:25,550 --> 00:54:27,969
Los lenguajes orientados a objetos para eso

1332
00:54:27,969 --> 00:54:35,389
Y hay otros temas que los lenguajes, sobre todo la programación nuestra, no funcional, no lógica

1333
00:54:35,389 --> 00:54:44,869
Que utilizamos nosotros, crea programas súper complejos y súper lentos para poder hacer decenas de cosas

1334
00:54:44,869 --> 00:54:52,190
Hay campos en los que esta forma de programar, la que estamos aprendiendo nosotros, no funciona

1335
00:54:52,190 --> 00:54:54,929
Es muy engorrosa

1336
00:54:54,929 --> 00:54:58,110
Uno de ellos, por ejemplo, es el lenguaje natural

1337
00:54:58,110 --> 00:55:01,650
El procesamiento del lenguaje natural

1338
00:55:01,650 --> 00:55:03,710
Lo puedes hacer tranquilamente en Java

1339
00:55:03,710 --> 00:55:07,170
Pero la forma con que lo logras

1340
00:55:07,170 --> 00:55:08,510
Utilizando Prolog

1341
00:55:08,510 --> 00:55:11,389
O otros lenguajes de programación lógica

1342
00:55:11,389 --> 00:55:12,670
O de programación funcional

1343
00:55:12,670 --> 00:55:14,329
Pues es otro mundo

1344
00:55:14,329 --> 00:55:16,449
Yo esto lo he vivido

1345
00:55:16,449 --> 00:55:22,159
En un curso aquí en la Politécnica

1346
00:55:22,159 --> 00:55:24,980
Donde había el procesamiento del lenguaje natural

1347
00:55:24,980 --> 00:55:25,739
Había que hacer

1348
00:55:25,739 --> 00:55:27,480
No sé, no me acuerdo ni siquiera qué

1349
00:55:27,480 --> 00:55:29,760
Me acuerdo que yo me pasé tres días

1350
00:55:29,760 --> 00:55:31,039
Lo hacíamos en pareja

1351
00:55:31,039 --> 00:55:33,159
Entonces yo me pasé tres días

1352
00:55:33,159 --> 00:55:34,460
Haciendo mi programito en Java

1353
00:55:34,460 --> 00:55:35,639
Para hacer lo que sea

1354
00:55:35,639 --> 00:55:36,880
Y vino mi compañero y le digo

1355
00:55:36,880 --> 00:55:38,000
Mira, yo conozco Prolog

1356
00:55:38,000 --> 00:55:40,300
Mira, tres líneas de código

1357
00:55:40,300 --> 00:55:47,289
Entonces, todo depende

1358
00:55:47,289 --> 00:55:49,230
Pero la idea es que

1359
00:55:49,230 --> 00:55:50,929
Si en un día futuro

1360
00:55:50,929 --> 00:55:52,389
Como el MOOC

1361
00:55:52,389 --> 00:56:01,590
¿Vale? Llega un momento en que vosotros veáis runas arcanas en un programa de Java, ¿vale?

1362
00:56:01,630 --> 00:56:09,389
Podráis decir, me acuerdo ese tío que hablaba mal, que habló de programación funcional o de interfaz funcional.

1363
00:56:09,989 --> 00:56:12,389
Y allí tendréis como un...

1364
00:56:15,570 --> 00:56:16,409
Una revelación.

1365
00:56:16,809 --> 00:56:22,289
No, no, una sensación mala de esta, de como que hay alguien detrás que intentarlo.

1366
00:56:22,289 --> 00:56:26,909
y son cosas complejas

1367
00:56:26,909 --> 00:56:29,349
que no se pueden

1368
00:56:29,349 --> 00:56:30,349
parar, aprender

1369
00:56:30,349 --> 00:56:33,530
esto os lo digo

1370
00:56:33,530 --> 00:56:34,849
de verdad, lo pongo aquí

1371
00:56:34,849 --> 00:56:36,650
simplemente para que tengáis un

1372
00:56:36,650 --> 00:56:38,949
ejemplo, lo podéis copiar

1373
00:56:38,949 --> 00:56:40,849
por algún lado y ver que funciona

1374
00:56:40,849 --> 00:56:42,690
y cosas por el estilo, pero que

1375
00:56:42,690 --> 00:56:44,690
no va a entrar en el examen

1376
00:56:44,690 --> 00:56:47,409
ni siquiera para el bien

1377
00:56:47,409 --> 00:56:49,150
son cosas que no vamos a

1378
00:56:49,150 --> 00:56:49,449
trabajar

1379
00:56:49,449 --> 00:56:57,889
esto sería un main

1380
00:56:57,889 --> 00:56:59,570
Y este de aquí sería

1381
00:56:59,570 --> 00:57:07,170
Y ya está