1
00:00:00,050 --> 00:00:40,049
Bueno, pues lo último que estuvimos viendo el miércoles estaba en relación con el concepto de estática, ¿vale? Entonces, sabemos lo que es que una propiedad sea estática y es una propiedad, es, vale, estática, vale, entonces, vale, ya sabemos que una propiedad,

2
00:00:40,049 --> 00:01:08,900
Si tiene el static delante, en una clase, la que sea, clase A, ya sabemos que eso significa que todos los objetos de la clase A, a1, a2, a3, todos, tienen como propiedad .num esta, la misma.

3
00:01:08,900 --> 00:01:11,920
todos tienen la misma

4
00:01:11,920 --> 00:01:13,780
entonces si hacemos a1.num

5
00:01:13,780 --> 00:01:15,659
vamos aquí, pero si hacemos

6
00:01:15,659 --> 00:01:17,700
a2.num también vamos aquí

7
00:01:17,700 --> 00:01:20,099
hasta ahí está claro, entonces tanto es así

8
00:01:20,099 --> 00:01:21,879
que podemos llamar

9
00:01:21,879 --> 00:01:23,959
esa propiedad static con el nombre de la clase

10
00:01:23,959 --> 00:01:25,879
sin más, a.num

11
00:01:25,879 --> 00:01:28,040
no hace falta que la llamemos

12
00:01:28,040 --> 00:01:29,900
como a1.num

13
00:01:29,900 --> 00:01:31,379
o como a2.num

14
00:01:31,379 --> 00:01:34,359
se puede, pero no es lo recomendable

15
00:01:34,359 --> 00:01:35,819
el propio compilador te va a decir

16
00:01:35,819 --> 00:01:37,719
que manera tan artificiosa de llamarlo

17
00:01:37,719 --> 00:01:39,939
¿vale? no llamamos

18
00:01:39,939 --> 00:01:41,859
así a las propiedades estáticas, sino lo llamamos

19
00:01:41,859 --> 00:01:43,000
con el nombre de la clase.

20
00:01:44,319 --> 00:01:45,819
¿Vale? Porque como vayamos

21
00:01:45,819 --> 00:01:47,680
por donde vayamos, vamos a ir al mismo sitio.

22
00:01:48,879 --> 00:01:49,680
Además hay otra

23
00:01:49,680 --> 00:01:51,579
implicación, y es

24
00:01:51,579 --> 00:01:53,879
que si llamamos así a la propiedad

25
00:01:53,879 --> 00:01:55,819
necesitamos que exista

26
00:01:55,819 --> 00:01:56,980
un objeto previamente.

27
00:01:58,060 --> 00:01:59,659
¿Vale? ¿Y hace falta

28
00:01:59,659 --> 00:02:00,879
que exista un objeto

29
00:02:00,879 --> 00:02:03,739
para que exista la propiedad estática?

30
00:02:03,879 --> 00:02:04,579
No hace falta.

31
00:02:05,700 --> 00:02:07,560
Las propiedades estáticas de una clase

32
00:02:07,560 --> 00:02:09,659
son lo que se llaman el contexto estático

33
00:02:09,659 --> 00:02:11,840
de la clase, que puede haber una o mil

34
00:02:11,840 --> 00:02:13,560
y esas propiedades

35
00:02:13,560 --> 00:02:15,919
pueden existir en memoria RAM

36
00:02:15,919 --> 00:02:17,939
aunque no exista ningún objeto

37
00:02:17,939 --> 00:02:19,400
aunque no exista ninguno

38
00:02:19,400 --> 00:02:21,400
y cuando

39
00:02:21,400 --> 00:02:23,719
aparecen, cuando se crean, porque sabemos

40
00:02:23,719 --> 00:02:25,680
cuando se crea un objeto, un objeto se

41
00:02:25,680 --> 00:02:27,439
crea cuando lo instancias con el new

42
00:02:27,439 --> 00:02:29,620
¿vale? pero cuando

43
00:02:29,620 --> 00:02:31,800
aparecen las propiedades estáticas de una clase

44
00:02:31,800 --> 00:02:33,500
si hubiéramos

45
00:02:33,500 --> 00:02:35,560
instanciado algún objeto con el new

46
00:02:35,560 --> 00:02:37,580
en el momento de instanciar

47
00:02:37,580 --> 00:02:38,719
el primer objeto

48
00:02:38,719 --> 00:02:40,819
ya aparecen, ya están ahí

49
00:02:40,819 --> 00:02:42,879
ya aparecen a disposición de todas las demás

50
00:02:42,879 --> 00:02:44,919
pero si no hemos instanciado

51
00:02:44,919 --> 00:02:46,879
ningún objeto, también pueden

52
00:02:46,879 --> 00:02:48,979
aparecer, ¿cuándo? la primera vez

53
00:02:48,979 --> 00:02:50,919
que accedamos a ellas, por ejemplo

54
00:02:50,919 --> 00:02:52,460
si yo hago a.num

55
00:02:52,460 --> 00:02:53,319
igual a 3

56
00:02:53,319 --> 00:02:56,460
puedo hacer esta sentencia

57
00:02:56,460 --> 00:02:58,300
a.num igual a 3

58
00:02:58,300 --> 00:03:01,120
sin haber instanciado ningún objeto antes

59
00:03:01,120 --> 00:03:02,620
pues en este momento

60
00:03:02,620 --> 00:03:04,680
que es la primera vez que hago

61
00:03:04,680 --> 00:03:06,699
referencia a la propiedad a través del número

62
00:03:06,699 --> 00:03:08,219
de la clase, aparece

63
00:03:08,219 --> 00:03:16,620
Y ahí aparece, es el contexto, ella y todas las demás, no solo ella, todas las demás que hay estáticas, aparecen.

64
00:03:17,759 --> 00:03:25,460
Es decir, el contexto estático de una clase, o lo que es lo mismo, toda esa información compartida por todos los objetos

65
00:03:25,460 --> 00:03:32,020
que se supone que está pensada para describir la entidad en conjunto y no cada objeto por separado,

66
00:03:32,280 --> 00:03:38,080
pues ese contexto estático aparece la primera vez que se hace referencia a esa clase en el código.

67
00:03:38,219 --> 00:03:44,319
Bien porque se hace referencia a una variable, a una propiedad, bien porque es instancia en objeto, por lo que sea.

68
00:03:45,080 --> 00:03:47,719
Bueno, pues esas son las variables estáticas.

69
00:03:48,020 --> 00:03:58,860
El hecho de que hubiera variables estáticas implicaba automáticamente que entonces puede haber métodos que sean estáticos también.

70
00:04:00,000 --> 00:04:01,960
Entonces, los métodos ya sabemos lo que son.

71
00:04:01,960 --> 00:04:18,720
Los métodos son un montón de líneas de código que yo encierro ahí entre llaves, a la que puedo llamar por su nombre, la llamo por su nombre, y en condiciones normales a ese método le llamamos, ¿vale?

72
00:04:18,720 --> 00:04:23,410
en condiciones normales

73
00:04:23,410 --> 00:04:25,209
a ese método le llamamos

74
00:04:25,209 --> 00:04:26,790
asociado a un objeto

75
00:04:26,790 --> 00:04:28,550
este método de aquí

76
00:04:28,550 --> 00:04:30,389
que me devuelve un entero

77
00:04:30,389 --> 00:04:31,649
me devuelve lo que sea

78
00:04:31,649 --> 00:04:33,449
¿vale?

79
00:04:33,810 --> 00:04:34,889
este método de aquí

80
00:04:34,889 --> 00:04:36,029
en condiciones normales

81
00:04:36,029 --> 00:04:37,410
pues yo instanciaría un objeto

82
00:04:37,410 --> 00:04:41,069
a uno igual a ni uno sé qué

83
00:04:41,069 --> 00:04:44,790
y haría a uno punto método

84
00:04:44,790 --> 00:04:46,550
y ya está

85
00:04:46,550 --> 00:04:48,329
¿vale? es un método normal y corriente

86
00:04:48,329 --> 00:04:53,310
Entonces, este método va a ejecutar este código que hay aquí

87
00:04:53,310 --> 00:04:58,990
Y cuando este método haga referencia a alguna de las variables de la clase

88
00:04:58,990 --> 00:05:02,550
Como por ejemplo esta, x igual a 3

89
00:05:02,550 --> 00:05:07,050
Pues, ¿a qué variable se va a referir en esta ejecución en concreto?

90
00:05:07,629 --> 00:05:10,750
Pues en esta ejecución en concreto, cuando veamos x

91
00:05:10,750 --> 00:05:15,589
Se va a referir a la propiedad x del objeto a1, obviamente

92
00:05:15,589 --> 00:05:18,230
si lo llama el objeto A2

93
00:05:18,230 --> 00:05:22,360
pues cuando se ejecute este código

94
00:05:22,360 --> 00:05:24,379
y accedamos a la variable X

95
00:05:24,379 --> 00:05:25,540
se va a referir

96
00:05:25,540 --> 00:05:28,000
a la variable propiedad X

97
00:05:28,000 --> 00:05:29,480
de este A2, hasta ahí está claro

98
00:05:29,480 --> 00:05:33,120
bueno, pero puede ocurrir

99
00:05:33,120 --> 00:05:34,519
que haya métodos

100
00:05:34,519 --> 00:05:36,639
que no necesiten

101
00:05:36,639 --> 00:05:38,060
para trabajar

102
00:05:38,060 --> 00:05:39,100
que no lo necesiten

103
00:05:39,100 --> 00:05:41,779
acceder a las propiedades del objeto

104
00:05:41,779 --> 00:05:43,519
porque hagan cosas

105
00:05:43,519 --> 00:05:45,459
que no están relacionadas

106
00:05:45,459 --> 00:05:47,819
con el contenido concreto del objeto

107
00:05:47,819 --> 00:05:49,699
que hagan otro tipo

108
00:05:49,699 --> 00:05:51,720
de cosas, que no es modificar

109
00:05:51,720 --> 00:05:53,579
ni acceder en las propiedades concretas

110
00:05:53,579 --> 00:05:55,379
del objeto, entonces ese método

111
00:05:55,379 --> 00:05:57,620
automáticamente es un método que ya

112
00:05:57,620 --> 00:05:59,680
en la clase decimos, bueno es un método independiente

113
00:05:59,680 --> 00:06:01,240
de cualquier objeto, lógicamente

114
00:06:01,240 --> 00:06:03,600
si este método no

115
00:06:03,600 --> 00:06:05,620
depende lo que hace

116
00:06:05,620 --> 00:06:10,040
un método, por ejemplo

117
00:06:10,040 --> 00:06:12,199
este método que saluda, pues ya está

118
00:06:12,199 --> 00:06:13,920
este método saluda

119
00:06:13,920 --> 00:06:15,180
bla bla bla

120
00:06:15,180 --> 00:06:17,339
este método

121
00:06:17,339 --> 00:06:19,300
no accede en ningún momento

122
00:06:19,300 --> 00:06:20,779
¿dónde van ustedes?

123
00:06:23,240 --> 00:06:25,620
este método en ningún momento accede

124
00:06:25,620 --> 00:06:27,639
a las propiedades del objeto

125
00:06:27,639 --> 00:06:30,180
luego da igual que lo llame Pepito

126
00:06:30,180 --> 00:06:31,360
da igual que lo llame Juanito

127
00:06:31,360 --> 00:06:33,000
da igual, va a hacer lo mismo

128
00:06:33,000 --> 00:06:35,759
lo llame quien lo llame, va a hacer lo mismo

129
00:06:35,759 --> 00:06:37,800
entonces cuando nos damos cuenta

130
00:06:37,800 --> 00:06:39,639
de que el método es independiente del objeto

131
00:06:39,639 --> 00:06:41,519
¿y cuándo es independiente del objeto?

132
00:06:41,879 --> 00:06:44,680
cuando no accede a ninguna propiedad

133
00:06:44,680 --> 00:06:46,259
no estática

134
00:06:46,259 --> 00:06:49,259
pues entonces ese método

135
00:06:49,259 --> 00:06:51,500
decimos, uy, pues tiene la personalidad

136
00:06:51,500 --> 00:06:53,199
de estático, y la tiene

137
00:06:53,199 --> 00:06:55,279
y ya está, pues si además de

138
00:06:55,279 --> 00:06:56,560
darnos cuenta de que la tiene

139
00:06:56,560 --> 00:06:58,560
le ponemos el static delante

140
00:06:58,560 --> 00:07:03,240
habilitamos ya por código

141
00:07:03,240 --> 00:07:05,339
poder llamarlo con el nombre de la clase

142
00:07:05,339 --> 00:07:07,240
si yo a este método

143
00:07:07,240 --> 00:07:09,319
que es estático en su comportamiento

144
00:07:09,319 --> 00:07:10,920
que tiene el siso y es estático

145
00:07:10,920 --> 00:07:12,180
porque no accede a X

146
00:07:12,180 --> 00:07:14,180
no le pongo el static delante

147
00:07:14,180 --> 00:07:15,699
no pasa nada

148
00:07:15,699 --> 00:07:18,300
pero voy a estar obligada

149
00:07:18,300 --> 00:07:20,560
a instanciar siempre un objeto

150
00:07:20,560 --> 00:07:21,300
para llamarlo

151
00:07:21,300 --> 00:07:23,759
y menuda tontería

152
00:07:23,759 --> 00:07:25,399
¿para qué voy a instanciar un objeto

153
00:07:25,399 --> 00:07:28,319
si este método no usa para nada

154
00:07:28,319 --> 00:07:29,339
los datos de este objeto?

155
00:07:30,100 --> 00:07:32,399
da igual que lo llame para 1, que para 2, para 3

156
00:07:32,399 --> 00:07:33,500
¿para qué voy a instanciarlo?

157
00:07:33,680 --> 00:07:35,480
querría no tener que instanciar un objeto

158
00:07:35,480 --> 00:07:38,000
bueno, pues para poder hacerlo así

159
00:07:38,000 --> 00:07:41,120
si yo me doy cuenta

160
00:07:41,120 --> 00:07:42,160
de que es estático

161
00:07:42,160 --> 00:07:44,339
lo marco

162
00:07:44,339 --> 00:07:46,839
lo marco poniendo el static delante

163
00:07:46,839 --> 00:07:48,819
y desde el momento en que está marcado

164
00:07:48,819 --> 00:07:51,120
el compilador ya nos deja

165
00:07:51,120 --> 00:07:53,220
llamarlo

166
00:07:53,220 --> 00:07:55,120
con el nombre

167
00:07:55,120 --> 00:07:55,879
de la clase

168
00:07:55,879 --> 00:08:00,560
¿vale? entonces poder

169
00:08:00,560 --> 00:08:02,660
llamar a un método sin haber instanciado

170
00:08:02,660 --> 00:08:03,860
un objeto previamente

171
00:08:03,860 --> 00:08:06,220
llamándolo con el nombre de la clase

172
00:08:06,220 --> 00:08:09,199
nos habilita automáticamente

173
00:08:09,199 --> 00:08:10,420
el

174
00:08:10,420 --> 00:08:13,199
enorme, la enorme herramienta

175
00:08:13,199 --> 00:08:14,120
de las famosas

176
00:08:14,120 --> 00:08:15,959
funciones de librería

177
00:08:15,959 --> 00:08:18,600
que yo tengo utilidades para hacer cosas

178
00:08:18,600 --> 00:08:20,339
pues le pongo esas utilidades

179
00:08:20,339 --> 00:08:21,699
hay guardaditas en un archivo

180
00:08:21,699 --> 00:08:24,459
utilidades para hacer cosas con números, con cadenas

181
00:08:24,459 --> 00:08:25,079
con lo que sea

182
00:08:25,079 --> 00:08:27,660
cuando quiera yo hacer esas cosas

183
00:08:27,660 --> 00:08:30,220
nombre de la clase

184
00:08:30,220 --> 00:08:31,639
que tiene las utilidades

185
00:08:31,639 --> 00:08:33,779
nombre de la utilidad

186
00:08:33,779 --> 00:08:36,460
y ya está, y no tengo ni que crear objetos

187
00:08:36,460 --> 00:08:37,360
ni que hacer nada

188
00:08:37,360 --> 00:08:40,379
entonces los métodos estáticos

189
00:08:40,379 --> 00:08:42,779
representan

190
00:08:42,779 --> 00:08:44,740
en Java el concepto de los métodos

191
00:08:44,740 --> 00:08:46,080
de librería de toda la vida

192
00:08:46,080 --> 00:08:47,980
métodos que hacen cosas

193
00:08:47,980 --> 00:08:49,059
ahí guardaditas

194
00:08:49,059 --> 00:08:51,620
no asociados a ningún objeto concreto

195
00:08:51,620 --> 00:08:52,860
hacen cosas genéricas

196
00:08:52,860 --> 00:08:54,159
y yo los llamo

197
00:08:54,159 --> 00:08:55,840
con el nombre de la clase

198
00:08:55,840 --> 00:08:56,759
donde están guardados

199
00:08:56,759 --> 00:08:57,919
cuando tenga que usarlo

200
00:08:57,919 --> 00:08:59,899
¿vale?

201
00:09:01,240 --> 00:09:02,080
entonces recordad

202
00:09:02,080 --> 00:09:03,120
un método estático

203
00:09:03,120 --> 00:09:05,059
su única condición

204
00:09:05,059 --> 00:09:06,580
es que no use

205
00:09:06,580 --> 00:09:08,360
propiedades no estáticas

206
00:09:08,360 --> 00:09:10,480
si usa static

207
00:09:10,480 --> 00:09:11,519
sigue siendo estático

208
00:09:11,519 --> 00:09:12,139
lógicamente

209
00:09:12,139 --> 00:09:13,360
porque depende de los objetos

210
00:09:13,360 --> 00:09:16,480
si se le pasan propiedades

211
00:09:16,480 --> 00:09:18,460
aquí, pues no pasa nada

212
00:09:18,460 --> 00:09:20,259
está usando propiedades suyas

213
00:09:20,259 --> 00:09:22,340
que le han pasado, no pasa nada

214
00:09:22,340 --> 00:09:23,879
sigue siendo estático igualmente

215
00:09:23,879 --> 00:09:26,559
aquí puede tener variables locales, lógicamente

216
00:09:26,559 --> 00:09:28,559
solamente va a

217
00:09:28,559 --> 00:09:30,679
depender el método del objeto

218
00:09:30,679 --> 00:09:31,740
solo va a depender

219
00:09:31,740 --> 00:09:34,519
si accede a propiedades propias

220
00:09:34,519 --> 00:09:35,899
si no accede a propiedades propias

221
00:09:35,899 --> 00:09:38,340
ya es estático, lo marco

222
00:09:38,340 --> 00:09:39,279
y lo puedo llamar así

223
00:09:39,279 --> 00:09:42,000
bueno, pues en relación a esto dijimos

224
00:09:42,000 --> 00:10:09,519
Y vamos a usar esta posibilidad para a lo mejor ahorrarnos un poco de la problemática asociada, por ejemplo, al famoso escáner este. Tenemos que estar siempre preocupándonos de instanciar el escáner cuando queremos leer por tecla, de instanciarlo, luego si he leído un número, acordarme de que se queda un salto de línea y si luego leo una cadena, va a interpretar que es la cadena vacía, seguida el salto de línea.

225
00:10:09,519 --> 00:10:12,740
y si podemos meter toda esa complejidad

226
00:10:12,740 --> 00:10:14,179
en unas funciones de librería

227
00:10:14,179 --> 00:10:17,360
que se llame en unos métodos estáticos

228
00:10:17,360 --> 00:10:18,960
que se llame leer entero, leer no sé qué

229
00:10:18,960 --> 00:10:21,740
cuando yo quiera leer, llamo a leer entero y ya está

230
00:10:21,740 --> 00:10:24,279
pues qué fácil, me olvido ya del escáner para siempre

231
00:10:24,279 --> 00:10:28,480
y nos sirve como ejemplo de métodos estáticos

232
00:10:28,480 --> 00:10:32,740
bueno, pues era lo que hicimos el último día

233
00:10:32,740 --> 00:10:37,600
y el asunto era el siguiente

234
00:10:37,600 --> 00:10:50,950
Vale, pues lo hicimos con este ejemplo

235
00:10:50,950 --> 00:10:53,269
Este proyecto lo subo luego

236
00:10:53,269 --> 00:10:54,570
O sea, esta clase, vamos

237
00:10:54,570 --> 00:10:57,970
Este proyecto de aquí

238
00:10:57,970 --> 00:11:00,289
Nos hicimos aquí este paquete

239
00:11:00,289 --> 00:11:01,610
En el mismo proyecto de ejercicios

240
00:11:01,610 --> 00:11:03,929
Nos hicimos un paquete teclado

241
00:11:03,929 --> 00:11:06,149
Con esta clase de aquí

242
00:11:06,149 --> 00:11:07,090
Vale

243
00:11:07,090 --> 00:11:09,710
Dijimos, me interesa a mí el método

244
00:11:09,710 --> 00:11:12,190
Leer un numerito entero

245
00:11:12,190 --> 00:11:15,149
Y que me devuelva como valor de retorno el entero

246
00:11:15,149 --> 00:11:18,169
entonces, como esta clase

247
00:11:18,169 --> 00:11:20,009
que yo he llamado teclado

248
00:11:20,009 --> 00:11:22,529
no tiene propiedades

249
00:11:22,529 --> 00:11:24,870
es que este método

250
00:11:24,870 --> 00:11:26,610
es obligatoriamente

251
00:11:26,610 --> 00:11:28,450
static, es imposible que dependa

252
00:11:28,450 --> 00:11:30,049
de propiedades de la clase, es imposible

253
00:11:30,049 --> 00:11:32,149
pues entonces le marco con static

254
00:11:32,149 --> 00:11:34,669
eso que me va a permitir

255
00:11:34,669 --> 00:11:36,669
llamarlo ya desde cualquier

256
00:11:36,669 --> 00:11:38,590
sitio, porque tiene el public, claro

257
00:11:38,590 --> 00:11:40,809
con teclado

258
00:11:40,809 --> 00:11:41,990
punto leer entero

259
00:11:41,990 --> 00:11:46,100
y ya me devolverá como valor de retorno

260
00:11:46,100 --> 00:11:48,399
el int. Y ahora yo ya

261
00:11:48,399 --> 00:11:50,360
meto aquí dentro todo lo que

262
00:11:50,360 --> 00:11:52,080
quiera hacer. Entonces dijimos,

263
00:11:53,480 --> 00:11:54,039
como esto lo estamos

264
00:11:54,039 --> 00:11:55,759
usando como ejemplo, esto

265
00:11:55,759 --> 00:11:58,200
no era una cosa que había que

266
00:11:58,200 --> 00:12:00,299
entender ni de nada. Dije, vamos a cambiar

267
00:12:00,299 --> 00:12:02,279
el escáner por este objeto,

268
00:12:02,779 --> 00:12:04,179
que es otra forma de leer

269
00:12:04,179 --> 00:12:06,080
que me evita los errores del salto de línea.

270
00:12:07,080 --> 00:12:08,360
Y como luego a partir de ahí

271
00:12:08,360 --> 00:12:10,440
ya esto se va a quedar metido en este método

272
00:12:10,440 --> 00:12:11,480
y no lo voy a volver a ver,

273
00:12:12,559 --> 00:12:14,500
pues ahora mismo no nos preocupa entenderlo

274
00:12:14,500 --> 00:12:22,299
Entonces, instanciamos este objeto, que era igual que un escáner, pero sin menos problemas que el escáner, porque es más complejo.

275
00:12:23,940 --> 00:12:27,580
Y dentro del entero instanciamos este, que se instancia de esta manera.

276
00:12:29,940 --> 00:12:37,039
Y luego ya llamábamos a esta sentencia, que es la que me permite leer un número entero con este objeto.

277
00:12:38,679 --> 00:12:43,480
Este objeto me lee una cadena, luego lo transformo entero y lo devuelvo con el retorno.

278
00:12:43,480 --> 00:12:57,580
La clase BufferReader está en java.io, aquí, ¿vale?

279
00:12:58,360 --> 00:13:06,980
Y esta clase, su constructor tira a la vez de esta otra, que también se queda aquí.

280
00:13:08,700 --> 00:13:14,899
Y entonces, si quitamos esto un segundito, que es lo que mete aquí mucha basurilla,

281
00:13:15,559 --> 00:13:17,440
nos quedaba esto, ¿vale?

282
00:13:17,440 --> 00:13:20,840
Entonces el método es

283
00:13:20,840 --> 00:13:22,039
Créame este objeto

284
00:13:22,039 --> 00:13:23,659
Que es como si fuera un escáner

285
00:13:23,659 --> 00:13:25,659
Ya lo entenderemos cuando veamos entrada y salida

286
00:13:25,659 --> 00:13:27,240
Pero es como si fuera un escáner

287
00:13:27,240 --> 00:13:28,980
Y ahora este objeto

288
00:13:28,980 --> 00:13:31,340
Te lee líneas del teclado

289
00:13:31,340 --> 00:13:33,179
Y ahora tú ya

290
00:13:33,179 --> 00:13:36,299
Las conviertes a numerito entero

291
00:13:36,299 --> 00:13:37,899
¿Vale?

292
00:13:45,840 --> 00:13:47,940
Podríamos poner un escáner también

293
00:13:47,940 --> 00:13:49,740
Y hacer siempre un next line

294
00:13:49,740 --> 00:13:50,679
Y convertirlo a entero

295
00:13:50,679 --> 00:13:51,200
Y ya está

296
00:13:51,200 --> 00:13:52,440
si este

297
00:13:52,440 --> 00:13:56,940
vale, de hecho

298
00:13:56,940 --> 00:14:00,059
estoy pensando en que vamos a

299
00:14:00,059 --> 00:14:01,519
para no poner cosas

300
00:14:01,519 --> 00:14:08,320
vamos a cambiarlo

301
00:14:08,320 --> 00:14:09,879
por el escáner directamente

302
00:14:09,879 --> 00:14:17,940
vale, entonces

303
00:14:17,940 --> 00:14:24,000
sí, lo que pasa es

304
00:14:24,000 --> 00:14:25,620
claro, pero lo que hago es

305
00:14:25,620 --> 00:14:27,659
ahora no hago el next in, sino que hago

306
00:14:27,659 --> 00:14:29,360
el next line y lo convierto entero

307
00:14:29,360 --> 00:14:31,399
para que se coja el salto de línea

308
00:14:31,399 --> 00:14:33,679
porque el next line sí que coge el salto

309
00:14:33,679 --> 00:14:37,720
de línea, y así me ahorro

310
00:14:37,720 --> 00:14:39,159
eso de la excepción que

311
00:14:39,159 --> 00:14:41,299
os he puesto, entonces todos estos

312
00:14:41,299 --> 00:14:43,500
import no hacen

313
00:14:43,500 --> 00:14:45,360
falta, vale

314
00:14:45,360 --> 00:14:46,759
no, no os liéis, vamos a

315
00:14:46,759 --> 00:14:49,580
entonces vamos a hacer un método que

316
00:14:49,580 --> 00:14:53,559
me creo un objeto

317
00:14:53,559 --> 00:14:54,059
scan

318
00:14:54,059 --> 00:14:57,460
se supone que

319
00:14:57,460 --> 00:14:59,279
este método lo voy a llamar cuando el usuario

320
00:14:59,279 --> 00:15:00,440
vaya a introducir un número entero

321
00:15:00,440 --> 00:15:03,440
pero el número entero lo leo

322
00:15:03,440 --> 00:15:05,539
con next line, ¿para qué?

323
00:15:06,039 --> 00:15:07,360
para asegurarme de que el

324
00:15:07,360 --> 00:15:09,460
objeto escáner se queda con el

325
00:15:09,460 --> 00:15:11,159
salto de línea porque el next line

326
00:15:11,159 --> 00:15:13,259
elimina el salto de línea del buffer

327
00:15:13,259 --> 00:15:14,399
el next int no

328
00:15:14,399 --> 00:15:17,419
y ahora ya ese numerito que yo he leído

329
00:15:17,419 --> 00:15:18,419
en formato cadena

330
00:15:18,419 --> 00:15:21,480
lo convierto a integer parse int

331
00:15:21,480 --> 00:15:25,100
porque claro, si hiciéramos esto

332
00:15:25,100 --> 00:15:27,039
return

333
00:15:27,039 --> 00:15:29,360
scan.next

334
00:15:29,360 --> 00:15:30,000
int

335
00:15:30,000 --> 00:15:32,299
si hiciéramos esto de arriba

336
00:15:32,299 --> 00:15:35,480
el salto de línea

337
00:15:35,480 --> 00:15:37,299
se queda, entonces en la siguiente

338
00:15:37,299 --> 00:15:38,500
lectura tendría el problema

339
00:15:38,500 --> 00:15:41,580
vale, entonces no queremos hacer esto

340
00:15:41,580 --> 00:15:42,720
sino esto de abajo

341
00:15:42,720 --> 00:15:45,559
vale, pues entonces

342
00:15:45,559 --> 00:15:47,940
leer entero

343
00:15:47,940 --> 00:15:49,200
lo llamaremos

344
00:15:49,200 --> 00:15:51,139
y no tenemos que instanciar ya scan en nada

345
00:15:51,139 --> 00:15:52,299
pero ya lo va a hacer leer entero

346
00:15:52,299 --> 00:15:54,559
leer decimal lo vamos a hacer igual

347
00:15:54,559 --> 00:16:11,840
y aquí eso nos permite

348
00:16:11,840 --> 00:16:13,799
quitar esta excepción que todavía no

349
00:16:13,799 --> 00:16:15,100
las conocemos

350
00:16:15,100 --> 00:16:21,090
scan.nextline

351
00:16:22,129 --> 00:16:28,519
y este de aquí lo mismo

352
00:16:28,519 --> 00:16:32,519
leer decimal, leer cadena

353
00:16:32,519 --> 00:16:33,500
es más fácil

354
00:16:33,500 --> 00:16:39,350
leer cadena es

355
00:16:39,350 --> 00:16:41,509
directamente

356
00:16:41,509 --> 00:16:43,549
return scan next line

357
00:16:43,549 --> 00:16:48,570
bueno, para

358
00:16:48,570 --> 00:16:52,110
usar una clase única para todas las entradas y salidas

359
00:16:52,110 --> 00:16:53,809
entonces como

360
00:16:53,809 --> 00:16:55,070
diseño tiene sentido

361
00:16:55,070 --> 00:16:57,049
que esta clase

362
00:16:57,049 --> 00:16:59,929
me encapsula todo lo relacionado con la

363
00:16:59,929 --> 00:17:00,230
entrada

364
00:17:00,230 --> 00:17:03,809
entonces siempre como de nuevo

365
00:17:03,809 --> 00:17:05,410
principio de diseño básico

366
00:17:05,410 --> 00:17:07,410
vamos a encapsular

367
00:17:07,410 --> 00:17:09,710
en clases separadas

368
00:17:09,710 --> 00:17:12,210
las actividades

369
00:17:12,210 --> 00:17:14,309
que están relacionadas por significado

370
00:17:14,309 --> 00:17:15,930
pues todo lo relacionado

371
00:17:15,930 --> 00:17:16,869
con las entradas

372
00:17:16,869 --> 00:17:21,049
se va ahí, por ejemplo

373
00:17:21,049 --> 00:17:22,970
si

374
00:17:22,970 --> 00:17:25,250
era otra cosa que iba a decir ahora

375
00:17:25,250 --> 00:17:27,730
pues en lugar de hacer aquí variables locales

376
00:17:27,730 --> 00:17:29,309
podría hacer aquí

377
00:17:29,309 --> 00:17:31,170
la variable scanner static

378
00:17:31,170 --> 00:17:33,029
y que todos la usen

379
00:17:33,029 --> 00:17:35,430
único problema

380
00:17:35,430 --> 00:17:38,250
que desde el momento en que haga el primer uso

381
00:17:38,250 --> 00:17:40,250
el contexto estático de esa clase

382
00:17:40,250 --> 00:17:42,130
ya va a existir para siempre

383
00:17:42,130 --> 00:17:44,250
sin embargo aquí es variable local

384
00:17:44,250 --> 00:17:46,509
luego va a desaparecer

385
00:17:46,509 --> 00:17:47,930
cada vez que yo llame al método

386
00:17:47,930 --> 00:17:49,730
se crea y desaparece

387
00:17:49,730 --> 00:17:52,049
sin embargo si yo lo pongo aquí como variable estática

388
00:17:52,049 --> 00:17:53,930
hay un escáner ahí

389
00:17:53,930 --> 00:17:54,670
enganchado

390
00:17:54,670 --> 00:17:56,970
a la consola

391
00:17:56,970 --> 00:17:58,470
ya para siempre

392
00:17:58,470 --> 00:18:01,250
porque es una variable estática

393
00:18:01,250 --> 00:18:03,509
que aparece la primera vez que se usa esta clase

394
00:18:03,509 --> 00:18:04,529
y ahí se queda para siempre

395
00:18:04,529 --> 00:18:07,329
todo lo que sea local, en principio

396
00:18:07,329 --> 00:18:09,490
mejor, porque sólo está

397
00:18:09,490 --> 00:18:11,289
sólo existe el tiempo que se le usa

398
00:18:11,289 --> 00:18:13,430
en general, son de nuevo

399
00:18:13,430 --> 00:18:15,470
pues pautas más o menos

400
00:18:15,470 --> 00:18:17,430
generales, vale, pues yo me

401
00:18:17,430 --> 00:18:19,410
aquí tengo tres funciones

402
00:18:19,410 --> 00:18:21,710
de librería, tres métodos estáticos

403
00:18:21,710 --> 00:18:23,410
que he querido hacer porque

404
00:18:23,410 --> 00:18:25,650
me interesa, como hago muchas veces

405
00:18:25,650 --> 00:18:26,630
lo de leer datos

406
00:18:26,630 --> 00:18:29,210
pues no quiero cada vez preocuparme

407
00:18:29,210 --> 00:18:30,910
de hacer un escáner y patatín

408
00:18:30,910 --> 00:18:33,410
pues nos hacemos

409
00:18:33,410 --> 00:18:34,109
esta clase

410
00:18:34,109 --> 00:18:37,049
¿vale? con los tres métodos

411
00:18:37,049 --> 00:18:39,329
y ahora ya, por ejemplo

412
00:18:39,329 --> 00:18:41,349
que la queremos usar

413
00:18:41,349 --> 00:18:43,369
desde cualquier otro

414
00:18:43,369 --> 00:18:44,269
sitio

415
00:18:44,269 --> 00:18:47,230
desde este main que teníamos aquí

416
00:18:47,230 --> 00:18:49,289
que era el de

417
00:18:49,289 --> 00:18:51,130
clientes pedidos, pues yo me hacía un

418
00:18:51,130 --> 00:18:53,690
escáner para usarlo

419
00:18:53,690 --> 00:18:55,250
pues podría pasar

420
00:18:55,250 --> 00:18:56,009
de este escáner

421
00:18:56,009 --> 00:18:59,500
podría pasar de él

422
00:18:59,500 --> 00:19:01,440
y ahora ya, que quiero leer un decimal

423
00:19:01,440 --> 00:19:05,759
pues llamo a mi función de librería

424
00:19:05,759 --> 00:19:09,440
quería leer yo aquí

425
00:19:09,440 --> 00:19:10,900
un decimal para

426
00:19:10,900 --> 00:19:13,380
llamo a mi función de librería

427
00:19:13,380 --> 00:19:14,819
y mi función de librería, ¿dónde está?

428
00:19:15,640 --> 00:19:17,559
está en el paquete teclado

429
00:19:17,559 --> 00:19:19,799
con minúsculas y se llama teclado

430
00:19:19,799 --> 00:19:21,640
luego su nombre real

431
00:19:21,640 --> 00:19:23,740
es este, teclado punto teclado

432
00:19:23,740 --> 00:19:25,440
leer

433
00:19:25,440 --> 00:19:26,059
decimal

434
00:19:26,059 --> 00:19:28,279
ala, ya está

435
00:19:28,279 --> 00:19:32,119
ya está, ni

436
00:19:32,119 --> 00:19:34,160
escáner ni nada, que yo quiero

437
00:19:34,160 --> 00:19:36,140
leer un decimal, llamo al método de

438
00:19:36,140 --> 00:19:38,339
librería o método estático de la clase

439
00:19:38,339 --> 00:19:39,619
teclado

440
00:19:39,619 --> 00:19:42,119
que no queremos

441
00:19:42,119 --> 00:19:44,359
arrastrar todo el nombre del paquete

442
00:19:44,359 --> 00:19:45,720
¿qué hacíamos?

443
00:19:46,440 --> 00:19:48,140
un import, ¿vale?

444
00:19:48,700 --> 00:19:50,140
si yo no quiero arrastrar el

445
00:19:50,140 --> 00:19:51,980
nombre, me hago aquí un import

446
00:19:51,980 --> 00:19:53,779
y ya está

447
00:19:53,779 --> 00:19:56,140
me hago aquí el import y se acabó

448
00:19:56,720 --> 00:19:58,119
que

449
00:19:58,119 --> 00:19:59,980
aquí, por ejemplo,

450
00:20:00,079 --> 00:20:02,299
aquí teníamos el problema de que teníamos que

451
00:20:02,299 --> 00:20:04,059
quitar esto. Pues no,

452
00:20:04,160 --> 00:20:05,319
ahora ya no me hace falta esto.

453
00:20:06,720 --> 00:20:08,319
Vale, aquí queremos leer una cadena.

454
00:20:08,819 --> 00:20:10,099
Hombre, pues no la voy a leer así.

455
00:20:10,480 --> 00:20:12,099
La voy a leer con mi función de librería.

456
00:20:12,940 --> 00:20:14,180
Teclado, punto, leer

457
00:20:14,180 --> 00:20:16,240
cadena. Vale, aquí lo mismo.

458
00:20:16,920 --> 00:20:18,180
No la quiero leer así, más que

459
00:20:18,180 --> 00:20:19,859
nada porque el escáner lo acabo de quitar.

460
00:20:20,940 --> 00:20:22,140
Teclado, punto, leer

461
00:20:22,140 --> 00:20:26,710
cadena. Aquí teníamos

462
00:20:26,710 --> 00:20:31,250
lo mismo. Teclado,

463
00:20:31,250 --> 00:20:32,849
punto, leer

464
00:20:32,849 --> 00:20:45,940
sin duda

465
00:20:45,940 --> 00:20:49,539
ah, esto era un decimal, no una cadena

466
00:20:49,539 --> 00:20:54,430
vale, y teníamos más entradas

467
00:20:54,430 --> 00:20:55,089
salidas

468
00:20:55,089 --> 00:20:57,890
pues aquí teníamos una cadena

469
00:20:57,890 --> 00:21:10,779
cadena, vale

470
00:21:10,779 --> 00:21:12,619
y ya está, sí

471
00:21:12,619 --> 00:21:13,559
puedes ir al baño

472
00:21:13,559 --> 00:21:16,420
y ya casi hemos acabado

473
00:21:16,420 --> 00:21:18,720
este era el entero, este es el proyecto de clientes

474
00:21:18,720 --> 00:21:20,279
pedidos que estábamos haciendo

475
00:21:20,279 --> 00:21:24,640
Jolines

476
00:21:24,640 --> 00:21:32,480
Un segundito

477
00:21:32,480 --> 00:21:35,339
Irretul

478
00:21:35,339 --> 00:21:40,839
Teclado

479
00:21:40,839 --> 00:21:41,980
Leer

480
00:21:41,980 --> 00:21:43,680
Entero era

481
00:21:43,680 --> 00:21:46,539
Vale, pues como veis

482
00:21:46,539 --> 00:21:49,519
Hemos usado esas funciones de librería

483
00:21:49,519 --> 00:21:51,220
Ahora ya las hemos

484
00:21:51,220 --> 00:21:52,880
Reutilizado, las hemos usado

485
00:21:52,880 --> 00:21:54,200
Desde un montón de sitios

486
00:21:54,200 --> 00:21:57,099
y aquí ya esta aplicación

487
00:21:57,099 --> 00:21:59,059
mía, mi main, ya se olvida

488
00:21:59,059 --> 00:22:01,299
de toda la complejidad del escáner

489
00:22:01,299 --> 00:22:03,619
de si es

490
00:22:03,619 --> 00:22:05,259
next line, si es next in

491
00:22:05,259 --> 00:22:07,160
de todos esos detalles se olvida

492
00:22:07,160 --> 00:22:09,180
yo ya sé que tengo unos métodos

493
00:22:09,180 --> 00:22:10,440
leer decimal, leer entero

494
00:22:10,440 --> 00:22:14,049
y no solo eso

495
00:22:14,049 --> 00:22:17,130
sino, aquí habíamos llegado

496
00:22:17,130 --> 00:22:19,410
a comentar, no habíamos llegado a comentar

497
00:22:19,410 --> 00:22:24,960
y no solo eso

498
00:22:24,960 --> 00:22:27,119
como esta, en este caso

499
00:22:27,119 --> 00:22:29,160
son tres métodos muy sencillitos

500
00:22:29,160 --> 00:22:31,359
tampoco es que hayamos metido ahí 200.000 líneas

501
00:22:31,359 --> 00:22:32,799
que le ahorran mucho trabajo a nadie

502
00:22:32,799 --> 00:22:35,240
pero bueno, es un ejemplo de procedimiento

503
00:22:35,240 --> 00:22:37,259
si nosotros hacemos esto

504
00:22:37,259 --> 00:22:38,140
además, ¿qué es?

505
00:22:38,640 --> 00:22:40,519
me he hecho unas funciones de librería maravillosas

506
00:22:40,519 --> 00:22:42,940
para que la gente las use y se despreocupe

507
00:22:42,940 --> 00:22:44,640
de hacer el trabajo que hago yo aquí dentro

508
00:22:44,640 --> 00:22:47,819
si hacemos eso, hombre, la idea es documentarlo

509
00:22:47,819 --> 00:22:48,900
que menos

510
00:22:48,900 --> 00:22:51,480
para que la gente sepa qué es lo que hace eso

511
00:22:51,480 --> 00:22:52,559
qué va a usar

512
00:22:52,559 --> 00:22:55,140
documentación estándar

513
00:22:55,140 --> 00:22:57,119
con Javadoc

514
00:22:57,119 --> 00:22:59,440
que es un tipo

515
00:22:59,440 --> 00:23:01,200
concreto de comentarios

516
00:23:01,200 --> 00:23:03,500
que empiezan

517
00:23:03,500 --> 00:23:05,539
con barra

518
00:23:05,539 --> 00:23:07,000
y ahora dos asteriscos

519
00:23:07,000 --> 00:23:08,980
y en cuanto le dais a un enter

520
00:23:08,980 --> 00:23:10,539
esto lo mencionamos, ¿verdad?

521
00:23:10,980 --> 00:23:12,619
En cuanto le dais a un enter

522
00:23:12,619 --> 00:23:15,359
ya él te pone el formato de Javadoc.

523
00:23:16,319 --> 00:23:17,880
Entonces, el formato de Javadoc

524
00:23:17,880 --> 00:23:19,220
pues

525
00:23:19,220 --> 00:23:20,940
si hay parámetros, te pondría

526
00:23:20,940 --> 00:23:23,140
parameters, aquí, return

527
00:23:23,140 --> 00:23:25,140
tú aquí dices, bueno, aquí explicas

528
00:23:25,140 --> 00:23:36,440
Este método me lee un entero del teclado.

529
00:23:36,680 --> 00:23:38,579
Retún, ¿qué devuelve?

530
00:23:39,680 --> 00:23:45,519
El número entero leído.

531
00:23:46,339 --> 00:23:46,579
Vale.

532
00:23:47,319 --> 00:23:49,000
Y sería interesante que pusiéramos.

533
00:23:49,660 --> 00:23:50,500
Cuidado.

534
00:23:50,500 --> 00:23:52,839
va a dar excepción

535
00:23:52,839 --> 00:23:55,480
si lo que introduce el tipo

536
00:23:55,480 --> 00:23:57,119
no es un número

537
00:23:57,119 --> 00:23:58,539
porque el integer parseInt

538
00:23:58,539 --> 00:24:00,700
si le pasamos solo a Pepito

539
00:24:00,700 --> 00:24:01,980
pues va a cascar

540
00:24:01,980 --> 00:24:04,299
al integer parseInt

541
00:24:04,299 --> 00:24:07,359
hay que pasarle una cadena que tenga 3, 2, 7

542
00:24:07,359 --> 00:24:09,000
o menos 4, 9, 2

543
00:24:09,000 --> 00:24:10,880
el integer parseInt

544
00:24:10,880 --> 00:24:13,299
coge esta cadena y lo transformaba

545
00:24:13,299 --> 00:24:14,839
al número entero que representaba

546
00:24:14,839 --> 00:24:17,160
si yo paso una cadena que no tiene

547
00:24:17,160 --> 00:24:18,960
una secuencia de números enteros va a dar un error

548
00:24:18,960 --> 00:24:48,019
Entonces, aquí sería interesante avisar. Cuidado, si no pasas, si no escribes una cadena de números válida, da excepción. Vale, y uno lo comenta y lo deja así estupendo. Con comentarios Javadoc, que empiezan así.

549
00:24:48,019 --> 00:24:51,779
ahora, ¿qué ganamos de nuestros comentarios?

550
00:24:52,099 --> 00:24:53,319
pues que ahora alguien usa

551
00:24:53,319 --> 00:24:55,420
está usando mi clase teclado

552
00:24:55,420 --> 00:24:57,740
porque la ha conseguido, ya veremos

553
00:24:57,740 --> 00:24:58,700
cómo la ha conseguido

554
00:24:58,700 --> 00:25:01,279
ha conseguido mi clase teclado, dice

555
00:25:01,279 --> 00:25:03,720
oye, pues yo, uy que bien, tengo esta clase teclado

556
00:25:03,720 --> 00:25:04,960
que hace cositas

557
00:25:04,960 --> 00:25:06,599
voy a ver qué hace

558
00:25:06,599 --> 00:25:09,359
y esto que hago en cualquier otro entorno

559
00:25:09,359 --> 00:25:11,119
funciona exactamente igual, me da igual que sea

560
00:25:11,119 --> 00:25:13,180
Intelligent, Bins, funcionan todos igual

561
00:25:13,180 --> 00:25:15,440
le pones el punto para ver lo que te

562
00:25:15,440 --> 00:25:17,079
ofrece esta clase y dice

563
00:25:17,079 --> 00:25:18,900
ah mira, me ofrece varios, a ver

564
00:25:18,900 --> 00:25:20,180
leer entero que me ofrece

565
00:25:20,180 --> 00:25:22,779
y tú pinchas aquí

566
00:25:22,779 --> 00:25:23,460
leer entero

567
00:25:23,460 --> 00:25:26,740
y automáticamente el entorno, cualquier

568
00:25:26,740 --> 00:25:28,819
entorno, está conectado

569
00:25:28,819 --> 00:25:30,799
a los comentarios de Javadoc, cualquiera

570
00:25:30,799 --> 00:25:32,819
entonces aquí te sale lo que tú has

571
00:25:32,819 --> 00:25:34,660
escrito, este entero me lee un número

572
00:25:34,660 --> 00:25:37,140
el número entero leído, cuidadín

573
00:25:37,140 --> 00:25:38,880
si no escribes una cadena te va a dar

574
00:25:38,880 --> 00:25:41,119
excepción, ¿vale? que es la manera

575
00:25:41,119 --> 00:25:43,099
de desarrollar

576
00:25:43,099 --> 00:25:44,940
tus librerías, comentándolas

577
00:25:44,940 --> 00:25:46,839
con Javadoc y así

578
00:25:46,839 --> 00:25:49,240
el que las usa, que no le interesa

579
00:25:49,240 --> 00:25:50,759
nada el código que hay dentro

580
00:25:50,759 --> 00:25:52,019
pero sí lo que hace

581
00:25:52,019 --> 00:25:54,500
pues directamente desde su entorno

582
00:25:54,500 --> 00:25:57,180
ya dice, oye a ver que tienes, ah tienes todo esto

583
00:25:57,180 --> 00:25:58,839
vale, y cada cosa que hace

584
00:25:58,839 --> 00:26:01,099
si yo no la tuviera comentada

585
00:26:01,099 --> 00:26:02,140
si pincho la de arriba

586
00:26:02,140 --> 00:26:04,180
la de arriba

587
00:26:04,180 --> 00:26:06,700
no le he puesto el comentario javadoc

588
00:26:06,700 --> 00:26:08,740
luego no me sale nada

589
00:26:08,740 --> 00:26:10,980
no le he puesto el comentario

590
00:26:10,980 --> 00:26:12,880
tengo que deducir por el nombre que es lo que hace

591
00:26:12,880 --> 00:26:15,039
pero la de abajo al tener el comentario

592
00:26:15,039 --> 00:26:16,660
javadoc, pues que estupendo

593
00:26:16,660 --> 00:26:19,200
y ya decido, me interesa, pues sí, me interesa

594
00:26:19,200 --> 00:26:19,680
uso eso

595
00:26:19,680 --> 00:26:23,299
y esto es así en cualquier entorno

596
00:26:23,299 --> 00:26:24,200
de nuevo

597
00:26:24,200 --> 00:26:27,019
son procedimientos, normas

598
00:26:27,019 --> 00:26:29,299
a las que todos nos adaptamos

599
00:26:29,299 --> 00:26:31,160
para poder hacer

600
00:26:31,160 --> 00:26:32,279
una comunidad de desarrollo

601
00:26:32,279 --> 00:26:35,339
en la que de alguna manera progresemos

602
00:26:35,339 --> 00:26:39,640
vale, hasta aquí está claro

603
00:26:39,640 --> 00:26:51,609
perdón

604
00:26:51,609 --> 00:26:54,470
para leer stream

605
00:26:54,470 --> 00:27:06,890
A ver un momentito

606
00:27:06,890 --> 00:27:08,970
Si es por la mañana, sí

607
00:27:08,970 --> 00:27:11,049
Que me están montando la cocina

608
00:27:11,049 --> 00:27:12,009
Y la están liando el pardo

609
00:27:12,009 --> 00:27:14,450
Si es por la mañana, sí

610
00:27:14,450 --> 00:27:21,140
Vale

611
00:27:37,940 --> 00:27:46,940
vale

612
00:27:46,940 --> 00:27:48,759
hasta aquí estamos

613
00:27:48,759 --> 00:27:52,160
todo el mundo

614
00:27:52,160 --> 00:27:53,079
lo tiene ready

615
00:27:53,079 --> 00:27:59,880
bueno pues

616
00:27:59,880 --> 00:28:02,119
y ahora me diréis

617
00:28:02,119 --> 00:28:02,740
vosotros

618
00:28:02,740 --> 00:28:06,000
con todo el buen criterio del mundo

619
00:28:06,000 --> 00:28:10,279
no, para qué sirve no

620
00:28:10,279 --> 00:28:12,559
porque eso es evidente, si alguno me pregunta

621
00:28:12,559 --> 00:28:14,299
para qué sirve, es que tiene

622
00:28:14,299 --> 00:28:15,799
el cerebro de un mosquito

623
00:28:15,799 --> 00:28:18,240
¿alguien aquí tiene el cerebro de un mosquito? no

624
00:28:18,240 --> 00:28:20,440
pues entonces nadie

625
00:28:20,440 --> 00:28:22,119
me haría esa pregunta, obviamente

626
00:28:22,119 --> 00:28:23,619
¿vale?

627
00:28:24,819 --> 00:28:26,539
es evidente, las funciones

628
00:28:26,539 --> 00:28:28,720
de librería son la magia de la programación

629
00:28:28,720 --> 00:28:30,539
¿vale?

630
00:28:30,839 --> 00:28:31,759
¿las usamos continuamente?

631
00:28:32,480 --> 00:28:32,720
vale

632
00:28:32,720 --> 00:28:37,319
entonces, pero sí, la pregunta

633
00:28:37,319 --> 00:28:38,579
que sí que me haríais

634
00:28:38,579 --> 00:28:41,000
la que sí que me haríais, lógicamente

635
00:28:41,000 --> 00:28:43,359
es, menudo

636
00:28:43,359 --> 00:28:45,279
rollo, o sea, si yo ahora quiero usar esta

637
00:28:45,279 --> 00:28:47,380
clase teclado, que la tengo aquí

638
00:28:47,380 --> 00:28:48,319
en este proyecto

639
00:28:48,319 --> 00:28:50,940
de ejercicios, aquí la tengo

640
00:28:50,940 --> 00:28:53,380
encerrada en un paquete y claro

641
00:28:53,380 --> 00:28:55,119
la he podido usar desde

642
00:28:55,119 --> 00:28:56,299
otras clases

643
00:28:56,299 --> 00:28:58,200
del mismo proyecto

644
00:28:58,200 --> 00:29:01,220
pero si ahora yo quiero usar la clase teclado

645
00:29:01,220 --> 00:29:02,440
como debería querer usarla

646
00:29:02,440 --> 00:29:03,680
desde cualquier proyecto

647
00:29:03,680 --> 00:29:04,700
de cualquier parte

648
00:29:04,700 --> 00:29:05,880
porque me es muy cómoda

649
00:29:05,880 --> 00:29:06,839
me olvido del escáner

650
00:29:06,839 --> 00:29:09,539
voy a tener que ir a este proyecto

651
00:29:09,539 --> 00:29:11,519
coger este paquete

652
00:29:11,519 --> 00:29:12,880
copiarlo en mi proyecto

653
00:29:12,880 --> 00:29:15,779
pues no es la manera de trabajar

654
00:29:15,779 --> 00:29:17,700
más que nada

655
00:29:17,700 --> 00:29:18,680
en todo caso

656
00:29:18,680 --> 00:29:19,819
en nuestro caso

657
00:29:19,819 --> 00:29:20,599
si estamos nosotros

658
00:29:20,599 --> 00:29:21,880
practicando estos ejercicios

659
00:29:21,880 --> 00:29:22,819
pues sí podría serlo

660
00:29:22,819 --> 00:29:24,000
porque nos es cómodo

661
00:29:24,000 --> 00:29:25,319
pero no es la manera

662
00:29:25,319 --> 00:29:26,579
de trabajar en general

663
00:29:26,579 --> 00:29:27,339
más que nada

664
00:29:27,339 --> 00:29:28,700
porque las aplicaciones

665
00:29:28,700 --> 00:29:30,000
el término de proyecto

666
00:29:30,000 --> 00:29:33,000
es un término del entorno de desarrollo,

667
00:29:33,140 --> 00:29:35,119
de Eclipse, de IntelliJ, del que sea.

668
00:29:35,700 --> 00:29:36,259
No es de Java.

669
00:29:36,940 --> 00:29:38,700
Para Java lo único que hay es clases.

670
00:29:40,119 --> 00:29:41,319
No hay proyectos, no hay nada.

671
00:29:41,900 --> 00:29:44,039
Yo tengo que trascender un poco de esta idea

672
00:29:44,039 --> 00:29:45,259
de que tengo esto en un proyecto,

673
00:29:45,359 --> 00:29:46,220
ahora lo copio a otro.

674
00:29:46,420 --> 00:29:46,539
No.

675
00:29:47,339 --> 00:29:49,339
Tengo que sacar esto a algo más general

676
00:29:49,339 --> 00:29:52,279
para que lo pueda usar cualquier aplicación Java.

677
00:29:52,960 --> 00:29:54,619
Este me tiene un entorno de desarrollo

678
00:29:54,619 --> 00:29:56,700
o ya no, ya sea un conjunto de clases,

679
00:29:56,779 --> 00:29:58,480
pero es una aplicación Java fuera del entorno.

680
00:29:59,599 --> 00:29:59,839
Vale.

681
00:30:00,000 --> 00:30:28,519
Pues entonces, ¿qué es lo que hacemos cuando nosotros queremos ofrecer nuestras aplicaciones al exterior? Bien sean clases de librería o una aplicación con un main que ya funciona, ¿vale? Queremos ofrecer nuestra aplicación al exterior, pues no le damos a ese humano el proyecto, no le damos el proyecto, porque si le diéramos el proyecto le estaríamos obligando a que él se instale en un entorno de desarrollo, cargue el proyecto en el entorno y lo ejecute.

682
00:30:28,519 --> 00:30:29,980
obviamente no

683
00:30:29,980 --> 00:30:32,559
cuando nosotros le damos una aplicación Java

684
00:30:32,559 --> 00:30:34,559
o funciones de librería

685
00:30:34,559 --> 00:30:36,460
a alguien, ese alguien

686
00:30:36,460 --> 00:30:38,220
no tiene que tener un entorno de desarrollo

687
00:30:38,220 --> 00:30:39,880
lo único que tiene que tener es una máquina virtual

688
00:30:39,880 --> 00:30:42,299
una JVM para ejecutarlo

689
00:30:42,299 --> 00:30:43,240
no necesita nada más

690
00:30:43,240 --> 00:30:45,440
cuando os descargáis una aplicación Java

691
00:30:45,440 --> 00:30:48,579
hacéis clic y pum, esa aplicación arranca

692
00:30:48,579 --> 00:30:50,799
porque tenéis una máquina virtual que la interpreta

693
00:30:50,799 --> 00:30:52,660
pero no

694
00:30:52,660 --> 00:30:53,759
os dan un proyecto

695
00:30:53,759 --> 00:30:55,599
y lo abrís desde un entorno

696
00:30:55,599 --> 00:30:57,099
eso no lo hacéis nunca

697
00:30:57,960 --> 00:31:01,200
Bueno, pues entonces, ¿cómo distribuimos nuestras aplicaciones

698
00:31:01,200 --> 00:31:04,500
o funciones de Iberia para que funcione así la máquina virtual

699
00:31:04,500 --> 00:31:05,819
tal cual las interprete?

700
00:31:06,299 --> 00:31:09,259
Pues tenemos que empaquetarlas, tenemos que guardarlas,

701
00:31:09,359 --> 00:31:13,519
que comprimirlas de una manera que la máquina virtual sepa entender.

702
00:31:14,500 --> 00:31:16,880
Que repito, no es el formato proyecto.

703
00:31:17,240 --> 00:31:19,960
La máquina virtual de Java no entiende el formato proyecto.

704
00:31:20,680 --> 00:31:24,099
La máquina virtual de Java, ¿qué formato entiende para ejecutar

705
00:31:24,099 --> 00:31:27,000
y desentrañar y meterse dentro a cotillear?

706
00:31:27,099 --> 00:31:28,880
el

707
00:31:28,880 --> 00:31:31,039
jar

708
00:31:31,039 --> 00:31:33,759
este

709
00:31:33,759 --> 00:31:38,240
con la herramienta jar

710
00:31:38,240 --> 00:31:40,160
se generan archivos

711
00:31:40,160 --> 00:31:41,180
.jar

712
00:31:41,180 --> 00:31:46,220
y los archivos .jar son la base

713
00:31:46,220 --> 00:31:48,660
de Java, que es un archivo .jar

714
00:31:48,660 --> 00:31:50,440
algo que tiene tropecientas

715
00:31:50,440 --> 00:31:50,799
clases

716
00:31:50,799 --> 00:31:54,000
una de ellas se supone que será un mail

717
00:31:54,000 --> 00:31:56,359
y cuando a la máquina virtual le pasas

718
00:31:56,359 --> 00:31:58,240
un jar, pues ya está

719
00:31:58,240 --> 00:32:00,220
la máquina virtual es capaz de meterse

720
00:32:00,220 --> 00:32:02,039
en el jar porque ese sí que lo entiende

721
00:32:02,039 --> 00:32:04,279
no como el proyecto, lo entiende

722
00:32:04,279 --> 00:32:06,240
y de ahí busca el mail

723
00:32:06,240 --> 00:32:08,079
y se ejecuta, y ya está

724
00:32:08,079 --> 00:32:10,119
luego un fichero .jar

725
00:32:10,119 --> 00:32:12,200
es un conjunto de clases, y esa es la

726
00:32:12,200 --> 00:32:13,920
manera de distribuir el código java

727
00:32:13,920 --> 00:32:16,220
porque ese es el que la máquina virtual puede

728
00:32:16,220 --> 00:32:18,160
entender, luego

729
00:32:18,160 --> 00:32:20,160
si nosotros

730
00:32:20,160 --> 00:32:24,180
queremos este

731
00:32:24,180 --> 00:32:26,500
paquetito java teclado de aquí

732
00:32:26,500 --> 00:32:27,980
este de aquí

733
00:32:27,980 --> 00:32:30,539
distribuirlo para usarlo

734
00:32:30,539 --> 00:32:31,460
desde cualquier lado

735
00:32:31,460 --> 00:32:34,400
vamos a tener que empaquetarlo en hard

736
00:32:34,400 --> 00:32:36,680
empaquetarlo en hard

737
00:32:36,680 --> 00:32:38,599
es muy sencillo, es una herramienta

738
00:32:38,599 --> 00:32:39,980
que se puede usar desde consola

739
00:32:39,980 --> 00:32:41,240
como el zip

740
00:32:41,240 --> 00:32:44,339
pues hard con unos parámetros

741
00:32:44,339 --> 00:32:45,500
y ya está y te lo crea

742
00:32:45,500 --> 00:32:48,420
pero somos tan absolutamente

743
00:32:48,420 --> 00:32:50,900
vagos que los centros de desarrollo

744
00:32:50,900 --> 00:32:52,460
nos lo facilitan todo

745
00:32:52,460 --> 00:32:54,599
no tenemos que abrir la consola ya para nada

746
00:32:54,599 --> 00:32:56,920
desgraciadamente

747
00:32:56,920 --> 00:32:58,880
porque es la mejor manera

748
00:32:58,880 --> 00:32:59,460
de aprender

749
00:32:59,460 --> 00:33:01,279
entonces

750
00:33:01,279 --> 00:33:03,160
el entorno de desarrollo

751
00:33:03,160 --> 00:33:05,440
como me puede ayudar

752
00:33:05,440 --> 00:33:06,500
a crear un jar

753
00:33:06,500 --> 00:33:08,599
con un conjunto de clases dentro

754
00:33:08,599 --> 00:33:10,359
pues botón derecho

755
00:33:10,359 --> 00:33:12,559
export

756
00:33:12,559 --> 00:33:17,319
en cualquier lado, luego ya lo marcamos

757
00:33:17,319 --> 00:33:19,019
pero si tú vas a exportar este

758
00:33:19,019 --> 00:33:21,500
paquete, ya directamente

759
00:33:21,500 --> 00:33:23,460
hazlo ahí y ya te va a

760
00:33:23,460 --> 00:33:25,099
aparecer marcado ese paquete, aunque luego

761
00:33:25,099 --> 00:33:25,880
podrías cambiarlo

762
00:33:25,880 --> 00:33:35,299
siempre tiene que haber un empaquetado

763
00:33:35,299 --> 00:33:42,240
No es obligatorio

764
00:33:42,240 --> 00:33:44,460
O sea, puedes exportar sin empaquetado

765
00:33:44,460 --> 00:33:46,480
Pero no es recomendable

766
00:33:46,480 --> 00:33:49,079
Export

767
00:33:49,079 --> 00:33:52,619
Entonces, ¿export qué queremos exportar?

768
00:33:52,680 --> 00:33:53,519
Por nosotros hasta ahora

769
00:33:53,519 --> 00:33:56,660
Lo único que queremos exportar es un

770
00:33:56,660 --> 00:33:58,140
JAR file

771
00:33:58,140 --> 00:34:00,200
El JAR de arriba

772
00:34:00,200 --> 00:34:02,680
Porque son clases de librería

773
00:34:02,680 --> 00:34:04,759
Si fuera un proyecto con main

774
00:34:04,759 --> 00:34:06,440
Sería el de abajo, el runable

775
00:34:06,440 --> 00:34:08,980
que ahora lo mencionamos

776
00:34:08,980 --> 00:34:10,239
venga, quiero un hard file

777
00:34:10,239 --> 00:34:12,619
que es empaquetar clases sin más

778
00:34:12,619 --> 00:34:14,800
pues marcamos el hard file

779
00:34:14,800 --> 00:34:16,360
y ahora

780
00:34:16,360 --> 00:34:18,719
oye

781
00:34:18,719 --> 00:34:20,619
¿a qué fichero lo quieres empaquetar?

782
00:34:21,760 --> 00:34:22,820
pues aquí

783
00:34:22,820 --> 00:34:24,460
ya le dais un fichero .hard

784
00:34:24,460 --> 00:34:26,400
que él va a crear

785
00:34:26,400 --> 00:34:28,880
yo por ejemplo lo he puesto en el escritorio

786
00:34:28,880 --> 00:34:30,659
uno que se llame teclado.hard

787
00:34:30,659 --> 00:34:33,059
que tenga la extensión .hard

788
00:34:33,059 --> 00:34:34,179
es lo único que necesitamos

789
00:34:34,179 --> 00:34:39,659
y ahora aquí

790
00:34:39,659 --> 00:34:40,579
es que claro

791
00:34:40,579 --> 00:34:43,820
yo con la pantalla que tengo

792
00:34:43,820 --> 00:34:45,260
aquí se ve fatal

793
00:34:45,260 --> 00:34:47,199
pero en esta

794
00:34:47,199 --> 00:34:49,739
mini ventanita, os aparecerá más grande

795
00:34:49,739 --> 00:34:51,539
ahí ya podéis marcar

796
00:34:51,539 --> 00:34:53,739
el paquete o los paquetes que queréis

797
00:34:53,739 --> 00:34:55,300
exportar, ¿vale?

798
00:34:55,760 --> 00:34:57,159
pero marcamos solo

799
00:34:57,159 --> 00:34:58,559
el paquete teclado

800
00:34:58,559 --> 00:35:01,960
porque esa es la única clase

801
00:35:01,960 --> 00:35:03,179
que queremos exportar

802
00:35:03,179 --> 00:35:04,900
para usarla desde otras partes

803
00:35:04,900 --> 00:35:07,719
pero os va a aparecer

804
00:35:07,719 --> 00:35:09,760
marcado si lo habéis hecho lo de botón derecho

805
00:35:09,760 --> 00:35:10,340
desde ahí

806
00:35:10,340 --> 00:35:13,559
lo que pasa es que yo aquí no veo nada

807
00:35:13,559 --> 00:35:21,840
src

808
00:35:21,840 --> 00:35:26,780
teclado, vale

809
00:35:26,780 --> 00:35:31,349
vale

810
00:35:31,349 --> 00:35:33,570
pues ya está, nes

811
00:35:33,570 --> 00:35:36,090
dejamos todas las opciones por defecto

812
00:35:36,090 --> 00:35:37,570
porque no merece la pena

813
00:35:37,570 --> 00:35:39,309
que nos metemos a explicarlas ahora

814
00:35:39,309 --> 00:35:40,469
solo queremos ver

815
00:35:40,469 --> 00:35:43,980
ala

816
00:35:43,980 --> 00:35:46,679
vale

817
00:35:46,679 --> 00:35:49,380
si queremos

818
00:35:49,380 --> 00:35:51,380
que

819
00:35:51,380 --> 00:35:57,409
se exporte

820
00:35:57,409 --> 00:35:58,769
con la posibilidad

821
00:35:58,769 --> 00:36:00,409
de que salga el javadoc

822
00:36:00,409 --> 00:36:03,250
tenemos que marcar esta pestañita de aquí

823
00:36:03,250 --> 00:36:05,250
exportar source files

824
00:36:05,250 --> 00:36:06,670
and resources, vale

825
00:36:06,670 --> 00:36:08,769
marcáis esta pestañita

826
00:36:08,769 --> 00:36:11,409
pero esto es solo para que se vea

827
00:36:11,409 --> 00:36:11,809
la ayuda

828
00:36:11,809 --> 00:36:15,210
nada, todo por defecto

829
00:36:15,210 --> 00:36:17,170
todo por defecto

830
00:36:17,170 --> 00:36:17,750
finish

831
00:36:17,750 --> 00:36:19,590
vale

832
00:36:19,590 --> 00:36:27,550
no, era un aviso

833
00:36:27,550 --> 00:36:29,889
de que el fichero ya existía en mi caso

834
00:36:29,889 --> 00:36:31,889
vale, pues es este

835
00:36:31,889 --> 00:36:35,750
entonces, este no es

836
00:36:35,750 --> 00:36:37,949
un programa Java que la máquina virtual

837
00:36:37,949 --> 00:36:39,969
ahora mismo puede ejecutar

838
00:36:39,969 --> 00:36:40,730
porque no tiene un main

839
00:36:40,730 --> 00:36:43,590
pero es que este en particular no es para

840
00:36:43,590 --> 00:36:45,750
ejecutarlo, este es para

841
00:36:45,750 --> 00:36:47,949
usarlo desde otras aplicaciones

842
00:36:47,949 --> 00:36:49,710
no es para ejecutarlo

843
00:36:49,710 --> 00:36:51,550
porque no tiene main, es para usarlo

844
00:36:51,550 --> 00:36:53,570
desde otras, ¿vale? Pues aquí

845
00:36:53,570 --> 00:36:55,190
lo dejamos nosotros, tan feliz

846
00:36:55,190 --> 00:36:57,869
y ahora, por ejemplo

847
00:36:57,869 --> 00:36:59,570
vamos a imaginarnos que yo

848
00:36:59,570 --> 00:37:01,070
arranco un proyecto nuevo

849
00:37:01,070 --> 00:37:05,090
es solamente

850
00:37:05,090 --> 00:37:06,969
un proyecto de prueba

851
00:37:06,969 --> 00:37:10,030
y ahora voy a borrar

852
00:37:10,030 --> 00:37:15,940
es solo para...

853
00:37:15,940 --> 00:37:17,619
y aquí tengo mi proyecto de prueba

854
00:37:17,619 --> 00:37:20,599
mi proyecto de prueba

855
00:37:20,599 --> 00:37:22,739
pues yo voy a hacer cosas que lean del teclado

856
00:37:22,739 --> 00:37:24,800
y me apetecería usar

857
00:37:24,800 --> 00:37:25,579
eso

858
00:37:25,579 --> 00:37:28,420
entonces lo que yo tengo que tener es el

859
00:37:28,420 --> 00:37:30,300
JAR, pero el JAR lo tendré porque

860
00:37:30,300 --> 00:37:32,300
quien sea me lo ha dado, o lo he

861
00:37:32,300 --> 00:37:34,440
descargado yo de un repositorio, que es lo habitual

862
00:37:34,440 --> 00:37:36,159
de un repositorio lo he descargado

863
00:37:36,159 --> 00:37:36,840
y ahí lo tengo

864
00:37:36,840 --> 00:37:40,119
entonces desde mi repositorio de Maven

865
00:37:40,119 --> 00:37:41,639
o el que sea, o de GitHub

866
00:37:41,639 --> 00:37:44,239
yo me he descargado ese JAR, que me han dicho

867
00:37:44,239 --> 00:37:45,760
que está muy bien para hacer cosas

868
00:37:45,760 --> 00:37:46,860
y ya lo tengo

869
00:37:46,860 --> 00:37:49,380
¿vale? y ya está aquí

870
00:37:49,380 --> 00:37:52,460
y siempre será en JAR

871
00:37:52,460 --> 00:37:54,400
cuando yo me descargo código Java, siempre

872
00:37:54,400 --> 00:38:18,079
Pues ahí lo tengo, en cualquier lado. Vale, ahora, ¿cómo lo incorporo a mi proyecto para hacerlo accesible? ¿Cómo lo incorporo? Bueno, pues le dais botón derecho y veis donde pone Build Path. Pues Build Path, configurar Build Path.

873
00:38:18,079 --> 00:38:19,780
Build Path significa

874
00:38:19,780 --> 00:38:22,880
Configura los caminos

875
00:38:22,880 --> 00:38:26,199
En los que hay cosas

876
00:38:26,199 --> 00:38:28,059
En este proyecto

877
00:38:28,059 --> 00:38:29,119
Path es

878
00:38:29,119 --> 00:38:31,000
Configúrame, por favor

879
00:38:31,000 --> 00:38:34,639
Los caminos en los cuales va a haber recursos

880
00:38:34,639 --> 00:38:35,659
Es lo que significa

881
00:38:35,659 --> 00:38:38,480
Lo digo para que lo asocéis como regla mnemotécnica

882
00:38:38,480 --> 00:38:39,639
Ya sabéis que es camino

883
00:38:39,639 --> 00:38:42,719
Configúrame el camino a mis recursos, por favor

884
00:38:42,719 --> 00:38:44,679
Pues voy a configurarte

885
00:38:44,679 --> 00:38:46,179
Un camino al recurso teclado

886
00:38:46,179 --> 00:39:00,059
Voy a configurarte un camino a ese recurso. Teclado.jar es un recurso que me he descargado, que está por ahí. Pues, oye, por favor, configúrame los caminos a recursos, anda. Pues, venga, vamos a configurarlo. Vale.

887
00:39:00,059 --> 00:39:03,199
al darle aquí a configurar

888
00:39:03,199 --> 00:39:05,179
es que ya me sale automáticamente una pestaña

889
00:39:05,179 --> 00:39:06,900
que es librerías

890
00:39:06,900 --> 00:39:09,260
esto es para configurar el camino

891
00:39:09,260 --> 00:39:10,940
a librerías, justo, venga

892
00:39:10,940 --> 00:39:12,659
librerías, vale

893
00:39:12,659 --> 00:39:15,019
venga, pues

894
00:39:15,019 --> 00:39:16,960
pincháis en cualquiera de los dos

895
00:39:16,960 --> 00:39:20,670
classpath, para no liarnos

896
00:39:20,670 --> 00:39:22,389
porque no estamos haciendo módulos

897
00:39:22,389 --> 00:39:23,889
aquí en classpath

898
00:39:23,889 --> 00:39:26,369
y decido, venga, voy a añadir un

899
00:39:26,369 --> 00:39:28,130
jar, vale

900
00:39:28,130 --> 00:39:30,309
aquí ya aparece

901
00:39:30,309 --> 00:39:32,269
botón añadir JAR externo.

902
00:39:32,670 --> 00:39:34,230
Porque el JAR está afuera, me lo he descargado

903
00:39:34,230 --> 00:39:35,949
y está en mi escritorio, está fuera del proyecto.

904
00:39:36,809 --> 00:39:37,889
Venga, voy a añadir un JAR.

905
00:39:38,210 --> 00:39:40,650
Añadir un JAR es añadirme un camino, un recurso.

906
00:39:41,610 --> 00:39:42,590
Venga, pues lo añado.

907
00:39:42,969 --> 00:39:44,309
Y ahora ya lo buscamos.

908
00:39:45,190 --> 00:39:46,190
Lo buscamos

909
00:39:46,190 --> 00:39:46,829
donde esté.

910
00:39:52,099 --> 00:39:53,000
Añadir external.

911
00:39:53,519 --> 00:39:55,079
Porque está fuera del proyecto,

912
00:39:55,079 --> 00:39:56,059
está en el escritorio.

913
00:39:57,719 --> 00:39:57,880
Sí.

914
00:40:01,139 --> 00:40:02,099
Uno nuevo que he hecho.

915
00:40:02,940 --> 00:40:05,099
Uno nuevo limpio que he hecho

916
00:40:05,099 --> 00:40:07,300
en el que se supone que quiero usar esas utilidades.

917
00:40:08,739 --> 00:40:09,179
¿Vale?

918
00:40:09,199 --> 00:40:10,559
Entonces, he hecho un proyecto nuevo.

919
00:40:11,059 --> 00:40:12,940
En el botón derecho de ese proyecto,

920
00:40:13,059 --> 00:40:14,880
he dado BuildPad, configure BuildPad

921
00:40:14,880 --> 00:40:16,219
y se me ha abierto esto.

922
00:40:17,420 --> 00:40:19,940
Entonces, el configure BuildPad es como decirle,

923
00:40:20,920 --> 00:40:23,000
voy a configurarte caminos a recursos,

924
00:40:23,260 --> 00:40:24,219
caminos a recursos.

925
00:40:25,000 --> 00:40:25,280
¿Vale?

926
00:40:25,940 --> 00:40:27,639
Pues, las librerías son recursos.

927
00:40:28,739 --> 00:40:32,500
Pues, marco ClassPad, que es el camino de mis clases,

928
00:40:32,579 --> 00:40:33,719
dame el camino a mis clases.

929
00:40:33,719 --> 00:40:47,559
Y aquí le he dicho, oye, pues te voy a añadir un camino a un JAR externo, ¿vale? Con ADE externo al JAR, te voy a añadir un camino a un JAR externo. Lo hemos buscado en nuestro explorador de archivos y aquí apareció ya.

930
00:40:47,559 --> 00:40:50,599
entonces, no es que hayamos metido

931
00:40:50,599 --> 00:40:52,539
el JAR dentro del proyecto, no, no, el JAR

932
00:40:52,539 --> 00:40:54,880
sigue fuera, lo que hemos añadido

933
00:40:54,880 --> 00:40:55,840
es un caminito

934
00:40:55,840 --> 00:40:58,880
le hemos dicho, uy, te ha abierto un camino

935
00:40:58,880 --> 00:41:00,760
a ti proyecto, te ha abierto

936
00:41:00,760 --> 00:41:02,719
un camino, que es el camino users admin

937
00:41:02,719 --> 00:41:04,059
de esto, te ha abierto un camino

938
00:41:04,059 --> 00:41:06,539
y en ese camino tienes este recurso

939
00:41:06,539 --> 00:41:08,460
por si quisieras usarlo

940
00:41:08,460 --> 00:41:10,940
todos los

941
00:41:10,940 --> 00:41:12,780
caminos que no, todos los recursos

942
00:41:12,780 --> 00:41:13,880
que no estén aquí

943
00:41:13,880 --> 00:41:16,760
o sea, Java solamente va a poder

944
00:41:16,760 --> 00:41:18,840
acceder a lo que esté dentro

945
00:41:18,840 --> 00:41:19,800
de su proyecto

946
00:41:19,800 --> 00:41:22,739
si quiero que acceda a algo que esté fuera

947
00:41:22,739 --> 00:41:24,739
va a tener que ser

948
00:41:24,739 --> 00:41:25,840
dándole caminos aquí

949
00:41:25,840 --> 00:41:28,559
¿vale? pero bueno ahora

950
00:41:28,559 --> 00:41:30,900
quedémonos solamente con esto sin meternos en más

951
00:41:30,900 --> 00:41:32,960
¿vale? pues le hemos añadido un caminito

952
00:41:32,960 --> 00:41:34,300
a este recurso teclado

953
00:41:34,300 --> 00:41:37,260
ya lo tenemos, voy a play and close

954
00:41:37,260 --> 00:41:42,079
y ahora

955
00:41:42,079 --> 00:41:43,719
fijaos lo que nos ha parecido

956
00:41:43,719 --> 00:41:46,440
en mi proyecto de prueba

957
00:41:46,440 --> 00:41:50,730
nos ha parecido esto

958
00:41:50,730 --> 00:41:52,050
que no estaba

959
00:41:52,050 --> 00:41:55,449
y ahora esto me dice

960
00:41:55,449 --> 00:41:56,610
oye, tu proyecto

961
00:41:56,610 --> 00:41:59,269
tiene acceso a la librería de la máquina virtual

962
00:41:59,269 --> 00:42:01,610
eso como siempre, a esta tiene que tener acceso

963
00:42:01,610 --> 00:42:03,449
siempre a las clases de la máquina virtual

964
00:42:03,449 --> 00:42:05,269
tienes acceso

965
00:42:05,269 --> 00:42:07,150
a tu código fuente, lógicamente

966
00:42:07,150 --> 00:42:08,849
como no te da objeto a tu código fuente

967
00:42:08,849 --> 00:42:11,690
y tienes acceso a estos recursos

968
00:42:11,690 --> 00:42:12,829
que están en este caminito

969
00:42:12,829 --> 00:42:15,250
es decir, he añadido a mi proyecto

970
00:42:15,250 --> 00:42:16,750
un caminito, un recurso nuevo

971
00:42:16,750 --> 00:42:18,510
y ya está

972
00:42:18,510 --> 00:42:21,150
y cada vez que quiera usar ese hardware de un proyecto

973
00:42:21,150 --> 00:42:23,349
de esta manera, añado con el

974
00:42:23,349 --> 00:42:25,550
Configure Buildpad, el camino a ese recurso.

975
00:42:26,090 --> 00:42:27,710
El JAR es uno, está ahí.

976
00:42:28,889 --> 00:42:32,730
Y los proyectos, les digo, oye, que aquí tienes esto,

977
00:42:32,829 --> 00:42:34,349
oye, que aquí tienes esto y ahí tienes esto.

978
00:42:34,449 --> 00:42:34,869
Y ya está.

979
00:42:35,650 --> 00:42:38,030
Y ahora lo podemos usar como cualquier otra clase.

980
00:42:39,010 --> 00:42:41,449
De hecho, si desplegamos aquí, ¿veis?

981
00:42:41,489 --> 00:42:46,670
Si desplegamos, ¿veis que me aparece lo que hay dentro del

982
00:42:46,670 --> 00:42:46,929
JAR?

983
00:42:48,329 --> 00:42:50,289
Si desplegamos, me aparece esto.

984
00:42:50,789 --> 00:42:53,329
Como si el paquete estuviera en mi proyecto.

985
00:42:53,349 --> 00:42:54,650
que no está en mi proyecto

986
00:42:54,650 --> 00:42:57,150
el paquete está en el jar

987
00:42:57,150 --> 00:42:59,489
y al jar llego por este camino

988
00:42:59,489 --> 00:43:02,090
pero lo puedo usar exactamente igual

989
00:43:02,090 --> 00:43:03,070
que mis propias clases

990
00:43:03,070 --> 00:43:04,050
exactamente igual

991
00:43:04,050 --> 00:43:09,690
sí porque lo he exportado

992
00:43:09,690 --> 00:43:11,670
pero podría en el jar no exportarlo

993
00:43:11,670 --> 00:43:13,989
claro

994
00:43:13,989 --> 00:43:18,550
de hecho yo aquí

995
00:43:18,550 --> 00:43:20,809
solo me aparece teclado.class

996
00:43:20,809 --> 00:43:21,889
pero si yo le pincho

997
00:43:21,889 --> 00:43:23,929
me sale el código

998
00:43:23,929 --> 00:43:26,070
porque lo he exportado en el hard

999
00:43:26,070 --> 00:43:27,349
¿vale?

1000
00:43:28,730 --> 00:43:30,710
pero Raquel, pasa algo si lo importas directamente

1001
00:43:30,710 --> 00:43:32,750
¿cómo si lo importas directamente?

1002
00:43:33,070 --> 00:43:34,190
la clase y le importa

1003
00:43:34,190 --> 00:43:35,789
la clase de teclado

1004
00:43:35,789 --> 00:43:40,250
bueno, es que el import lo tendremos que hacer ahora

1005
00:43:40,250 --> 00:43:41,130
pero eso es aparte

1006
00:43:41,130 --> 00:43:44,469
yo lo que le he dicho es, le he dicho a la aplicación

1007
00:43:44,469 --> 00:43:46,010
oye, ahí tienes un paquete

1008
00:43:46,010 --> 00:43:47,389
que puedes usar

1009
00:43:47,389 --> 00:43:49,809
y ahora yo ya programo como siempre

1010
00:43:49,809 --> 00:43:51,329
ahora el import lo voy a tener que hacer sí o sí

1011
00:43:51,329 --> 00:43:53,230
pero es que eso lo hacía igualmente

1012
00:43:53,230 --> 00:43:55,050
si el paquete ya estaba dentro del proyecto

1013
00:43:55,050 --> 00:43:56,510
entonces ahora ya

1014
00:43:56,510 --> 00:43:59,030
lo que he hecho es decirle que esto

1015
00:43:59,030 --> 00:44:00,190
está aquí, que lo puedo usar

1016
00:44:00,190 --> 00:44:02,409
si yo no hago esto, no lo puedo usar

1017
00:44:02,409 --> 00:44:05,130
entonces, ahora, pues yo por ejemplo

1018
00:44:05,130 --> 00:44:06,889
pues ahora yo ya me hago mi aplicación

1019
00:44:06,889 --> 00:44:09,210
pues cualquier cosita

1020
00:44:09,210 --> 00:44:15,739
vale, mi main

1021
00:44:15,739 --> 00:44:17,320
y ahora ya

1022
00:44:17,320 --> 00:44:19,940
pues en mi

1023
00:44:19,940 --> 00:44:22,119
uy, si, nueva clase

1024
00:44:22,119 --> 00:44:28,760
pues esta es mi clase

1025
00:44:28,760 --> 00:44:29,280
main

1026
00:44:29,280 --> 00:44:32,139
ala, pues que quiero yo

1027
00:44:32,139 --> 00:44:33,820
leer un numerito entero

1028
00:44:33,820 --> 00:44:35,019
es lo primero que quiero hacer

1029
00:44:35,019 --> 00:44:36,460
pues que suerte

1030
00:44:36,460 --> 00:44:40,199
porque tengo acceso

1031
00:44:40,199 --> 00:44:41,219
a una clase teclado

1032
00:44:41,219 --> 00:44:43,239
con su ayuda y con todo

1033
00:44:43,239 --> 00:44:46,099
ahí tengo acceso, aquí ya ni escáner

1034
00:44:46,099 --> 00:44:48,099
ni nada, yo estoy accediendo

1035
00:44:48,099 --> 00:44:48,760
directamente

1036
00:44:48,760 --> 00:44:50,420
¿vale?

1037
00:44:52,000 --> 00:44:54,119
claro, el import lo tengo que hacer, lógicamente

1038
00:44:54,119 --> 00:44:55,960
pero esto es independiente

1039
00:44:55,960 --> 00:44:56,420
del otro

1040
00:44:56,420 --> 00:44:58,380
¿Vale?

1041
00:44:58,480 --> 00:45:00,059
Que ahora quiero leer una cadena

1042
00:45:00,059 --> 00:45:03,860
Uy

1043
00:45:03,860 --> 00:45:09,719
Pues ya está, yo puedo leer mi cadena

1044
00:45:09,719 --> 00:45:12,679
Tan tranquilamente

1045
00:45:12,679 --> 00:45:13,820
¿Vale?

1046
00:45:13,860 --> 00:45:15,780
Usando las funciones de esta librería

1047
00:45:15,780 --> 00:45:16,579
Que está en el jar

1048
00:45:16,579 --> 00:45:18,599
¿Vale?

1049
00:45:24,750 --> 00:45:26,550
Si yo no hubiera hecho este input

1050
00:45:26,550 --> 00:45:28,110
De hecho voy a deshacerlo

1051
00:45:28,110 --> 00:45:29,789
¿Cómo lo puedo deshacer?

1052
00:45:30,190 --> 00:45:32,210
Pues lo voy a deshacer así rápidamente

1053
00:45:32,210 --> 00:45:33,630
Diciendo quítalo del path

1054
00:45:33,630 --> 00:45:35,989
Lo digo, quítalo del camino

1055
00:45:35,989 --> 00:45:37,590
quita este camino, fuera, quitao

1056
00:45:37,590 --> 00:45:38,610
desapareció

1057
00:45:38,610 --> 00:45:41,750
quité el camino a ese recurso

1058
00:45:41,750 --> 00:45:44,030
quité el camino, ahora este import

1059
00:45:44,030 --> 00:45:45,889
me dice, pero ¿qué es esto?

1060
00:45:45,969 --> 00:45:46,730
¿qué es este paquete?

1061
00:45:47,449 --> 00:45:50,190
es que no puedo hacer import de nada porque este paquete no existe

1062
00:45:50,190 --> 00:45:50,969
no sé nada de él

1063
00:45:50,969 --> 00:45:53,869
claro, porque le hemos quitado el camino a ese paquete

1064
00:45:53,869 --> 00:45:55,349
se lo hemos quitado

1065
00:45:55,349 --> 00:45:58,230
si se lo volvemos a poner

1066
00:45:58,230 --> 00:46:02,079
al library

1067
00:46:02,079 --> 00:46:03,860
a este lanzar

1068
00:46:03,860 --> 00:46:06,000
teclado

1069
00:46:06,000 --> 00:46:09,900
ala, pues ya está

1070
00:46:09,900 --> 00:46:11,880
le hemos puesto el camino, ahora ya sí

1071
00:46:11,880 --> 00:46:13,900
reconoce ese paquete con el INP

1072
00:46:13,900 --> 00:46:15,619
¿vale?

1073
00:46:16,500 --> 00:46:17,880
entonces vamos a ver un momento

1074
00:46:17,880 --> 00:46:20,099
si ahora el tema de los

1075
00:46:20,099 --> 00:46:21,480
saltos de línea

1076
00:46:21,480 --> 00:46:23,739
me lo hace bien

1077
00:46:23,739 --> 00:46:26,099
ahora ya sí hemos codificado bien

1078
00:46:26,099 --> 00:46:27,780
esos métodos, aunque fueran dos líneas

1079
00:46:27,780 --> 00:46:32,320
¿vale? con el

1080
00:46:32,320 --> 00:46:34,059
escáner directamente sin más

1081
00:46:34,059 --> 00:46:36,119
después de hacer el next in

1082
00:46:36,119 --> 00:46:40,179
se quedaba el salto de línea

1083
00:46:40,179 --> 00:46:42,500
con lo cual no me dejaría

1084
00:46:42,500 --> 00:46:44,219
leer esto, ¿verdad?

1085
00:46:44,559 --> 00:46:46,179
o sea, no se quedaría

1086
00:46:46,179 --> 00:46:48,039
aquí a la espera porque se quedaría con el salto de línea

1087
00:46:48,039 --> 00:46:49,760
voy a ver si ahora se queda

1088
00:46:49,760 --> 00:47:06,980
vale, entero, 6

1089
00:47:06,980 --> 00:47:08,500
muy bien, cadena

1090
00:47:08,500 --> 00:47:10,900
no sé cuántos, fin, ¿vale?

1091
00:47:14,420 --> 00:47:15,320
bueno, pues que

1092
00:47:15,320 --> 00:47:17,920
queréis olvidaros de los escáneres

1093
00:47:17,920 --> 00:47:20,039
pues os hacéis el teclado .jar, os limitáis

1094
00:47:20,039 --> 00:47:22,000
a incorporarlo

1095
00:47:22,000 --> 00:47:23,519
a cada proyecto que hagáis y ya está

1096
00:47:23,519 --> 00:47:25,780
y a partir de ahí, cada vez que queréis leer algo

1097
00:47:25,780 --> 00:47:27,860
lo leéis así y ya está

1098
00:47:27,860 --> 00:47:32,179
bueno, pues esto venía como

1099
00:47:32,179 --> 00:47:33,219
ejemplo

1100
00:47:33,219 --> 00:47:36,519
de la utilidad

1101
00:47:36,519 --> 00:47:37,659
de los métodos estáticos

1102
00:47:37,659 --> 00:47:40,440
¿veis? este obviamente es un

1103
00:47:40,440 --> 00:47:42,280
método estático, lo llamo asociado al nombre

1104
00:47:42,280 --> 00:47:44,480
de la clase, ni objeto ni nada

1105
00:47:44,480 --> 00:47:45,920
es un método de librería

1106
00:47:45,920 --> 00:47:54,739
bueno, dudas