1
00:00:00,000 --> 00:00:03,400
¿Vale? Vamos a volver ya con este rollo de Static

2
00:00:03,400 --> 00:00:07,400
para ya que conocemos lo que son métodos estáticos, variables estáticas,

3
00:00:07,400 --> 00:00:10,900
usarlas para hacernos funciones de librería nuestras

4
00:00:10,900 --> 00:00:12,900
que nos puedan ser útiles.

5
00:00:12,900 --> 00:00:14,400
Por ejemplo,

6
00:00:14,400 --> 00:00:18,400
imaginaos que nos hacemos nuestra propia clase, llamémosla

7
00:00:18,400 --> 00:00:22,900
entrada por teclado, por ejemplo, llamemos a la clase entrada por teclado.

8
00:00:22,900 --> 00:00:25,400
Y hacemos en nuestra clase unos métodos

9
00:00:25,400 --> 00:00:28,400
leer entero, leer decimal,

10
00:00:28,800 --> 00:00:32,800
leer cadena y dentro del código que hagamos dentro

11
00:00:32,800 --> 00:00:36,800
pues ya hacemos los apaños que haya que hacer

12
00:00:36,800 --> 00:00:39,800
para arreglar las cosas que queramos arreglar

13
00:00:39,800 --> 00:00:42,800
que nos estén funcionando mal, como lo del next line, etc.

14
00:00:42,800 --> 00:00:46,800
Y ahora ya podremos llamar a esos métodos igual de a los del escáner.

15
00:00:47,800 --> 00:00:49,800
A lo mejor eso nos soluciona un poco la vida.

16
00:00:49,800 --> 00:00:53,800
Vamos a hacer eso como ejemplo de métodos estáticos.

17
00:00:55,800 --> 00:00:57,800
Vale, pues venga.

18
00:00:58,200 --> 00:01:00,200
Vamos a hacer un proyecto que luego vamos a,

19
00:01:00,200 --> 00:01:03,200
esa clase estática, vamos a aprender cómo empaquetarla

20
00:01:03,200 --> 00:01:05,200
para poder importarla desde cualquier otro proyecto

21
00:01:05,200 --> 00:01:07,200
y usarla yo donde quiera.

22
00:01:08,200 --> 00:01:11,200
Pues venga, vamos a hacernos un proyecto nuevo.

23
00:01:11,200 --> 00:01:15,200
Vamos a llamarle a este proyecto, por ejemplo,

24
00:01:15,200 --> 00:01:17,200
utilidades teclado.

25
00:01:19,200 --> 00:01:21,200
Utilidades.

26
00:01:25,200 --> 00:01:27,200
Utilidades teclado, por ejemplo.

27
00:01:28,200 --> 00:01:30,200
¿Vale?

28
00:01:34,200 --> 00:01:37,200
Y ahora me voy a hacer un paquete.

29
00:01:39,200 --> 00:01:42,200
Voy a quitar el módulo info este que he puesto aquí.

30
00:01:43,200 --> 00:01:45,200
Vale.

31
00:01:45,200 --> 00:01:47,200
Voy a hacerme un paquete utilidades

32
00:01:47,200 --> 00:01:49,200
que es el que luego voy a exportar.

33
00:01:50,200 --> 00:01:54,200
Utilidades teclado también lo voy a llamar

34
00:01:54,200 --> 00:01:56,200
para que se vea claro

35
00:01:56,600 --> 00:01:59,600
que es de teclado.

36
00:02:00,600 --> 00:02:02,600
Entonces.

37
00:02:04,600 --> 00:02:06,600
¿Vale? Esto es lo que me he hecho simplemente,

38
00:02:06,600 --> 00:02:08,600
una aplicación vacía, un proyecto vacío

39
00:02:08,600 --> 00:02:10,600
con un paquete utilidades teclado.

40
00:02:11,600 --> 00:02:13,600
Y aquí vamos a hacer ya la clase con métodos estáticos

41
00:02:13,600 --> 00:02:15,600
para luego usar.

42
00:02:16,600 --> 00:02:19,600
¿Vale? Pues en este paquete nos vamos a hacer una nueva clase.

43
00:02:21,600 --> 00:02:24,600
Pues bueno, cada uno el nombre que le sea más...

44
00:02:26,600 --> 00:02:28,600
Pues venga, teclado,

45
00:02:28,600 --> 00:02:30,600
porque la vamos a usar para leer.

46
00:02:30,600 --> 00:02:32,600
Pues hala, una clase teclado

47
00:02:32,600 --> 00:02:34,600
y ya está. Y ahora ya sí que quito la lupa.

48
00:02:36,600 --> 00:02:38,600
Hala, esta es mi clase teclado.

49
00:02:39,600 --> 00:02:42,600
Vale. Pues vamos a hacerle unos métodos estáticos

50
00:02:43,600 --> 00:02:46,600
públicos para poder llamarlos desde fuera.

51
00:02:48,600 --> 00:02:50,600
Este método que quiero que me haga

52
00:02:50,600 --> 00:02:52,600
me lea un entero de la consola

53
00:02:53,000 --> 00:02:55,000
leer entero.

54
00:02:55,000 --> 00:02:57,000
Me lo lea

55
00:02:57,000 --> 00:02:59,000
y me lo devuelva como valor de retorno.

56
00:02:59,000 --> 00:03:01,000
¿Vale? Esto es lo que yo quiero hacer.

57
00:03:01,000 --> 00:03:03,000
Que me lea un entero de la consola

58
00:03:03,000 --> 00:03:05,000
y me lo devuelva como valor de retorno.

59
00:03:05,000 --> 00:03:07,000
Y ahora aquí yo ya es cuando haría

60
00:03:07,000 --> 00:03:09,000
todo el rollo de hacer el escáner

61
00:03:09,000 --> 00:03:11,000
de patatín, de patatán.

62
00:03:11,000 --> 00:03:13,000
Y cuando yo quiera, una vez que tengo

63
00:03:13,000 --> 00:03:15,000
este método estático, desde otra aplicación cualquiera

64
00:03:15,000 --> 00:03:17,000
leer un entero,

65
00:03:17,000 --> 00:03:19,000
me limito a hacer teclado punto leer entero

66
00:03:19,000 --> 00:03:21,000
y me olvido de crear el escáner,

67
00:03:21,400 --> 00:03:23,400
me olvido de todo, porque ya

68
00:03:23,400 --> 00:03:25,400
está todo aquí dentro hecho.

69
00:03:25,400 --> 00:03:27,400
Bueno, pues entonces

70
00:03:27,400 --> 00:03:29,400
como es un método que vamos a programar

71
00:03:29,400 --> 00:03:31,400
una vez y luego vamos a usarlo

72
00:03:31,400 --> 00:03:33,400
desde cualquier lado sin preocuparnos

73
00:03:33,400 --> 00:03:35,400
lo que hay dentro,

74
00:03:35,400 --> 00:03:37,400
pues vamos a dejarlo bien hecho.

75
00:03:37,400 --> 00:03:39,400
Vale, pues en lugar de la clase escáner

76
00:03:39,400 --> 00:03:41,400
hay otras clases para leer

77
00:03:41,400 --> 00:03:43,400
por teclado

78
00:03:43,400 --> 00:03:45,400
que a la hora de escribir

79
00:03:45,400 --> 00:03:47,400
su declaración es más largo,

80
00:03:47,400 --> 00:03:49,400
por eso ya estaría usado solo escáner,

81
00:03:49,800 --> 00:03:51,800
pero a cambio esas clases

82
00:03:51,800 --> 00:03:53,800
no tienen el problema de que te dejen basura en el buffer.

83
00:03:53,800 --> 00:03:55,800
Pues vamos, como lo vamos

84
00:03:55,800 --> 00:03:57,800
a escribir solo una vez ahora, solo una vez

85
00:03:57,800 --> 00:03:59,800
lo vamos a escribir aquí y luego ya lo usaremos

86
00:03:59,800 --> 00:04:01,800
a través de la llamada leer teclado

87
00:04:01,800 --> 00:04:03,800
vamos a usar ahora esa clase.

88
00:04:03,800 --> 00:04:05,800
Porque solo hay que escribirlo una vez, que es aquí

89
00:04:05,800 --> 00:04:07,800
luego ya llamaremos a leer teclado.

90
00:04:07,800 --> 00:04:09,800
Vale, pues es un nombrecito

91
00:04:09,800 --> 00:04:11,800
muy largo efectivamente.

92
00:04:11,800 --> 00:04:13,800
Entonces

93
00:04:15,800 --> 00:04:17,800
la clase que yo digo

94
00:04:18,200 --> 00:04:20,200
sería esta.

95
00:04:20,200 --> 00:04:22,200
Esta clase.

96
00:04:22,200 --> 00:04:24,200
En lugar de escáner es esta.

97
00:04:24,200 --> 00:04:26,200
Y para instanciarla

98
00:04:26,200 --> 00:04:28,200
pues hay que hacer

99
00:04:28,200 --> 00:04:30,200
todo esto.

100
00:04:42,200 --> 00:04:44,200
Es decir, más largo que el new escáner.

101
00:04:44,200 --> 00:04:46,200
Por eso,

102
00:04:46,600 --> 00:04:48,600
hasta ahora he usado el escáner solo,

103
00:04:48,600 --> 00:04:50,600
aunque es un poco pataterilla

104
00:04:50,600 --> 00:04:52,600
para algunas cosas, porque escribir esto

105
00:04:52,600 --> 00:04:54,600
es más largo.

106
00:04:54,600 --> 00:04:56,600
De hecho, es newBufferReader,

107
00:04:56,600 --> 00:04:58,600
newInputStreamReader y luego ahí

108
00:04:58,600 --> 00:05:00,600
System.In.

109
00:05:00,600 --> 00:05:02,600
Todo eso.

110
00:05:02,600 --> 00:05:04,600
Claro, tengo que importar de Java.IO

111
00:05:04,600 --> 00:05:06,600
estas clases, igual que antes importaba el escáner

112
00:05:06,600 --> 00:05:08,600
pues el bufferreader

113
00:05:08,600 --> 00:05:10,600
se importa de Java.IO

114
00:05:10,600 --> 00:05:12,600
este se importa de

115
00:05:12,600 --> 00:05:14,600
Java.IO

116
00:05:15,000 --> 00:05:17,000
Vale, esta es la declaración de la clase.

117
00:05:17,000 --> 00:05:19,000
Y ahora ya la usamos para leer

118
00:05:19,000 --> 00:05:21,000
el numerito y devolverlo.

119
00:05:23,000 --> 00:05:25,000
newBufferReader,

120
00:05:25,000 --> 00:05:27,000
newInputStreamReader, System.In. Eso de ahí.

121
00:05:33,000 --> 00:05:35,000
Sí.

122
00:05:39,000 --> 00:05:41,000
Vale, la clase ya está. Pues ahora

123
00:05:41,000 --> 00:05:43,000
esta clase cómo se usa.

124
00:05:45,000 --> 00:05:47,000
Pues esta clase te ofrece un método

125
00:05:47,000 --> 00:05:49,000
que es el método

126
00:05:49,000 --> 00:05:51,000
readLine, este de aquí.

127
00:05:51,000 --> 00:05:53,000
Este método

128
00:05:53,000 --> 00:05:55,000
que este método

129
00:05:55,000 --> 00:05:57,000
te lee todo lo que le hayas metido tú

130
00:05:57,000 --> 00:05:59,000
y el salto de línea

131
00:05:59,000 --> 00:06:01,000
te lo quita, con lo cual

132
00:06:01,000 --> 00:06:03,000
nunca va a haber problemas con que se quede un salto de línea pendiente ahí.

133
00:06:03,000 --> 00:06:05,000
Te lee todo lo que has escrito

134
00:06:05,000 --> 00:06:07,000
y te quita el salto de línea.

135
00:06:07,000 --> 00:06:09,000
Pero solo hay un problema, que todo lo que has escrito

136
00:06:09,000 --> 00:06:11,000
te lo devuelve como formato string.

137
00:06:11,000 --> 00:06:13,000
¿Vale?

138
00:06:13,400 --> 00:06:15,400
Entonces, si tú has leído un número

139
00:06:15,400 --> 00:06:17,400
tienes que convertirlo luego a string.

140
00:06:17,400 --> 00:06:19,400
Pero eso es muy sencillo.

141
00:06:19,400 --> 00:06:21,400
Primero, vamos a hacerlo por partes

142
00:06:21,400 --> 00:06:23,400
para que sea más cómodo.

143
00:06:23,400 --> 00:06:25,400
Primero leemos del teclado, la línea leída del teclado.

144
00:06:25,400 --> 00:06:27,400
Esta.

145
00:06:27,400 --> 00:06:29,400
La leemos con el readLine, este de aquí.

146
00:06:29,400 --> 00:06:31,400
Vale.

147
00:06:31,400 --> 00:06:33,400
Ahora el rojo lo quitamos ahora.

148
00:06:33,400 --> 00:06:35,400
¿Vale?

149
00:06:35,400 --> 00:06:37,400
Ahora,

150
00:06:37,400 --> 00:06:39,400
ya no hay

151
00:06:39,400 --> 00:06:41,400
ningún salto de línea del teclado.

152
00:06:41,800 --> 00:06:43,800
No hay nada.

153
00:06:43,800 --> 00:06:45,800
De ese problema ya nos olvidamos afortunadamente.

154
00:06:45,800 --> 00:06:47,800
Pero claro, yo este método lo quiero

155
00:06:47,800 --> 00:06:49,800
para leer un numerito.

156
00:06:49,800 --> 00:06:51,800
Lo haré cuando esté esperando que el tío me escriba

157
00:06:51,800 --> 00:06:53,800
37, 12.

158
00:06:53,800 --> 00:06:55,800
Entonces, yo no quiero 37, 12 en formato string.

159
00:06:55,800 --> 00:06:57,800
Quiero 37, 12 en entero

160
00:06:57,800 --> 00:06:59,800
para devolverlo como entero,

161
00:06:59,800 --> 00:07:01,800
porque va a ir a una variable entera.

162
00:07:01,800 --> 00:07:03,800
Es como cuando hacía el nextIn.

163
00:07:03,800 --> 00:07:05,800
Era para llevar una variable entera.

164
00:07:05,800 --> 00:07:07,800
Entonces, vamos a convertirlo a entero.

165
00:07:07,800 --> 00:07:09,800
¿Cómo se convierte un numerito que está en una cadena string

166
00:07:10,200 --> 00:07:12,200
al entero correspondiente?

167
00:07:12,200 --> 00:07:14,200
Pues tenemos de nuevo

168
00:07:14,200 --> 00:07:16,200
un maravilloso método estático

169
00:07:16,200 --> 00:07:18,200
que está en una clase.

170
00:07:18,200 --> 00:07:20,200
¿Ves a JRE que hay tantas clases?

171
00:07:20,200 --> 00:07:22,200
La Math, la Scanner, la Patatín.

172
00:07:22,200 --> 00:07:24,200
¿Eh?

173
00:07:24,200 --> 00:07:26,200
Eh, no. Parseing.

174
00:07:26,200 --> 00:07:28,200
Tu string es para hacer lo contrario, un entero a un string.

175
00:07:28,200 --> 00:07:30,200
Vale. Pues tenemos

176
00:07:30,200 --> 00:07:32,200
una clase maravillosa que es la clase Integer

177
00:07:32,200 --> 00:07:34,200
que está ahí en la JRE

178
00:07:34,200 --> 00:07:36,200
que resulta que tiene un método

179
00:07:36,200 --> 00:07:38,200
estático estupendo

180
00:07:38,200 --> 00:07:40,200
que es el método estático parseing

181
00:07:40,200 --> 00:07:42,200
que tú le pasas un string

182
00:07:44,200 --> 00:07:46,200
y te devuelve el numerito

183
00:07:46,200 --> 00:07:48,200
entero que representa, ya guardado

184
00:07:48,200 --> 00:07:50,200
como variable entera.

185
00:07:50,200 --> 00:07:52,200
Pues eso es justo lo que queríamos devolver

186
00:07:52,200 --> 00:07:54,200
como valor de retorno.

187
00:07:54,200 --> 00:07:56,200
Pues hala eso al retun

188
00:07:56,200 --> 00:07:58,200
y tan ricamente. Eso al retun.

189
00:08:00,200 --> 00:08:02,200
Entonces sería nuestro método.

190
00:08:02,200 --> 00:08:04,200
Y eso ni va a dejar

191
00:08:04,200 --> 00:08:06,200
salto genial de tecla

192
00:08:06,200 --> 00:08:08,200
ni va a dejar nada.

193
00:08:08,200 --> 00:08:10,200
Entonces cuando queramos leer un entero llamaremos

194
00:08:10,200 --> 00:08:12,200
a teclado.leer

195
00:08:12,200 --> 00:08:14,200
entero y solucionado.

196
00:08:14,200 --> 00:08:16,200
Nos tenemos que despreocupar de todo.

197
00:08:16,200 --> 00:08:18,200
El rojo lo quitamos ahora.

198
00:08:18,200 --> 00:08:20,200
¿Qué haremos para leer un dabble?

199
00:08:20,200 --> 00:08:22,200
Pues vamos a copiar y pegar esto mismo

200
00:08:22,200 --> 00:08:24,200
pero con dabble.

201
00:08:26,200 --> 00:08:28,200
Yo quiero leer

202
00:08:28,200 --> 00:08:30,200
un decimal.

203
00:08:32,200 --> 00:08:34,200
Leer decimal. Leer dabble

204
00:08:34,200 --> 00:08:36,200
como queráis.

205
00:08:36,200 --> 00:08:38,200
Lo leo con el readline igual.

206
00:08:38,200 --> 00:08:40,200
3,7 lo que sea.

207
00:08:40,200 --> 00:08:42,200
Pero claro, yo no quiero la cadena

208
00:08:42,200 --> 00:08:44,200
3,7. Quiero su

209
00:08:44,200 --> 00:08:46,200
conversión al numerito dabble

210
00:08:46,200 --> 00:08:48,200
que representa.

211
00:08:48,200 --> 00:08:50,200
Pues de nuevo, de todas esas miles de clases que tenemos

212
00:08:50,200 --> 00:08:52,200
en la JRE, tenemos una clase

213
00:08:52,200 --> 00:08:54,200
estupenda que es la clase

214
00:08:54,200 --> 00:08:56,200
dabble.

215
00:08:56,200 --> 00:08:58,200
La clase dabble

216
00:08:58,200 --> 00:09:00,200
como veis es mayúscula.

217
00:09:00,200 --> 00:09:02,200
Mayúscula. Esto es una clase.

218
00:09:02,200 --> 00:09:04,200
No es el tipo dabble

219
00:09:04,200 --> 00:09:06,200
primitivo con minúscula. No, dabble

220
00:09:06,200 --> 00:09:08,200
es el tipo primitivo.

221
00:09:08,200 --> 00:09:10,200
Esto es mayúscula. Es otra cosa. Esto es una clase.

222
00:09:10,200 --> 00:09:12,200
Esto es una clase.

223
00:09:12,200 --> 00:09:14,200
Pues tenemos la clase dabble maravillosa

224
00:09:14,200 --> 00:09:16,200
que tiene un método estático

225
00:09:16,200 --> 00:09:18,200
que se llama parseDabble

226
00:09:20,200 --> 00:09:22,200
y este método estático

227
00:09:22,200 --> 00:09:24,200
parseDabble

228
00:09:24,200 --> 00:09:26,200
te devuelve

229
00:09:26,200 --> 00:09:28,200
el numerito dabble

230
00:09:28,200 --> 00:09:30,200
en el que ha convertido este string.

231
00:09:32,200 --> 00:09:34,200
Tengo que cambiar el método de retorno, claro.

232
00:09:34,200 --> 00:09:36,200
El valor

233
00:09:36,200 --> 00:09:38,200
de retorno es el dabble en este método.

234
00:09:38,200 --> 00:09:40,200
¿Vale?

235
00:09:40,200 --> 00:09:42,200
De nuevo

236
00:09:42,200 --> 00:09:44,200
este rojo lo quitamos ahora. No os preocupéis ahora

237
00:09:44,200 --> 00:09:46,200
por él.

238
00:09:46,200 --> 00:09:48,200
¿Vale? Pues este método yo lo llamaré

239
00:09:48,200 --> 00:09:50,200
y me devolverá

240
00:09:50,200 --> 00:09:52,200
un numerito decimal como valor de retorno

241
00:09:52,200 --> 00:09:54,200
que ha leído por teclado.

242
00:09:56,200 --> 00:09:58,200
Que queremos incorporar a esta clase

243
00:09:58,200 --> 00:10:00,200
nuestra de métodos estáticos un método

244
00:10:00,200 --> 00:10:02,200
para leer una cadena de texto,

245
00:10:02,200 --> 00:10:04,200
pero también podemos leer cadena de texto, ¿no?

246
00:10:04,200 --> 00:10:06,200
Pues venga, vamos a hacer un método

247
00:10:06,200 --> 00:10:08,200
leer cadena de texto. En este caso, ¿qué me devolverá?

248
00:10:08,200 --> 00:10:10,200
Un string

249
00:10:10,200 --> 00:10:12,200
leerCadena.

250
00:10:14,200 --> 00:10:16,200
Pero en este caso es que ya devuelvo línea

251
00:10:16,200 --> 00:10:18,200
directamente. Es que no tengo que convertirla en nada.

252
00:10:18,200 --> 00:10:20,200
No tengo que convertirla en nada.

253
00:10:20,200 --> 00:10:22,200
Porque ya la propia

254
00:10:22,200 --> 00:10:24,200
cadena es la que devuelvo. De hecho,

255
00:10:24,200 --> 00:10:26,200
podríamos meter esto aquí en el retún

256
00:10:26,200 --> 00:10:28,200
directamente y ya está.

257
00:10:28,200 --> 00:10:30,200
Vamos a meter esto en el retún.

258
00:10:30,200 --> 00:10:32,200
Vale, leerCadena es

259
00:10:32,200 --> 00:10:34,200
la propia cadena que he leído. ¡Hala, esa!

260
00:10:34,200 --> 00:10:36,200
La devuelvo valor de retorno, string.

261
00:10:36,200 --> 00:10:38,200
Bueno, pues

262
00:10:38,200 --> 00:10:40,200
tres métodos estáticos tiene esta clase, teclado.

263
00:10:48,200 --> 00:10:50,200
Y de hecho es que esta clase

264
00:10:50,200 --> 00:10:52,200
esta clase es que no podría

265
00:10:52,200 --> 00:10:54,200
tener métodos no estáticos.

266
00:10:54,200 --> 00:10:56,200
Porque fijaos lo que le pasa a esta clase.

267
00:10:56,200 --> 00:10:58,200
Esta clase no tiene propiedades.

268
00:10:58,200 --> 00:11:00,200
No tiene propiedades, con lo cual

269
00:11:00,200 --> 00:11:02,200
es imposible que haya un método

270
00:11:02,200 --> 00:11:04,200
que dependa de las propiedades de

271
00:11:04,200 --> 00:11:06,200
un objeto teclado en concreto.

272
00:11:06,200 --> 00:11:08,200
Porque si un objeto teclado no tiene

273
00:11:08,200 --> 00:11:10,200
propiedades, es imposible que haya un

274
00:11:10,200 --> 00:11:12,200
método que dependa de las propiedades de aquí.

275
00:11:12,200 --> 00:11:14,200
Es que no las hay, no existen.

276
00:11:14,200 --> 00:11:16,200
Luego, todos los métodos de una clase

277
00:11:16,200 --> 00:11:18,200
que no tiene propiedades,

278
00:11:18,200 --> 00:11:20,200
todos serán estáticos por definición.

279
00:11:20,200 --> 00:11:22,200
Todos, porque no van a depender de ningún

280
00:11:22,200 --> 00:11:24,200
objeto concreto.

281
00:11:24,200 --> 00:11:26,200
Vale, pues tengo yo mi clase estupenda.

282
00:11:26,200 --> 00:11:28,200
A falta de arreglarle el rojo, que lo vamos

283
00:11:28,200 --> 00:11:30,200
a arreglar ahora.

284
00:11:30,200 --> 00:11:32,200
Vale.

285
00:11:34,200 --> 00:11:36,200
Ahora, este rojo

286
00:11:36,200 --> 00:11:38,200
a cuento de que viene.

287
00:11:38,200 --> 00:11:40,200
Este rojo

288
00:11:40,200 --> 00:11:42,200
viene a cuento de

289
00:11:42,200 --> 00:11:44,200
una cosa que veremos en el tema

290
00:11:44,200 --> 00:11:46,200
correspondiente, pero podemos adelantar ahora un poquito.

291
00:11:46,200 --> 00:11:48,200
Como lo vamos a escribir una vez,

292
00:11:48,200 --> 00:11:50,200
ya no hay que escribirlo más.

293
00:11:50,200 --> 00:11:52,200
Podemos adelantar un poquito y tampoco va a sonar muy raro.

294
00:11:52,200 --> 00:11:54,200
Esto viene a cuento de un concepto

295
00:11:54,200 --> 00:11:56,200
en Java,

296
00:11:56,200 --> 00:11:58,200
en cualquier lenguaje,

297
00:11:58,200 --> 00:12:00,200
que es el concepto de excepción.

298
00:12:00,200 --> 00:12:02,200
¿Vale?

299
00:12:02,200 --> 00:12:04,200
Y es, cuando uno desarrolla

300
00:12:08,200 --> 00:12:10,200
las excepciones, es una forma

301
00:12:10,200 --> 00:12:12,200
de habilitar, una

302
00:12:12,200 --> 00:12:14,200
forma de avisar de que algo raro ha pasado.

303
00:12:14,200 --> 00:12:16,200
Pero avisas tú

304
00:12:16,200 --> 00:12:18,200
por código, no es que explote

305
00:12:18,200 --> 00:12:20,200
lo del ordenador, no tiene nada que ver.

306
00:12:20,200 --> 00:12:22,200
Es decir, tú puedes programar y ya veremos cómo.

307
00:12:22,200 --> 00:12:24,200
Y además,

308
00:12:24,200 --> 00:12:26,200
puedes avisar de una manera

309
00:12:26,200 --> 00:12:28,200
curiosa, ya veremos cómo es de curiosa,

310
00:12:28,200 --> 00:12:30,200
de que ha pasado algo raro.

311
00:12:30,200 --> 00:12:32,200
Bueno, pues avisar de una manera curiosa

312
00:12:32,200 --> 00:12:34,200
es lo que se llama lanzar

313
00:12:34,200 --> 00:12:36,200
una excepción.

314
00:12:36,200 --> 00:12:38,200
Las excepciones se lanzan en los programas.

315
00:12:38,200 --> 00:12:40,200
Uno, cuando hace programas, puede lanzar

316
00:12:40,200 --> 00:12:42,200
excepciones. Y es una forma

317
00:12:42,200 --> 00:12:44,200
rara, extraña, peculiar y útil,

318
00:12:44,200 --> 00:12:46,200
ya veremos cómo es de útil, de avisar

319
00:12:46,200 --> 00:12:48,200
de que ese código

320
00:12:48,200 --> 00:12:50,200
te ha hecho algo raro. Bueno,

321
00:12:50,200 --> 00:12:52,200
pues el que hizo el

322
00:12:52,200 --> 00:12:54,200
código readline, que como veis, readline

323
00:12:54,200 --> 00:12:56,200
será un método de la clase

324
00:12:56,200 --> 00:12:58,200
buffer-reader, ¿no? Porque se llama

325
00:12:58,200 --> 00:13:00,200
con el objeto in.

326
00:13:00,200 --> 00:13:02,200
Pues el que hizo este código

327
00:13:02,200 --> 00:13:04,200
utilizó esa manera

328
00:13:04,200 --> 00:13:06,200
de avisarte

329
00:13:06,200 --> 00:13:08,200
de que puede que pase algo raro.

330
00:13:08,200 --> 00:13:10,200
Hombre, y tanto que puede que pase algo raro.

331
00:13:10,200 --> 00:13:12,200
Imagínate que el teclado no está

332
00:13:12,200 --> 00:13:14,200
conectado. Es que aquí no vas a poder

333
00:13:14,200 --> 00:13:16,200
leer. Entonces, el que escribió

334
00:13:16,200 --> 00:13:18,200
este código usó esa forma de avisarte

335
00:13:18,200 --> 00:13:20,200
de que, oye, puede que pase

336
00:13:20,200 --> 00:13:22,200
algo raro, lo que es lo mismo. Puede que

337
00:13:22,200 --> 00:13:24,200
aparezca una excepción. Pasar algo

338
00:13:24,200 --> 00:13:26,200
raro es aparecer una excepción.

339
00:13:26,200 --> 00:13:28,200
Es el nombre técnico.

340
00:13:28,200 --> 00:13:30,200
Entonces, este método, como

341
00:13:30,200 --> 00:13:32,200
tiene eso programado por dentro,

342
00:13:32,200 --> 00:13:34,200
tiene esa forma de avisar,

343
00:13:34,200 --> 00:13:36,200
te obliga a decir, vale,

344
00:13:36,200 --> 00:13:38,200
como me estás avisando de que puede que pase

345
00:13:38,200 --> 00:13:40,200
algo raro, me obligas

346
00:13:40,200 --> 00:13:42,200
a mí a, en caso

347
00:13:42,200 --> 00:13:44,200
de que pase ese algo raro,

348
00:13:44,200 --> 00:13:46,200
¿yo qué haría? Si no pasa nada

349
00:13:46,200 --> 00:13:48,200
raro, el programa sigue.

350
00:13:48,200 --> 00:13:50,200
Pero me estás diciendo

351
00:13:50,200 --> 00:13:52,200
que, y si pase ese algo raro que me

352
00:13:52,200 --> 00:13:54,200
dices, ¿qué hago? Me estás obligando

353
00:13:54,200 --> 00:13:56,200
a que yo te dé

354
00:13:56,200 --> 00:13:58,200
esa alternativa.

355
00:13:58,200 --> 00:14:00,200
Vale, pues, ¿cómo se hace eso?

356
00:14:00,200 --> 00:14:02,200
Haciendo el famoso

357
00:14:02,200 --> 00:14:04,200
try catch.

358
00:14:04,200 --> 00:14:06,200
Haciendo el famoso try catch.

359
00:14:06,200 --> 00:14:08,200
Entonces, el try catch lo podemos escribir,

360
00:14:08,200 --> 00:14:10,200
se escribe así.

361
00:14:10,200 --> 00:14:12,200
Y es...

362
00:14:12,200 --> 00:14:14,200
Vamos a ver.

363
00:14:14,200 --> 00:14:16,200
Vamos a, primero, declarar

364
00:14:16,200 --> 00:14:18,200
la línea

365
00:14:18,200 --> 00:14:20,200
y luego ya intentamos leerla.

366
00:14:20,200 --> 00:14:22,200
Vamos a intentar leerla. Entonces,

367
00:14:22,200 --> 00:14:24,200
esto significa, tú tienes

368
00:14:24,200 --> 00:14:26,200
que decirle, oye, intenta leerla.

369
00:14:26,200 --> 00:14:28,200
Intenta leerla.

370
00:14:28,200 --> 00:14:30,200
Línea igual a in

371
00:14:30,200 --> 00:14:32,200
punto readline.

372
00:14:32,200 --> 00:14:34,200
Vale, que aquí estaba la sentencia peligrosa.

373
00:14:34,200 --> 00:14:36,200
Más que la peligrosa,

374
00:14:36,200 --> 00:14:38,200
la que tiene programado dentro que puede

375
00:14:38,200 --> 00:14:40,200
que te dé un aviso de excepción.

376
00:14:40,200 --> 00:14:42,200
Pues dice, venga, intenta leerla.

377
00:14:42,200 --> 00:14:44,200
Que ha ido estupendo.

378
00:14:44,200 --> 00:14:46,200
Que no me sale esa excepción.

379
00:14:46,200 --> 00:14:48,200
Ya está, no hay más que hacer. Sigo.

380
00:14:48,200 --> 00:14:50,200
Sigo, salgo de la llave

381
00:14:50,200 --> 00:14:52,200
y sigo, y sigo con el retuido y lo que fuera.

382
00:14:52,200 --> 00:14:54,200
Pero, ¿qué pasa?

383
00:14:54,200 --> 00:14:56,200
Si este código al ejecutarse,

384
00:14:56,200 --> 00:14:58,200
¡paf!, lanza

385
00:14:58,200 --> 00:15:00,200
esa excepción que tiene programada dentro

386
00:15:00,200 --> 00:15:02,200
que puede que la lance.

387
00:15:02,200 --> 00:15:04,200
Habrá un if. Si teclado no funciona,

388
00:15:04,200 --> 00:15:06,200
lánzala.

389
00:15:06,200 --> 00:15:08,200
Bueno, pues, ¿qué pasa? Pues, me obligas

390
00:15:08,200 --> 00:15:10,200
a mí a ponerte aquí

391
00:15:10,200 --> 00:15:12,200
en un catch

392
00:15:12,200 --> 00:15:14,200
lo que vas a hacer

393
00:15:14,200 --> 00:15:16,200
en el caso de que eso

394
00:15:16,200 --> 00:15:18,200
pase.

395
00:15:18,200 --> 00:15:20,200
Y yo lo pongo de esta manera.

396
00:15:22,200 --> 00:15:24,200
¿Vale?

397
00:15:24,200 --> 00:15:26,200
Entonces,

398
00:15:26,200 --> 00:15:28,200
aquí en esta parte yo pongo

399
00:15:28,200 --> 00:15:30,200
lo que quiero que se haga

400
00:15:30,200 --> 00:15:32,200
si es que como

401
00:15:32,200 --> 00:15:34,200
consecuencia de meterse en readline

402
00:15:34,200 --> 00:15:36,200
ha aparecido esa excepción.

403
00:15:36,200 --> 00:15:38,200
¿Puede aparecer? Puede que no. Lo normal es que no aparezca.

404
00:15:38,200 --> 00:15:40,200
Pero me obligas, me estás obligando

405
00:15:40,200 --> 00:15:42,200
a decir qué hacer en caso de que aparezca.

406
00:15:42,200 --> 00:15:44,200
¿Y qué hago en caso de que aparezca?

407
00:15:44,200 --> 00:15:46,200
Lo que yo ponga ahí. ¿Qué voy a hacer? Dejarlo vacío.

408
00:15:46,200 --> 00:15:48,200
Yo no quiero hacer nada.

409
00:15:48,200 --> 00:15:50,200
Voy a confiar en que va a estar siempre

410
00:15:50,200 --> 00:15:52,200
el teclado conectado y ya está.

411
00:15:52,200 --> 00:15:54,200
Pero podría poner ahí otras cosas, etc.

412
00:15:54,200 --> 00:15:56,200
Todo esto, que es importante

413
00:15:56,200 --> 00:15:58,200
controlarlo y tiene muchos detalles,

414
00:15:58,200 --> 00:16:00,200
lo veremos en el tema de excepciones.

415
00:16:00,200 --> 00:16:02,200
Ahora mismo,

416
00:16:02,200 --> 00:16:04,200
con entender la idea

417
00:16:04,200 --> 00:16:06,200
simplemente entender

418
00:16:06,200 --> 00:16:08,200
que hay códigos que tienen programado

419
00:16:08,200 --> 00:16:10,200
por dentro

420
00:16:10,200 --> 00:16:12,200
la probabilidad de que pase algo raro.

421
00:16:12,200 --> 00:16:14,200
Y los códigos que tienen programado

422
00:16:14,200 --> 00:16:16,200
por dentro, como es este método readline,

423
00:16:16,200 --> 00:16:18,200
la probabilidad de que pase algo raro,

424
00:16:18,200 --> 00:16:20,200
cuando tú los llamas

425
00:16:20,200 --> 00:16:22,200
tienes que especificar

426
00:16:22,200 --> 00:16:24,200
qué vas a hacer si pasa ese algo raro.

427
00:16:24,200 --> 00:16:26,200
Tienes que especificarlo.

428
00:16:26,200 --> 00:16:28,200
Porque te obliga el compilador. Te obliga. Tienes que especificarlo.

429
00:16:28,200 --> 00:16:30,200
Venga, me obligas a especificarlo.

430
00:16:30,200 --> 00:16:32,200
Pues lo especifico.

431
00:16:32,200 --> 00:16:34,200
Lo especifico diciendo lo que tienes que hacer es

432
00:16:34,200 --> 00:16:36,200
nada.

433
00:16:36,200 --> 00:16:38,200
Que yo podría poner aquí un chorizo de cosas, pero no lo quiero.

434
00:16:38,200 --> 00:16:40,200
Quiero nada.

435
00:16:40,200 --> 00:16:42,200
¿Vale?

436
00:16:42,200 --> 00:16:44,200
Vale, entonces, IOExcepciones,

437
00:16:44,200 --> 00:16:46,200
porque esto es a su vez otra clase

438
00:16:46,200 --> 00:16:48,200
y hay que importarla. Por eso me lo pone en rojo.

439
00:16:48,200 --> 00:16:50,200
Pero no pasa nada. La importo y ya está.

440
00:16:50,200 --> 00:16:52,200
¡Hala! Pues estupendo.

441
00:16:52,200 --> 00:16:54,200
Ya he tranquilizado

442
00:16:54,200 --> 00:16:56,200
al compilador que me dice

443
00:16:56,200 --> 00:16:58,200
cuidado con readline

444
00:16:58,200 --> 00:17:00,200
que si

445
00:17:00,200 --> 00:17:02,200
entra en el if en el que te salta excepción

446
00:17:02,200 --> 00:17:04,200
no me estás diciendo qué hacer.

447
00:17:04,200 --> 00:17:06,200
Ya te lo he dicho. Haz nada.

448
00:17:06,200 --> 00:17:08,200
¿Vale?

449
00:17:08,200 --> 00:17:10,200
¿Vale? Esta es la idea.

450
00:17:10,200 --> 00:17:12,200
Nosotros como no vamos a limitar a llamar a este método leer entero

451
00:17:12,200 --> 00:17:14,200
una vez que hemos escrito esto dentro

452
00:17:14,200 --> 00:17:16,200
ya es que nos da igual.

453
00:17:16,200 --> 00:17:18,200
Bueno, pues este mismo tryCatch

454
00:17:18,200 --> 00:17:20,200
vamos a

455
00:17:20,200 --> 00:17:22,200
todo esto mismo vamos a copiarlo

456
00:17:22,200 --> 00:17:24,200
arriba

457
00:17:24,200 --> 00:17:26,200
en las otras partes que nos daba rojo.

458
00:17:26,200 --> 00:17:28,200
Aquí.

459
00:17:28,200 --> 00:17:30,200
Aquí.

460
00:17:30,200 --> 00:17:32,200
Aquí.

461
00:17:34,200 --> 00:17:36,200
Y aquí.

462
00:17:40,200 --> 00:17:42,200
Vale.

463
00:17:42,200 --> 00:17:44,200
¡Hala! Ya no tengo ningún rojito.

464
00:17:46,200 --> 00:17:48,200
Vale. Está entendido más o menos

465
00:17:48,200 --> 00:17:50,200
estos métodos entonces. Son métodos estáticos

466
00:17:50,200 --> 00:17:52,200
que me sirven para leer

467
00:17:52,200 --> 00:17:54,200
un entero,

468
00:17:54,200 --> 00:17:56,200
para leer un decimal y para leer

469
00:17:56,200 --> 00:17:58,200
una cadena. Y nunca se van a dejar

470
00:17:58,200 --> 00:18:00,200
un salto de línea en el teclado. Nunca.

471
00:18:00,200 --> 00:18:02,200
Porque la clase UFR no lo hace.

472
00:18:02,200 --> 00:18:04,200
A diferencia de la scanner. No lo hace. Nunca.

473
00:18:06,200 --> 00:18:08,200
Y ahora ya yo uso esto cuando

474
00:18:08,200 --> 00:18:10,200
me dé la gana. Por ejemplo, vamos a hacer aquí

475
00:18:10,200 --> 00:18:12,200
un main sólo para probarlo.

476
00:18:12,200 --> 00:18:14,200
Vamos a hacer otro nuevo paquete.

477
00:18:14,200 --> 00:18:16,200
Main.

478
00:18:18,200 --> 00:18:20,200
Un nuevo paquete

479
00:18:20,200 --> 00:18:22,200
main.

480
00:18:22,200 --> 00:18:24,200
Y

481
00:18:24,200 --> 00:18:26,200
vamos a

482
00:18:28,200 --> 00:18:30,200
hacer una clase main cualquiera

483
00:18:30,200 --> 00:18:32,200
para probar esto.

484
00:18:32,200 --> 00:18:34,200
Main. Vale.

485
00:18:34,200 --> 00:18:36,200
Pues venga.

486
00:18:36,200 --> 00:18:38,200
Ahora resulta

487
00:18:38,200 --> 00:18:40,200
que yo tengo que leer un numerito entero.

488
00:18:40,200 --> 00:18:42,200
Tengo que leer un numerito entero.

489
00:18:42,200 --> 00:18:44,200
Y guardarlo en N.

490
00:18:44,200 --> 00:18:46,200
Pues me olvido de scanner.

491
00:18:46,200 --> 00:18:48,200
Me olvido de todo. Para eso tengo yo

492
00:18:48,200 --> 00:18:50,200
el método estático que me acabo de hacer

493
00:18:50,200 --> 00:18:52,200
en la clase teclado.

494
00:18:52,200 --> 00:18:54,200
Leer un entero. Y ya está. Y me olvido

495
00:18:54,200 --> 00:18:56,200
de todo.

496
00:18:56,200 --> 00:18:58,200
Ya está todo aquí metido.

497
00:19:00,200 --> 00:19:02,200
Que ahora resulta que tengo que leer

498
00:19:02,200 --> 00:19:04,200
un dabble.

499
00:19:04,200 --> 00:19:06,200
Bueno. Pues venga.

500
00:19:06,200 --> 00:19:08,200
Para eso tengo yo mi clase teclado.

501
00:19:08,200 --> 00:19:10,200
Ahí. Estupenda.

502
00:19:12,200 --> 00:19:14,200
Para leer un decimal.

503
00:19:14,200 --> 00:19:16,200
Y me despreocupo de cara de scanner. Me preocupo de todo.

504
00:19:16,200 --> 00:19:18,200
Tengo ya este método que me lo hace todo.

505
00:19:18,200 --> 00:19:20,200
Y como son estáticos, los llamo

506
00:19:20,200 --> 00:19:22,200
el nombre de la clase. Es que no tengo que hacer

507
00:19:22,200 --> 00:19:24,200
ni un teclado ni nada. No tengo que hacerlo.

508
00:19:24,200 --> 00:19:26,200
Porque son métodos estáticos.

509
00:19:26,200 --> 00:19:28,200
¿Que quiero leer una cadena?

510
00:19:30,200 --> 00:19:32,200
Bueno. Pues vale. Ahora tengo que leer

511
00:19:32,200 --> 00:19:34,200
una cadena.

512
00:19:40,200 --> 00:19:42,200
Venga. Pues ala.

513
00:19:42,200 --> 00:19:44,200
Tengo yo mi clase teclado que me ofrece

514
00:19:44,200 --> 00:19:46,200
un método

515
00:19:46,200 --> 00:19:48,200
leer cadena

516
00:19:48,200 --> 00:19:50,200
para leer una cadena.

517
00:19:50,200 --> 00:19:52,200
Y ni instancio scanner ni instancio

518
00:19:52,200 --> 00:19:54,200
nada.

519
00:19:56,200 --> 00:19:58,200
Cut.

520
00:19:58,200 --> 00:20:00,200
Y de hecho aquí, como veremos, estamos leyendo

521
00:20:00,200 --> 00:20:02,200
un número y después una cadena.

522
00:20:02,200 --> 00:20:04,200
Y no va a haber problema.

523
00:20:04,200 --> 00:20:06,200
Me va a dejar leerlo todo.

524
00:20:06,200 --> 00:20:08,200
Voy a ejecutarlo.

525
00:20:12,200 --> 00:20:14,200
Aquí se está creando.

526
00:20:14,200 --> 00:20:16,200
Ahí está la espera del entero. Está en leer

527
00:20:16,200 --> 00:20:18,200
el entero. Está ahí esperando.

528
00:20:18,200 --> 00:20:20,200
Pues venga. A la una entero.

529
00:20:20,200 --> 00:20:22,200
Y me lo muestra. Y sigue esperando.

530
00:20:22,200 --> 00:20:24,200
Sigue esperando porque ahora tiene un

531
00:20:24,200 --> 00:20:26,200
Dabble. Un leer Dabble. Ahí sigue.

532
00:20:26,200 --> 00:20:28,200
Pues venga. 56.9

533
00:20:30,200 --> 00:20:32,200
Ahí está. El Dabble lo acaba de meter.

534
00:20:32,200 --> 00:20:34,200
Y sigue esperando. Sigue esperando

535
00:20:34,200 --> 00:20:36,200
porque ahora tiene que leer una cadena.

536
00:20:36,200 --> 00:20:38,200
Como veis, no tiene el problema de que

537
00:20:38,200 --> 00:20:40,200
se haya quedado un salto de línea ahí.

538
00:20:40,200 --> 00:20:42,200
Porque Buffer no tiene ese problema.

539
00:20:42,200 --> 00:20:44,200
Pues venga. Esta cadena. Y ahí la tiene. La acaba de leer.

540
00:20:46,200 --> 00:20:48,200
Entonces,

541
00:20:48,200 --> 00:20:50,200
si usáis

542
00:20:50,200 --> 00:20:52,200
esta clase en todos

543
00:20:52,200 --> 00:20:54,200
vuestros proyectos que

544
00:20:54,200 --> 00:20:56,200
lean por teclado, pues

545
00:20:56,200 --> 00:20:58,200
lo vais a ver más fácil.

546
00:20:58,200 --> 00:21:00,200
Pasáis ya del Skype a partir

547
00:21:00,200 --> 00:21:02,200
de ahora siempre.

548
00:21:02,200 --> 00:21:04,200
¿Vale?

549
00:21:06,200 --> 00:21:08,200
Claro, ¿qué implica

550
00:21:08,200 --> 00:21:10,200
esto? Que tendréis

551
00:21:10,200 --> 00:21:12,200
que hacer un copia y pega de la

552
00:21:12,200 --> 00:21:14,200
clase teclado. Es decir,

553
00:21:14,200 --> 00:21:16,200
la clase teclado es que yo ya tengo en este proyecto.

554
00:21:16,200 --> 00:21:18,200
Que la quiero usar en otro.

555
00:21:18,200 --> 00:21:20,200
Pues, la clase

556
00:21:20,200 --> 00:21:22,200
teclado la tendré que pegar en el otro.

557
00:21:22,200 --> 00:21:24,200
¿Vale? A menos que

558
00:21:24,200 --> 00:21:26,200
la exportemos en un hard y la

559
00:21:26,200 --> 00:21:28,200
importemos. Pero eso es que no nos da tiempo de hacerlo.

560
00:21:30,200 --> 00:21:32,200
Eso es justo lo que acabo de decir.

561
00:21:32,200 --> 00:21:34,200
A menos que exportemos el paquete en un hard

562
00:21:34,200 --> 00:21:36,200
y lo importemos al classpath del otro.

563
00:21:36,200 --> 00:21:38,200
¿Vale? Pero eso es lo que prefiero

564
00:21:38,200 --> 00:21:40,200
hacer el próximo día

565
00:21:40,200 --> 00:21:42,200
para que hay que entenderlo bien.

566
00:21:42,200 --> 00:21:44,200
¿Vale?

567
00:21:44,200 --> 00:21:46,200
Entonces, ejemplo de utilidad de los

568
00:21:46,200 --> 00:21:48,200
métodos estáticos.

569
00:21:48,200 --> 00:21:50,200
Son fundamentales para hacer cosas.

570
00:21:50,200 --> 00:21:52,200
¿Vale?

571
00:21:54,200 --> 00:21:56,200
Adiós.

572
00:21:56,200 --> 00:21:58,200
Vale.

573
00:21:58,200 --> 00:22:00,200
Y vamos a aprovechar

574
00:22:00,200 --> 00:22:02,200
este ratito

575
00:22:02,200 --> 00:22:04,200
para volver

576
00:22:04,200 --> 00:22:06,200
en algo en lo que no hemos entrado

577
00:22:06,200 --> 00:22:08,200
cuando hay viendo métodos,

578
00:22:08,200 --> 00:22:10,200
incluso trycatch y todo.

579
00:22:10,200 --> 00:22:12,200
Se supone que más o menos

580
00:22:12,200 --> 00:22:14,200
tenéis claro, pero hay que

581
00:22:14,200 --> 00:22:16,200
volver en ello por si acaso.

582
00:22:18,200 --> 00:22:20,200
Por ejemplo,

583
00:22:20,200 --> 00:22:22,200
vámonos a un

584
00:22:22,200 --> 00:22:24,200
método cualquiera de la clase

585
00:22:24,200 --> 00:22:26,200
pues cualquiera, pedido, por ejemplo.

586
00:22:26,200 --> 00:22:28,200
De la clase pedido

587
00:22:28,200 --> 00:22:30,200
en la que está de aquí.

588
00:22:30,200 --> 00:22:32,200
Vámonos al método de volver

589
00:22:32,200 --> 00:22:34,200
precio total.

590
00:22:34,200 --> 00:22:36,200
¿Vale?

591
00:22:36,200 --> 00:22:38,200
Este método, ¿con qué variables se está

592
00:22:38,200 --> 00:22:40,200
trabajando?

593
00:22:40,200 --> 00:22:42,200
Con variables de tres tipos.

594
00:22:42,200 --> 00:22:44,200
Una. Bueno,

595
00:22:44,200 --> 00:22:46,200
esta no tiene parámetro.

596
00:22:46,200 --> 00:22:48,200
Con el parámetro o los parámetros

597
00:22:48,200 --> 00:22:50,200
si los tuviera. Esta en particular

598
00:22:50,200 --> 00:22:52,200
no tiene. A ver si hay alguna que

599
00:22:52,200 --> 00:22:54,200
esta sí que tiene.

600
00:22:56,200 --> 00:22:58,200
Vale, este método,

601
00:22:58,200 --> 00:23:00,200
por ejemplo.

602
00:23:00,200 --> 00:23:02,200
Este método, ¿con qué variables

603
00:23:02,200 --> 00:23:04,200
diferentes se está trabajando?

604
00:23:04,200 --> 00:23:06,200
Este método y cualquiera.

605
00:23:06,200 --> 00:23:08,200
Pues está trabajando primero

606
00:23:08,200 --> 00:23:10,200
con el parámetro

607
00:23:10,200 --> 00:23:12,200
o los parámetros que se pasen al método.

608
00:23:12,200 --> 00:23:14,200
Con eso está trabajando.

609
00:23:14,200 --> 00:23:16,200
Lo está usando, de hecho,

610
00:23:16,200 --> 00:23:18,200
en algún sitio está usando

611
00:23:18,200 --> 00:23:20,200
descripción. Aquí hay un equal

612
00:23:20,200 --> 00:23:22,200
que no se ve.

613
00:23:22,200 --> 00:23:24,200
¿No?

614
00:23:24,200 --> 00:23:26,200
Aquí lo está usando.

615
00:23:26,200 --> 00:23:28,200
Vale.

616
00:23:28,200 --> 00:23:30,200
Lo está usando ese parámetro.

617
00:23:30,200 --> 00:23:32,200
¿Está claro? Yo lo he pasado para usarlo.

618
00:23:32,200 --> 00:23:34,200
Eso está claro. Vale.

619
00:23:34,200 --> 00:23:36,200
¿Qué más está usando?

620
00:23:36,200 --> 00:23:38,200
Está usando la variable

621
00:23:38,200 --> 00:23:40,200
ItemsPedido que no ha tenido que

622
00:23:40,200 --> 00:23:42,200
declararla. Es que no solo que no tiene

623
00:23:42,200 --> 00:23:44,200
que declararla, es que no tiene que declararla.

624
00:23:44,200 --> 00:23:46,200
Porque esa variable es una variable del objeto que llama al método.

625
00:23:46,200 --> 00:23:48,200
Esta variable ItemsPedido

626
00:23:48,200 --> 00:23:50,200
está aquí arriba.

627
00:23:50,200 --> 00:23:52,200
Es esta.

628
00:23:52,200 --> 00:23:54,200
Y trabaja directamente con ella.

629
00:23:54,200 --> 00:23:56,200
Sin ningún problema. Porque es una propiedad

630
00:23:56,200 --> 00:23:58,200
del objeto que llama al método. Está ahí arriba.

631
00:23:58,200 --> 00:24:00,200
Trabaja con ella directamente. Vale.

632
00:24:00,200 --> 00:24:02,200
Bueno, pero es que además de eso, el método

633
00:24:02,200 --> 00:24:04,200
también puede trabajar, si quiere,

634
00:24:04,200 --> 00:24:06,200
con variables que declare

635
00:24:06,200 --> 00:24:08,200
él. Que declare él.

636
00:24:10,200 --> 00:24:12,200
Por ejemplo, éste

637
00:24:12,200 --> 00:24:14,200
está trabajando además

638
00:24:14,200 --> 00:24:16,200
con esta variable out, que ha declarado

639
00:24:16,200 --> 00:24:18,200
él ahí dentro. Vale.

640
00:24:18,200 --> 00:24:20,200
Pues esta variable que ha declarado

641
00:24:20,200 --> 00:24:22,200
el método ahí dentro, es lo que

642
00:24:22,200 --> 00:24:24,200
se llama una variable local del

643
00:24:24,200 --> 00:24:26,200
método. ¿No? Luego

644
00:24:26,200 --> 00:24:28,200
distinguir las variables

645
00:24:28,200 --> 00:24:30,200
locales a los métodos

646
00:24:30,200 --> 00:24:32,200
que son las que declaran ellos ahí dentro

647
00:24:32,200 --> 00:24:34,200
para hacer un uso local ahí dentro

648
00:24:34,200 --> 00:24:36,200
de las variables de la clase que

649
00:24:36,200 --> 00:24:38,200
están arriba.

650
00:24:38,200 --> 00:24:40,200
Claro, entonces

651
00:24:40,200 --> 00:24:42,200
¿qué pasa con una variable local?

652
00:24:42,200 --> 00:24:44,200
Que esa variable

653
00:24:44,200 --> 00:24:46,200
desaparece cuando el método termina.

654
00:24:46,200 --> 00:24:48,200
Desaparece. Se ha creado

655
00:24:48,200 --> 00:24:50,200
para ser usado durante el tiempo

656
00:24:50,200 --> 00:24:52,200
que dure el método. Y cuando

657
00:24:52,200 --> 00:24:54,200
el método termina, esa variable

658
00:24:54,200 --> 00:24:56,200
desaparece. Claro, porque tiene

659
00:24:56,200 --> 00:24:58,200
un uso muy concreto, que es durante el tiempo de vida

660
00:24:58,200 --> 00:25:00,200
del método. Esos son los variables locales.

661
00:25:00,200 --> 00:25:02,200
Y las variables

662
00:25:02,200 --> 00:25:04,200
locales no se declaran

663
00:25:04,200 --> 00:25:06,200
solo dentro de métodos, sino se declaran

664
00:25:06,200 --> 00:25:08,200
dentro de cualquier bloque.

665
00:25:08,200 --> 00:25:10,200
Recordad lo que llamábamos bloque al principio.

666
00:25:10,200 --> 00:25:12,200
Un bloque es un trozo de código entre llaves.

667
00:25:12,200 --> 00:25:14,200
Un trozo de código entre llaves.

668
00:25:14,200 --> 00:25:16,200
Entonces, si yo declaro una variable

669
00:25:16,200 --> 00:25:18,200
dentro de un bloque,

670
00:25:18,200 --> 00:25:20,200
esa variable es local al bloque.

671
00:25:20,200 --> 00:25:22,200
Cuando el bloque termina, la variable

672
00:25:22,200 --> 00:25:24,200
desaparece. Eso es algo

673
00:25:24,200 --> 00:25:26,200
¿qué? Más o menos. Pues con

674
00:25:26,200 --> 00:25:28,200
lo que hemos asumido, pero conviene que

675
00:25:28,200 --> 00:25:30,200
ahora volvamos a ello.

676
00:25:30,200 --> 00:25:32,200
Por ejemplo, me voy yo aquí a mi main

677
00:25:32,200 --> 00:25:34,200
este que he hecho aquí para

678
00:25:34,200 --> 00:25:36,200
probar el teclado, así no

679
00:25:36,200 --> 00:25:38,200
embasuro el otro proyecto.

680
00:25:38,200 --> 00:25:40,200
Imaginaos que yo tengo aquí

681
00:25:40,200 --> 00:25:42,200
un if que me dice, si el

682
00:25:42,200 --> 00:25:44,200
n que acabo de leer es igual a

683
00:25:44,200 --> 00:25:46,200
3, y me abro

684
00:25:46,200 --> 00:25:48,200
aquí unas llaves para hacer cosas.

685
00:25:48,200 --> 00:25:50,200
Pues al abrirme aquí unas llaves,

686
00:25:50,200 --> 00:25:52,200
esto es

687
00:25:52,200 --> 00:25:54,200
un bloque. De repente es un bloque.

688
00:25:54,200 --> 00:25:56,200
Vale, no pasa nada, un conjunto de sentencias es un bloque.

689
00:25:56,200 --> 00:25:58,200
Claro, pero ¿qué pasa si ya tiene

690
00:25:58,200 --> 00:26:00,200
un bloque? Pues que, imaginaos

691
00:26:00,200 --> 00:26:02,200
que yo declaro aquí una variable

692
00:26:02,200 --> 00:26:04,200
int m igual a 8.

693
00:26:04,200 --> 00:26:06,200
Vale, no hay

694
00:26:06,200 --> 00:26:08,200
ningún problema. ¿Qué ocurre?

695
00:26:08,200 --> 00:26:10,200
Que m aquí no

696
00:26:10,200 --> 00:26:12,200
existe, ha desaparecido.

697
00:26:12,200 --> 00:26:14,200
¿Vale? Porque es

698
00:26:14,200 --> 00:26:16,200
una variable que está declarada

699
00:26:16,200 --> 00:26:18,200
dentro del bloque.

700
00:26:18,200 --> 00:26:20,200
Luego, si yo intento aquí

701
00:26:20,200 --> 00:26:22,200
mostrar m,

702
00:26:22,200 --> 00:26:24,200
me va a decir,

703
00:26:24,200 --> 00:26:26,200
oye, m no existe, ¿quién es?

704
00:26:26,200 --> 00:26:28,200
Pues vuelvo a esto,

705
00:26:28,200 --> 00:26:30,200
más o menos, se supone

706
00:26:30,200 --> 00:26:32,200
que más o menos lo vislumbramos, conviene que

707
00:26:32,200 --> 00:26:34,200
insistamos en ello.

708
00:26:34,200 --> 00:26:36,200
m, al estar

709
00:26:36,200 --> 00:26:38,200
declarada dentro de un bloque de un código

710
00:26:38,200 --> 00:26:40,200
entre llaves, es local

711
00:26:40,200 --> 00:26:42,200
al bloque, es local.

712
00:26:42,200 --> 00:26:44,200
Luego, cuando el bloque termina, a partir

713
00:26:44,200 --> 00:26:46,200
de aquí, la variable m desapareció.

714
00:26:46,200 --> 00:26:48,200
Solo existe

715
00:26:48,200 --> 00:26:50,200
durante el tiempo que se ejecute el código.

716
00:26:50,200 --> 00:26:52,200
Como si fuera un método.

717
00:26:52,200 --> 00:26:54,200
Un método es un código entre llaves también.

718
00:26:54,200 --> 00:26:56,200
Luego, un método, al tener un código entre llaves,

719
00:26:56,200 --> 00:26:58,200
es un bloque. Las variables que yo

720
00:26:58,200 --> 00:27:00,200
declare locales a ese método, cuando el método

721
00:27:00,200 --> 00:27:02,200
ha terminado, han dejado de existir.

722
00:27:02,200 --> 00:27:04,200
Pues esto es igual.

723
00:27:04,200 --> 00:27:06,200
Entonces, que yo quiero que esa variable

724
00:27:06,200 --> 00:27:08,200
m, poder verla, que

725
00:27:08,200 --> 00:27:10,200
siga existiendo aunque este bloque termine,

726
00:27:10,200 --> 00:27:12,200
pues la declaro fuera.

727
00:27:12,200 --> 00:27:14,200
No pasa nada, la declaro fuera,

728
00:27:14,200 --> 00:27:16,200
aquí,

729
00:27:16,200 --> 00:27:18,200
y le doy,

730
00:27:18,200 --> 00:27:20,200
y ya la uso dentro, para lo que me dé la gana,

731
00:27:20,200 --> 00:27:22,200
darle valor o lo que sea, la uso dentro.

732
00:27:22,200 --> 00:27:24,200
Entonces,

733
00:27:24,200 --> 00:27:26,200
ahora ya sí puedo ver m

734
00:27:26,200 --> 00:27:28,200
si me da la gana. Puedo ver m

735
00:27:28,200 --> 00:27:30,200
porque al estar declarada fuera,

736
00:27:30,200 --> 00:27:32,200
aunque este código termine,

737
00:27:32,200 --> 00:27:34,200
la variable no desaparece porque está declarada

738
00:27:34,200 --> 00:27:36,200
fuera. Recibirá

739
00:27:36,200 --> 00:27:38,200
su valor 8, eso sí, cambiará su valor

740
00:27:38,200 --> 00:27:40,200
que pasará a ser 8.

741
00:27:40,200 --> 00:27:42,200
Y yo podré verla y tendrá aquí su valor 8.

742
00:27:42,200 --> 00:27:44,200
Pero el espacio

743
00:27:44,200 --> 00:27:46,200
de memoria m no ha desaparecido.

744
00:27:46,200 --> 00:27:48,200
¿Vale?

745
00:27:48,200 --> 00:27:50,200
Luego, cuidado porque las variables locales,

746
00:27:50,200 --> 00:27:52,200
a lo mejor uno se cree que una variable

747
00:27:52,200 --> 00:27:54,200
la puede ver desde una zona

748
00:27:54,200 --> 00:27:56,200
de un código, y dice, pero si no puedo verla,

749
00:27:56,200 --> 00:27:58,200
claro que no puedes, porque la has declarado dentro

750
00:27:58,200 --> 00:28:00,200
de un bloque, declarada

751
00:28:00,200 --> 00:28:02,200
fuera, entonces podrás verla.

752
00:28:02,200 --> 00:28:04,200
Es lo que

753
00:28:04,200 --> 00:28:06,200
yo he hecho así, de forma muy

754
00:28:06,200 --> 00:28:08,200
disimulada,

755
00:28:08,200 --> 00:28:10,200
cuando he hecho lo del

756
00:28:10,200 --> 00:28:12,200
try-catch.

757
00:28:12,200 --> 00:28:14,200
Poneos en el try-catch.

758
00:28:14,200 --> 00:28:16,200
El try-catch, de nuevo,

759
00:28:16,200 --> 00:28:18,200
me abre un bloque, por

760
00:28:18,200 --> 00:28:20,200
narices, me lo abre,

761
00:28:20,200 --> 00:28:22,200
porque por obligación, el try

762
00:28:22,200 --> 00:28:24,200
tiene que ir entre llaves.

763
00:28:24,200 --> 00:28:26,200
¿Qué hubiera pasado si yo hubiera

764
00:28:26,200 --> 00:28:28,200
declarado el string line aquí,

765
00:28:28,200 --> 00:28:30,200
en vez de aquí,

766
00:28:30,200 --> 00:28:32,200
esto fuera?

767
00:28:34,200 --> 00:28:36,200
Pues que esto no tendría sentido,

768
00:28:36,200 --> 00:28:38,200
porque al estar esto

769
00:28:38,200 --> 00:28:40,200
declarado dentro de las llaves,

770
00:28:40,200 --> 00:28:42,200
cuando el try termina,

771
00:28:42,200 --> 00:28:44,200
línea ha desaparecido,

772
00:28:44,200 --> 00:28:46,200
luego no puedo devolverla, no podría.

773
00:28:46,200 --> 00:28:48,200
Por eso,

774
00:28:48,200 --> 00:28:50,200
saco la declaración fuera,

775
00:28:50,200 --> 00:28:52,200
y valor sí que se doy aquí,

776
00:28:52,200 --> 00:28:54,200
obviamente, el valor se lo doy en el try, porque me

777
00:28:54,200 --> 00:28:56,200
obliga a hacer esto dentro de un try.

778
00:28:56,200 --> 00:28:58,200
Pero la declaración la hago fuera,

779
00:28:58,200 --> 00:29:00,200
para que cuando el try termine, yo

780
00:29:00,200 --> 00:29:02,200
poder devolverla.

781
00:29:02,200 --> 00:29:04,200
¿Vale? Luego, no perdáis de vista

782
00:29:04,200 --> 00:29:06,200
lo que se llama esto,

783
00:29:06,200 --> 00:29:08,200
el ámbito de las variables, es que una variable

784
00:29:08,200 --> 00:29:10,200
solo es visible dentro

785
00:29:10,200 --> 00:29:12,200
del bloque en el que está declarada,

786
00:29:12,200 --> 00:29:14,200
solo es visible ahí. Cuando ese bloque

787
00:29:14,200 --> 00:29:16,200
termina, esa variable ha desaparecido.

788
00:29:16,200 --> 00:29:18,200
Y a veces queremos que sea así,

789
00:29:18,200 --> 00:29:20,200
porque yo una variable solo la uso dentro de un bloque.

790
00:29:20,200 --> 00:29:22,200
Si solo la uso ahí, la declaro

791
00:29:22,200 --> 00:29:24,200
ahí. ¿Para qué quiero que sea visible

792
00:29:24,200 --> 00:29:26,200
fuera? ¿Para dar guerra? No. Yo la declaro

793
00:29:26,200 --> 00:29:28,200
donde la voy a usar. Pero claro,

794
00:29:28,200 --> 00:29:30,200
si la declaro aquí, solo la puedo usar aquí.

795
00:29:30,200 --> 00:29:32,200
Si quiero usarla fuera, la declaro fuera.

796
00:29:32,200 --> 00:29:34,200
En este

797
00:29:34,200 --> 00:29:36,200
caso, es que tengo que declararla fuera,

798
00:29:36,200 --> 00:29:38,200
porque si no, luego no puedo hacer el return.

799
00:29:40,200 --> 00:29:42,200
¿Vale?

800
00:29:48,200 --> 00:29:50,200
Como principio básico,

801
00:29:50,200 --> 00:29:52,200
uno tiene que hacer las variables

802
00:29:52,200 --> 00:29:54,200
lo más locales posible,

803
00:29:54,200 --> 00:29:56,200
para que estén

804
00:29:56,200 --> 00:29:58,200
lo más

805
00:29:58,200 --> 00:30:00,200
escondidas posibles y no molesten

806
00:30:00,200 --> 00:30:02,200
a los demás. Pero claro,

807
00:30:02,200 --> 00:30:04,200
lo más locales

808
00:30:04,200 --> 00:30:06,200
posibles, siempre y cuando

809
00:30:06,200 --> 00:30:08,200
solo se usen ahí. Si se usan

810
00:30:08,200 --> 00:30:10,200
fuera, tendré que declararle fuera.

811
00:30:14,200 --> 00:30:16,200
¿Vale?

812
00:30:16,200 --> 00:30:18,200
Y que si se abren más bloques, pues igual.

813
00:30:18,200 --> 00:30:20,200
Si

814
00:30:20,200 --> 00:30:22,200
imaginaos este if, a lo mejor podría tener

815
00:30:22,200 --> 00:30:24,200
aquí otro if. Si m

816
00:30:24,200 --> 00:30:26,200
igual a 7, cualquier

817
00:30:26,200 --> 00:30:28,200
chorrada.

818
00:30:28,200 --> 00:30:30,200
Vale. Aquí he abierto

819
00:30:30,200 --> 00:30:32,200
un bloque dentro de otro bloque.

820
00:30:32,200 --> 00:30:34,200
Lo que yo declare

821
00:30:34,200 --> 00:30:36,200
aquí, imaginaos que aquí declaro una variable

822
00:30:36,200 --> 00:30:38,200
h.

823
00:30:38,200 --> 00:30:40,200
Esta variable

824
00:30:40,200 --> 00:30:42,200
h,

825
00:30:42,200 --> 00:30:44,200
aquí fuera no existe.

826
00:30:44,200 --> 00:30:46,200
Porque solo existe dentro de este bloque

827
00:30:46,200 --> 00:30:48,200
de aquí.

828
00:30:48,200 --> 00:30:50,200
Es decir, puede haber bloques dentro de bloques.

829
00:30:50,200 --> 00:30:52,200
Aquí hay un bloque

830
00:30:52,200 --> 00:30:54,200
dentro de este otro.

831
00:30:54,200 --> 00:30:56,200
La variable h solo existe

832
00:30:56,200 --> 00:30:58,200
aquí. Solo existe ahí. Cuando yo salga

833
00:30:58,200 --> 00:31:00,200
de este bloque, h ya ha dejado de existir.

834
00:31:00,200 --> 00:31:02,200
Puede que sea eso lo que me interese

835
00:31:02,200 --> 00:31:04,200
o puede que no. En función de eso,

836
00:31:04,200 --> 00:31:06,200
decido dónde declaro.

837
00:31:06,200 --> 00:31:08,200
¿Vale?

838
00:31:08,200 --> 00:31:10,200
Luego, con esto, uno está

839
00:31:10,200 --> 00:31:12,200
trabajando todo el rato, porque claro, uno tiene que declarar

840
00:31:12,200 --> 00:31:14,200
variables, y las va declarando, y aquí dice

841
00:31:14,200 --> 00:31:16,200
ah no, espérate, que la he declarado demasiado dentro.

842
00:31:16,200 --> 00:31:18,200
Al declararla demasiado dentro, no puedo usarla

843
00:31:18,200 --> 00:31:20,200
fuera. Pues saco la declaración y la llevo arriba.

844
00:31:20,200 --> 00:31:22,200
Es algo con lo que uno está trabajando todo el rato.

845
00:31:22,200 --> 00:31:24,200
¿Vale? Pero repito,

846
00:31:24,200 --> 00:31:26,200
la idea es que

847
00:31:26,200 --> 00:31:28,200
cuanto más dentro esté una variable,

848
00:31:28,200 --> 00:31:30,200
mejor, porque así no molesta

849
00:31:30,200 --> 00:31:32,200
afuera. Porque esta h, por ejemplo,

850
00:31:32,200 --> 00:31:34,200
aquí ya no existe. Con lo cual, aquí puedo

851
00:31:34,200 --> 00:31:36,200
utilizar otra h si me da la gana.

852
00:31:36,200 --> 00:31:38,200
Pero si declaro esta h aquí,

853
00:31:38,200 --> 00:31:40,200
solamente puedo utilizar una h.

854
00:31:40,200 --> 00:31:42,200
Entonces yo declaro lo más local

855
00:31:42,200 --> 00:31:44,200
posible, siempre y cuando no

856
00:31:44,200 --> 00:31:46,200
la necesite fuera. Si la necesito fuera, es que

857
00:31:46,200 --> 00:31:48,200
ahí no hay tu tía. Tengo que declararla fuera.

858
00:31:48,200 --> 00:31:50,200
Pero si solo la necesito aquí,

859
00:31:50,200 --> 00:31:52,200
solo voy a usar h aquí, pues entonces aquí.

860
00:31:52,200 --> 00:31:54,200
Y así ya no molesta fuera

861
00:31:54,200 --> 00:31:56,200
porque ha dejado de existir. Eso

862
00:31:56,200 --> 00:31:58,200
como principio general.

863
00:31:58,200 --> 00:32:00,200
¿Vale? Para que no hagáis el truco de

864
00:32:00,200 --> 00:32:02,200
declaro todo fuera al principio y así

865
00:32:02,200 --> 00:32:04,200
no tengo problema. No. Eso es una forma de

866
00:32:04,200 --> 00:32:06,200
programar fea. Entonces tienes un montón de variables

867
00:32:06,200 --> 00:32:08,200
que no usas todo el rato en memoria.

868
00:32:08,200 --> 00:32:10,200
Todo el rato en memoria. No.

869
00:32:10,200 --> 00:32:12,200
Cuanto más locales, mejor.

870
00:32:12,200 --> 00:32:14,200
Pero siempre y cuando solo se usen

871
00:32:14,200 --> 00:32:16,200
en su bloque.

872
00:32:16,200 --> 00:32:18,200
¿Vale? Si no van saliendo hacia afuera.

873
00:32:18,200 --> 00:32:20,200
¿Vale? Pues esto es lo que se llama

874
00:32:20,200 --> 00:32:22,200
el ámbito de variables en general. Pero bueno,

875
00:32:22,200 --> 00:32:24,200
uno está trabajando con esto todo el rato.

876
00:32:24,200 --> 00:32:26,200
Vale, venga. Pues ahora sí que paramos aquí.