1
00:00:01,780 --> 00:00:30,250
Vale, pues venga, propiedades. Hemos dicho que las propiedades en este caso van a ser el nombre y el año. Si es solo el año, en realidad no hace falta poner una fecha.

2
00:00:30,250 --> 00:00:32,270
una, vale

3
00:00:32,270 --> 00:00:34,329
si es solo el año, han nacido

4
00:00:34,329 --> 00:00:36,490
en el 2315, pues un número entero

5
00:00:36,490 --> 00:00:38,549
porque quien va a haber nacido en el

6
00:00:38,549 --> 00:00:40,350
3000 millones que es lo máximo

7
00:00:40,350 --> 00:00:42,250
que llega un entero, nadie, pues entonces

8
00:00:42,250 --> 00:00:44,270
con un año

9
00:00:44,270 --> 00:00:46,390
¿qué puedes hacer? comparar si es

10
00:00:46,390 --> 00:00:48,350
antes, si es después, pues un dato

11
00:00:48,350 --> 00:00:50,030
entero te encaja perfectamente

12
00:00:50,030 --> 00:00:52,229
vale, pues venga

13
00:00:52,229 --> 00:00:54,409
quitamos lo de la ñ

14
00:00:54,409 --> 00:00:56,210
por si estamos en otro tipo

15
00:00:56,210 --> 00:00:58,170
de teclados y

16
00:00:58,170 --> 00:00:59,850
no la reconoce

17
00:00:59,850 --> 00:01:01,950
Hacemos un constructor

18
00:01:01,950 --> 00:01:04,010
Con parámetros

19
00:01:04,010 --> 00:01:08,040
Vale, y ahora

20
00:01:08,040 --> 00:01:12,000
Y ahora dice

21
00:01:12,000 --> 00:01:14,040
La deberíamos hacer get y set

22
00:01:14,040 --> 00:01:15,420
Porque las propiedades son privadas

23
00:01:15,420 --> 00:01:16,340
Entonces

24
00:01:16,340 --> 00:01:20,500
Hacemos get y set

25
00:01:20,500 --> 00:01:21,239
Vale

26
00:01:21,239 --> 00:01:27,849
Vale, pues venga

27
00:01:27,849 --> 00:01:29,689
Ahora, dice

28
00:01:29,689 --> 00:01:31,450
Incorporar un método

29
00:01:31,450 --> 00:01:34,150
Crear alumno

30
00:01:34,150 --> 00:01:35,609
Que recibe unos parámetros

31
00:01:35,609 --> 00:01:38,069
Y crea un objeto alumno con esos parámetros

32
00:01:38,069 --> 00:01:40,290
y lo devuelve como valor de retorno.

33
00:01:41,629 --> 00:01:44,530
Vale, pues entonces, el método crearAlumno

34
00:01:44,530 --> 00:01:48,870
devuelve un objeto alumno como valor de retorno.

35
00:01:50,090 --> 00:01:53,969
Este es su nombre y recibe los parámetros necesarios

36
00:01:53,969 --> 00:01:56,670
para crear el objeto, nombre y año.

37
00:02:09,000 --> 00:02:13,719
Vale, pues entonces, este método instancia el objeto

38
00:02:13,719 --> 00:02:17,099
y lo crea.

39
00:02:17,099 --> 00:02:20,460
entonces, este método puede ser simplemente así

40
00:02:20,460 --> 00:02:31,110
¿vale? podría ser simplemente así

41
00:02:31,110 --> 00:02:34,250
entonces, este método

42
00:02:34,250 --> 00:02:37,889
es un método que nos permite crear objetos alumno

43
00:02:37,889 --> 00:02:40,449
cuando no tenemos acceso al constructor

44
00:02:40,449 --> 00:02:43,969
por ejemplo, es decir, aquí el constructor

45
00:02:43,969 --> 00:02:46,789
podría estar puesto con el modificador

46
00:02:46,789 --> 00:02:48,969
de, donde tengo el constructor hecho

47
00:02:48,969 --> 00:02:50,490
donde lo tengo, aquí

48
00:02:50,490 --> 00:02:54,270
el constructor podría ser así

49
00:02:57,400 --> 00:02:57,539
¿Vale?

50
00:02:57,560 --> 00:02:59,400
El constructor podría tener este modificador.

51
00:02:59,879 --> 00:03:01,460
Entonces, al tener este modificador, ¿qué ocurre?

52
00:03:01,539 --> 00:03:05,900
Que nadie puede instanciar objetos alumno con new alumno.

53
00:03:06,259 --> 00:03:06,840
Nadie puede.

54
00:03:07,259 --> 00:03:09,000
Porque el constructor tiene este modificador.

55
00:03:09,919 --> 00:03:14,639
Entonces, ¿cómo permitiríamos en este caso crear objetos alumno?

56
00:03:14,699 --> 00:03:17,500
Pues tendríamos que hacer un método aparte para crearlos.

57
00:03:18,000 --> 00:03:18,240
¿Vale?

58
00:03:18,240 --> 00:03:20,419
Pues no pasa nada, podría uno hacer este método.

59
00:03:22,080 --> 00:03:23,000
Crear alumno.

60
00:03:23,000 --> 00:03:25,280
entonces, este método

61
00:03:25,280 --> 00:03:27,560
ya sí que usa el constructor

62
00:03:27,560 --> 00:03:29,680
lo usa para instanciar un objeto

63
00:03:29,680 --> 00:03:31,060
y él sí que puede

64
00:03:31,060 --> 00:03:33,979
porque el constructor está en la misma clase

65
00:03:33,979 --> 00:03:35,620
entonces

66
00:03:35,620 --> 00:03:37,280
aunque tenga el modificador privado

67
00:03:37,280 --> 00:03:38,740
aunque tenga el modificador privado

68
00:03:38,740 --> 00:03:40,860
desde esta clase se puede usar

69
00:03:40,860 --> 00:03:43,259
todo lo de ella misma, aunque sea privado

70
00:03:43,259 --> 00:03:45,319
entonces

71
00:03:45,319 --> 00:03:47,340
este método sería el que

72
00:03:47,340 --> 00:03:48,979
las clases de fuera utilizarían

73
00:03:48,979 --> 00:03:51,319
porque no pueden instanciar un objeto con el constructor

74
00:03:51,319 --> 00:03:53,759
¿Vale? Entonces

75
00:03:53,759 --> 00:03:56,180
Vamos a hacer un main en paralelo

76
00:03:56,180 --> 00:03:57,159
Para irlo entendiendo

77
00:03:57,159 --> 00:04:02,080
Hacemos un paquete main

78
00:04:02,080 --> 00:04:02,919
Por ejemplo

79
00:04:02,919 --> 00:04:05,360
Y vamos a hacer una clase main

80
00:04:05,360 --> 00:04:15,229
¿Vale?

81
00:04:17,089 --> 00:04:18,589
Pues entonces, por ejemplo

82
00:04:18,589 --> 00:04:19,649
Si uno quisiera

83
00:04:19,649 --> 00:04:21,990
Crear aquí un objeto alumno

84
00:04:21,990 --> 00:04:23,170
Un objeto alumno

85
00:04:23,170 --> 00:04:25,930
Para hacer lo que fuera con él

86
00:04:25,930 --> 00:04:31,180
Pues con unos datos que ha leído por teclado

87
00:04:31,180 --> 00:04:32,480
O como fuera

88
00:04:32,480 --> 00:04:33,819
Nos da lo mismo

89
00:04:33,819 --> 00:04:36,220
Juan que ha nacido en el 2000

90
00:04:36,220 --> 00:04:41,759
pues primero la clase habría que importarla

91
00:04:41,759 --> 00:04:43,899
claro, importamos alumno

92
00:04:43,899 --> 00:04:46,680
pero incluso habiendo importado la clase

93
00:04:46,680 --> 00:04:47,819
el compilador me dice

94
00:04:47,819 --> 00:04:50,579
no puedes instanciar un objeto así

95
00:04:50,579 --> 00:04:53,779
y eso ocurre a menudo con clases que ya están hechas

96
00:04:53,779 --> 00:04:56,740
que usamos nosotros de la librería virtual

97
00:04:56,740 --> 00:04:59,399
que no podemos instanciarlas llamando al constructor

98
00:04:59,399 --> 00:05:02,939
¿por qué? pues porque el constructor está puesto como privado

99
00:05:02,939 --> 00:05:05,079
¿vale? aquí está puesto como privado

100
00:05:05,079 --> 00:05:07,180
luego no podemos crearlas así

101
00:05:07,180 --> 00:05:09,560
entonces, ¿por qué se hace eso así?

102
00:05:09,699 --> 00:05:10,959
¿por qué se hace ese diseño así?

103
00:05:11,779 --> 00:05:14,019
porque nosotros queremos que cuando alguien

104
00:05:14,019 --> 00:05:15,360
cree objetos nuestros

105
00:05:15,360 --> 00:05:18,240
además, pues verificar ciertas cosas

106
00:05:18,240 --> 00:05:19,459
y hacer cosas más complicadas

107
00:05:19,459 --> 00:05:21,079
entonces hacemos un método aparte

108
00:05:21,079 --> 00:05:23,319
un método, que sí ya sí que es público

109
00:05:23,319 --> 00:05:26,240
que sirva para crear el objeto

110
00:05:26,240 --> 00:05:27,319
un método aparte

111
00:05:27,319 --> 00:05:30,180
y ese método ya sí que por dentro llamará al constructor

112
00:05:30,180 --> 00:05:32,120
es un diseño

113
00:05:32,120 --> 00:05:33,000
pues habitual

114
00:05:33,000 --> 00:05:47,560
Que nosotros, cuando usamos clases de otros, nos hayan prohibido instanciar con el constructor y tengamos que instanciar con métodos que llaman internamente al constructor, pero además hacen otras cosas.

115
00:05:48,139 --> 00:05:51,920
Es un patrón de diseño que existe, es un patrón de diseño que existe.

116
00:05:52,500 --> 00:06:01,319
Entonces, en nuestro caso, esto no podríamos hacerlo por el constructor privado, porque para ello nos han dado el método crear alumno.

117
00:06:01,319 --> 00:06:03,819
nos ha dicho, si quieres crear un alumno

118
00:06:03,819 --> 00:06:05,839
hazlo con el método crear alumno

119
00:06:05,839 --> 00:06:06,360
que es este

120
00:06:06,360 --> 00:06:09,720
pero claro, el método crear alumno

121
00:06:09,720 --> 00:06:11,019
es un método de esta clase

122
00:06:11,019 --> 00:06:13,560
entonces los métodos

123
00:06:13,560 --> 00:06:15,720
por lo general

124
00:06:15,720 --> 00:06:17,259
los usamos siempre

125
00:06:17,259 --> 00:06:19,439
los llama siempre

126
00:06:19,439 --> 00:06:20,699
un objeto de esa clase

127
00:06:20,699 --> 00:06:23,019
pero claro, aquí, ¿pero qué objeto?

128
00:06:23,120 --> 00:06:24,860
si no tengo ningún objeto creado, alumno

129
00:06:24,860 --> 00:06:26,540
¿qué objeto va a llamar a crear alumno?

130
00:06:26,879 --> 00:06:28,660
claro, es que aquí es cuando uno se da cuenta y dice

131
00:06:28,660 --> 00:06:30,819
oye, es que este método es estático

132
00:06:30,819 --> 00:06:33,519
este es un método estático

133
00:06:33,519 --> 00:06:35,540
este método no usa

134
00:06:35,540 --> 00:06:37,199
ninguna propiedad de la clase

135
00:06:37,199 --> 00:06:39,720
este método recibe dos parámetros

136
00:06:39,720 --> 00:06:41,660
recibe dos parámetros

137
00:06:41,660 --> 00:06:43,660
y son los únicos que utiliza

138
00:06:43,660 --> 00:06:45,819
aquí dentro, no utiliza nada más que lo que recibe

139
00:06:45,819 --> 00:06:48,000
entonces es un método estático

140
00:06:48,000 --> 00:06:49,579
un método estático

141
00:06:49,579 --> 00:06:50,899
es un método que solo usa

142
00:06:50,899 --> 00:06:53,040
los parámetros que recibe

143
00:06:53,040 --> 00:06:55,459
y además variables locales si las hay

144
00:06:55,459 --> 00:06:57,759
o variables estáticas

145
00:06:57,759 --> 00:06:58,339
de la clase

146
00:06:58,339 --> 00:07:01,759
Pues este cumple esa condición

147
00:07:01,759 --> 00:07:03,040
Solo usa estos parámetros

148
00:07:03,040 --> 00:07:05,560
Los usa para llamar a este constructor

149
00:07:05,560 --> 00:07:06,740
Pero no usa más variables

150
00:07:06,740 --> 00:07:09,699
Con lo cual este método por definición es estático

151
00:07:09,699 --> 00:07:11,199
Entonces uno se da cuenta de eso

152
00:07:11,199 --> 00:07:13,540
Le pone el modificador static

153
00:07:13,540 --> 00:07:16,759
Vamos a ponerle el public también

154
00:07:16,759 --> 00:07:18,480
Si queremos que sea usado desde fuera

155
00:07:18,480 --> 00:07:19,620
Vamos a ponerle el public

156
00:07:19,620 --> 00:07:22,920
Y ahora ya tenemos un método estático estupendo

157
00:07:22,920 --> 00:07:25,639
Para usar cuando queremos crear alumnos

158
00:07:25,639 --> 00:07:27,319
Y ahora ya hacemos esto

159
00:07:27,319 --> 00:07:31,699
alumno.crearAlumno

160
00:07:31,699 --> 00:07:33,699
pasándole pues los datos

161
00:07:33,699 --> 00:07:45,029
que sean, vale

162
00:07:45,029 --> 00:07:46,610
y me faltará

163
00:07:46,610 --> 00:07:48,449
el punto y coma

164
00:07:48,449 --> 00:07:51,350
vale, pues es otro

165
00:07:51,350 --> 00:07:52,709
patrón de diseño en realidad

166
00:07:52,709 --> 00:07:55,370
que cuando yo quiero crear

167
00:07:55,370 --> 00:07:57,230
instancias de una entidad

168
00:07:57,230 --> 00:07:59,569
no puedo hacerlo con el constructor

169
00:07:59,569 --> 00:08:01,490
sino lo tengo que hacer con métodos

170
00:08:01,490 --> 00:08:03,490
de los que me han provisto para ello

171
00:08:03,490 --> 00:08:05,550
y este método pues meterá

172
00:08:05,550 --> 00:08:07,329
dentro las verificaciones, todo lo que quiera

173
00:08:07,329 --> 00:08:09,069
cosas, vale

174
00:08:09,069 --> 00:08:11,610
bueno, pues a ver, seguimos

175
00:08:11,610 --> 00:08:13,490
con el enunciado

176
00:08:13,490 --> 00:08:15,329
este, vale

177
00:08:15,329 --> 00:08:17,610
este enunciado nos dice, nuestra clase

178
00:08:17,610 --> 00:08:19,449
alumno, famosa

179
00:08:19,449 --> 00:08:21,050
tiene el método recrear alumno

180
00:08:21,050 --> 00:08:23,110
y ya nos dice, vale, este método

181
00:08:23,110 --> 00:08:25,310
precisamente, que es el que tiene que incluir

182
00:08:25,310 --> 00:08:27,269
verificaciones, todo lo que tú quieras

183
00:08:27,269 --> 00:08:28,269
verificar

184
00:08:28,269 --> 00:08:31,170
para poder crear un alumno correctamente

185
00:08:31,170 --> 00:08:32,889
pues

186
00:08:32,889 --> 00:08:35,269
dice, oye, cuidado, si el año

187
00:08:35,269 --> 00:08:37,169
pasado, el año que le has dado como

188
00:08:37,169 --> 00:08:38,529
parámetro es negativo

189
00:08:38,529 --> 00:08:41,269
devuelve un null, vale, pues venga

190
00:08:41,269 --> 00:08:43,070
entonces

191
00:08:43,070 --> 00:08:45,169
esto será

192
00:08:45,169 --> 00:08:46,610
si

193
00:08:46,610 --> 00:08:49,190
el año que me han pasado como

194
00:08:49,190 --> 00:08:50,629
parámetro es menor que cero

195
00:08:50,629 --> 00:08:53,230
entonces el objeto

196
00:08:53,230 --> 00:08:55,350
alumno devuelto es este

197
00:08:55,350 --> 00:08:57,169
vale

198
00:08:57,169 --> 00:08:59,470
y si no, podría poner ahí un else

199
00:08:59,470 --> 00:09:00,970
y si no, return lo otro

200
00:09:00,970 --> 00:09:02,950
pero es que no me hace falta ni el else, obviamente

201
00:09:02,950 --> 00:09:05,169
el else no me hace falta, porque

202
00:09:05,169 --> 00:09:07,169
si yo he hecho el return null

203
00:09:07,169 --> 00:09:08,009
ya ha salido el método

204
00:09:08,009 --> 00:09:11,370
y si no he salido del método es porque he seguido

205
00:09:11,370 --> 00:09:13,129
por aquí y entonces ya devuelvo esto

206
00:09:13,129 --> 00:09:14,350
no me hace falta ni un else

207
00:09:14,350 --> 00:09:17,070
pero vamos, puede poner uno

208
00:09:17,070 --> 00:09:19,190
hace un else y ya está, el efecto es el mismo

209
00:09:19,190 --> 00:09:20,370
el efecto es el mismo

210
00:09:20,370 --> 00:09:22,889
vale, pues entonces

211
00:09:22,889 --> 00:09:24,629
este método, crear alumno

212
00:09:24,629 --> 00:09:26,590
está avisando

213
00:09:26,590 --> 00:09:29,309
de que el alumno no se ha podido

214
00:09:29,309 --> 00:09:31,090
crear porque hay un dato incoherente

215
00:09:31,090 --> 00:09:33,409
que es un año negativo que no existe

216
00:09:33,409 --> 00:09:39,090
está avisando de que hay una información incoherente

217
00:09:39,090 --> 00:09:40,950
y no la ha podido crear mediante el valor de retorno

218
00:09:40,950 --> 00:09:43,049
devolviendo null, está avisando de eso

219
00:09:43,049 --> 00:09:44,909
entonces bueno, habría que documentarlo

220
00:09:44,909 --> 00:09:46,509
con javadoc y todo eso, pero bueno

221
00:09:46,509 --> 00:09:48,929
si devuelve null, es que el alumno

222
00:09:48,929 --> 00:09:50,629
no se ha podido crear por el año negativo

223
00:09:50,629 --> 00:09:53,210
vale, bueno pues entonces

224
00:09:53,210 --> 00:09:55,169
seguimos

225
00:09:55,169 --> 00:09:56,570
ya está

226
00:09:56,570 --> 00:09:58,629
ahora un main que rellena una raíz de objetos

227
00:09:58,629 --> 00:10:00,629
y

228
00:10:00,629 --> 00:10:02,370
contará

229
00:10:02,370 --> 00:10:03,909
cuantos han nacido en

230
00:10:03,909 --> 00:10:05,289
bueno pues esto

231
00:10:05,289 --> 00:10:08,230
lo sabéis hacer

232
00:10:08,230 --> 00:10:10,309
perfectamente y esto pues si que sería

233
00:10:10,309 --> 00:10:12,529
parte obviamente de la recuperación de

234
00:10:12,529 --> 00:10:14,149
de reas anteriores

235
00:10:14,149 --> 00:10:16,009
pues

236
00:10:16,009 --> 00:10:18,169
hacer aquí un array de objetos

237
00:10:18,169 --> 00:10:18,750
alumno

238
00:10:18,750 --> 00:10:26,070
vamos a hacer un array para que no se nos olviden

239
00:10:26,070 --> 00:10:27,889
los arrays, sería más cómodo hacer

240
00:10:27,889 --> 00:10:29,909
una lista de alumnos pero bueno para que no se nos

241
00:10:29,909 --> 00:10:31,149
olviden los arrays vamos a hacer

242
00:10:31,149 --> 00:10:33,149
un array de alumnos

243
00:10:33,149 --> 00:10:40,950
venga pues

244
00:10:40,950 --> 00:10:45,190
hala, cuatro alumnos

245
00:10:45,190 --> 00:10:46,370
entonces

246
00:10:46,370 --> 00:10:49,909
y ahora recorremos el array

247
00:10:49,909 --> 00:11:01,580
bueno, tú pondrías aquí un escáner

248
00:11:01,580 --> 00:11:04,840
y ya está, leerías la variable y pondrías aquí la variable

249
00:11:04,840 --> 00:11:08,399
vale, vamos de eso nadie tiene duda

250
00:11:08,399 --> 00:11:12,039
le diríamos un numerito, introduzca la cantidad

251
00:11:12,039 --> 00:11:14,460
Leeríamos ese numerito n

252
00:11:14,460 --> 00:11:16,299
Y aquí pondríamos esa variable leída

253
00:11:16,299 --> 00:11:16,639
N

254
00:11:16,639 --> 00:11:20,490
Alumnos.le

255
00:11:20,490 --> 00:11:25,799
Vale, voy acortando un poco las cosas

256
00:11:25,799 --> 00:11:27,860
Para que nos dé tiempo a hacer más cosillas

257
00:11:27,860 --> 00:11:28,899
Y repasar más cosas

258
00:11:28,899 --> 00:11:30,740
Venga, vamos a crear

259
00:11:30,740 --> 00:11:33,720
En lugar de la cantidad n que hemos leído por teclado

260
00:11:33,720 --> 00:11:34,779
4 y ya está

261
00:11:34,779 --> 00:11:37,320
Vamos a crear 4 alumnos

262
00:11:37,320 --> 00:11:38,340
Que van a ir a ese array

263
00:11:38,340 --> 00:11:41,200
Pues alumnos de i

264
00:11:41,200 --> 00:11:44,120
Va a ser igual a qué?

265
00:11:44,120 --> 00:11:47,700
a alumno.crearalumno

266
00:11:47,700 --> 00:11:49,340
de datos

267
00:11:49,340 --> 00:11:52,039
oficialmente los debería leer por teclado

268
00:11:52,039 --> 00:11:55,679
pero para que no se haga un rollo

269
00:11:55,679 --> 00:11:58,299
luego probar el mail y tener que meter, meter, meter todo el rato

270
00:11:58,299 --> 00:12:02,039
vamos a poner directamente que el nombre de los alumnos

271
00:12:02,039 --> 00:12:02,799
sea nombre

272
00:12:02,799 --> 00:12:06,899
concatenado con la posición que sea

273
00:12:06,899 --> 00:12:09,860
nombre 0, nombre 1, nombre 2

274
00:12:09,860 --> 00:12:12,039
y año vamos a generar un aleatorio

275
00:12:12,039 --> 00:12:14,879
Vamos a generar un aleatorio

276
00:12:14,879 --> 00:12:24,580
Entre el 2000

277
00:12:24,580 --> 00:12:26,100
¿Vale?

278
00:12:27,720 --> 00:12:29,080
Por 2000

279
00:12:29,080 --> 00:12:32,259
Y esto así

280
00:12:32,259 --> 00:12:36,019
Venga, pues años aleatorios entre 0 y 2000 aproximadamente

281
00:12:36,019 --> 00:12:44,429
Y me falta un paréntesis

282
00:12:44,429 --> 00:12:46,830
¿Vale?

283
00:12:47,330 --> 00:12:50,149
Bueno, pues ya tenemos el array de 4 alumnos

284
00:12:50,149 --> 00:12:51,590
Podrían ser n, pues son 4

285
00:12:51,590 --> 00:12:52,210
Ya está

286
00:12:52,210 --> 00:13:01,740
Aquí nos dice

287
00:13:01,740 --> 00:13:07,460
Contar cuántos han nacido

288
00:13:07,460 --> 00:13:11,299
En año bisiesto

289
00:13:11,299 --> 00:13:12,039
Vale

290
00:13:12,039 --> 00:13:17,240
Dice hacerlo creando en la propia clase principal

291
00:13:17,240 --> 00:13:18,940
Un método que te lo haga

292
00:13:18,940 --> 00:13:20,419
Entonces aquí

293
00:13:20,419 --> 00:13:22,960
Contar cuántos han nacido en año bisiesto

294
00:13:22,960 --> 00:13:24,580
Pues bueno, tendríamos que hacer un contador

295
00:13:24,580 --> 00:13:25,419
Como siempre

296
00:13:25,419 --> 00:13:29,480
y ahora ya recorremos otra vez el array

297
00:13:29,480 --> 00:13:35,080
vamos a cambiar, lo vamos a recorrer con un forEach

298
00:13:35,080 --> 00:13:36,759
como se lo vamos a consultar

299
00:13:36,759 --> 00:13:42,039
pues venga, para cada alumno A de ese array

300
00:13:42,039 --> 00:13:43,080
para cada alumno A

301
00:13:43,080 --> 00:13:48,039
aquí habría que ver, si el alumno A ha nacido

302
00:13:48,039 --> 00:13:49,519
en año bisiesto, le contamos

303
00:13:49,519 --> 00:13:52,779
y nos dicen, hazlo con un método adicional

304
00:13:52,779 --> 00:13:56,179
entonces ese método

305
00:13:56,179 --> 00:13:58,580
podríamos llamar nacido bisiesto

306
00:13:58,580 --> 00:13:59,659
¿Vale?

307
00:14:00,919 --> 00:14:02,360
Si ha nacido este alumno

308
00:14:02,360 --> 00:14:03,879
en año bisiesto, entonces

309
00:14:03,879 --> 00:14:05,779
le contamos

310
00:14:05,779 --> 00:14:06,940
¿Vale?

311
00:14:07,860 --> 00:14:09,960
Ahí se queda contado y ya está

312
00:14:09,960 --> 00:14:11,320
y luego se mostraría la cuenta

313
00:14:11,320 --> 00:14:21,779
¿Vale?

314
00:14:23,679 --> 00:14:25,259
Entonces este método es un método

315
00:14:25,259 --> 00:14:27,360
que tiene que devolver un boolean y trabajar

316
00:14:27,360 --> 00:14:28,840
con la propiedad año de este

317
00:14:28,840 --> 00:14:31,279
Bueno, pues vamos a hacer ese método

318
00:14:31,279 --> 00:14:33,139
dentro de la propia clase main

319
00:14:33,139 --> 00:14:35,960
Será este método de aquí

320
00:14:35,960 --> 00:14:37,980
Este método de aquí

321
00:14:37,980 --> 00:14:39,080
Me devuelve un boolean

322
00:14:39,080 --> 00:14:41,820
Recibe un objeto alumno

323
00:14:41,820 --> 00:14:43,940
Y mira a ver si es bisiesto

324
00:14:43,940 --> 00:14:45,080
No es bisiesto

325
00:14:45,080 --> 00:14:46,179
¿Vale?

326
00:14:46,879 --> 00:14:49,519
Entonces, la condición de ser bisiesto no

327
00:14:49,519 --> 00:14:52,259
La teníamos por ahí ya hecha en algún sitio

328
00:14:52,259 --> 00:14:54,320
Entonces, por pura vaguería

329
00:14:54,320 --> 00:14:56,039
Voy a copiarla

330
00:14:56,039 --> 00:14:56,940
Directamente de aquí

331
00:14:56,940 --> 00:15:01,659
Porque

332
00:15:01,659 --> 00:15:03,519
Bisiesto

333
00:15:03,519 --> 00:15:06,279
Era que no fuera múltiplo de 4

334
00:15:06,279 --> 00:15:08,419
Múltiplo de 4 sin serlo de 100

335
00:15:08,419 --> 00:15:09,440
Simultáneamente

336
00:15:09,440 --> 00:15:12,120
Entonces eso ya lo hicimos en

337
00:15:12,120 --> 00:15:15,340
¿En qué clase?

338
00:15:17,100 --> 00:15:18,700
Ah, pero ese no es un paquete

339
00:15:18,700 --> 00:15:19,340
De la librería

340
00:15:19,340 --> 00:15:21,080
Tendríamos que importar el paquete

341
00:15:21,080 --> 00:15:23,799
¿En qué libre?

342
00:15:25,220 --> 00:15:26,179
¿Está en la JRE?

343
00:15:26,600 --> 00:15:27,179
Ah, ¿dónde está?

344
00:15:29,269 --> 00:15:30,330
¿En qué clase está?

345
00:15:34,110 --> 00:15:35,970
Ah, Javatain tiene también para ver si el primer

346
00:15:35,970 --> 00:15:36,629
Mira que ha apañado

347
00:15:36,629 --> 00:15:39,769
Pero la clase

348
00:15:39,769 --> 00:15:40,830
Java también es el paquete

349
00:15:40,830 --> 00:15:41,730
¿Y la clase cómo se llama?

350
00:15:42,710 --> 00:15:43,070
Year

351
00:15:43,070 --> 00:15:45,450
Entonces, year.

352
00:15:51,000 --> 00:15:51,519
Esto

353
00:15:51,519 --> 00:15:54,659
Y ya te devuelve el boolean

354
00:15:54,659 --> 00:15:55,519
Directamente

355
00:15:55,519 --> 00:15:57,759
Es que también dio year con G

356
00:15:57,759 --> 00:15:59,100
Entonces decía, este es que es

357
00:15:59,100 --> 00:16:02,539
Y le ponemos esto de aquí

358
00:16:02,539 --> 00:16:06,909
A.getAño

359
00:16:06,909 --> 00:16:14,299
Vale

360
00:16:14,299 --> 00:16:17,179
Si no, uno planta la condición

361
00:16:17,179 --> 00:16:17,899
que

362
00:16:17,899 --> 00:16:21,700
ya hicimos

363
00:16:21,700 --> 00:16:24,419
programamos nosotros

364
00:16:24,419 --> 00:16:25,639
al principio del curso

365
00:16:25,639 --> 00:16:26,919
que era esta de aquí

366
00:16:26,919 --> 00:16:31,000
es bisiesto, sí

367
00:16:31,000 --> 00:16:33,919
es múltiplo de 4

368
00:16:33,919 --> 00:16:36,139
pero no es simultáneamente

369
00:16:36,139 --> 00:16:38,200
múltiplo de 100 y de 400

370
00:16:38,200 --> 00:16:40,059
era esta condición que planteamos aquí

371
00:16:40,059 --> 00:16:42,700
¿vale? entonces o ponéis esta condición

372
00:16:42,700 --> 00:16:44,679
o llamáis al método

373
00:16:44,679 --> 00:16:46,100
que ya tiene la condición metida dentro

374
00:16:46,100 --> 00:16:47,600
¿vale? da igual

375
00:16:47,600 --> 00:16:50,360
vale, entonces efectivamente

376
00:16:50,360 --> 00:16:52,080
JavaTime, como vimos

377
00:16:52,080 --> 00:16:53,860
es un paquete específico

378
00:16:53,860 --> 00:16:55,399
en cosas relacionadas con fechas

379
00:16:55,399 --> 00:16:57,840
entonces pues puede tener un montón

380
00:16:57,840 --> 00:17:00,179
de utilidades y si uno mira, investiga

381
00:17:00,179 --> 00:17:01,679
pues se puede ahorrar trabajo

382
00:17:01,679 --> 00:17:04,039
JavaUtil tiene cosas relacionadas con

383
00:17:04,039 --> 00:17:05,920
fechas y con más cosas, como Scanner

384
00:17:05,920 --> 00:17:08,119
por ejemplo, pero JavaTime tiene cosas relacionadas

385
00:17:08,119 --> 00:17:09,000
exclusivamente con

386
00:17:09,000 --> 00:17:11,900
operativa de tiempos, de fechas, entonces

387
00:17:11,900 --> 00:17:13,680
pues seguramente tenga dentro cosas

388
00:17:13,680 --> 00:17:15,440
que pueden ser útiles

389
00:17:15,440 --> 00:17:17,099
vale

390
00:17:17,099 --> 00:17:43,839
Bueno, pues ya está contado. Y ahora, ahora incorporamos alguna mejora relacionada con excepciones en este ejercicio. Vale. Bueno, pues entonces, aquí el problema, el problema por lo que esta aplicación es fea es, por lo que esta aplicación es fea es que si uno se pone aquí a meter datos de alumnos y se equivoca y algún alumno lo crea en negativo, lo crea en negativo,

391
00:17:43,839 --> 00:17:46,180
la aplicación

392
00:17:46,180 --> 00:17:47,680
mete ese null

393
00:17:47,680 --> 00:17:50,059
en el array, mete ese null en el array

394
00:17:50,059 --> 00:17:51,960
¿verdad? imaginaos que aquí

395
00:17:51,960 --> 00:17:54,019
en lugar de estar, yo es que lo estoy haciendo

396
00:17:54,019 --> 00:17:55,920
aleatoriamente, entonces van a ser positivos siempre

397
00:17:55,920 --> 00:17:57,740
entonces si ejecutamos esto

398
00:17:57,740 --> 00:18:02,349
si ejecutamos esto de aquí

399
00:18:02,349 --> 00:18:07,029
¿vale? bueno

400
00:18:07,029 --> 00:18:09,029
pues ya está, han coincidido ninguno

401
00:18:09,029 --> 00:18:10,890
ninguno era ambiciesto de los cuatro

402
00:18:10,890 --> 00:18:12,170
aleatorios que ha generado

403
00:18:12,170 --> 00:18:12,849
¿vale?

404
00:18:14,490 --> 00:18:16,690
pero podríamos estar, podría haber

405
00:18:16,690 --> 00:18:18,710
un gestor metiendo datos de los alumnos

406
00:18:18,710 --> 00:18:21,009
entonces ese gestor se equivoca

407
00:18:21,009 --> 00:18:23,569
y le da el menos en algún momento

408
00:18:23,569 --> 00:18:24,849
y mete un año negativo

409
00:18:24,849 --> 00:18:27,490
entonces la aplicación tal y como está hecha

410
00:18:27,490 --> 00:18:29,670
ahora mismo, el desarrollador que está usando

411
00:18:29,670 --> 00:18:31,589
la clase alumno, no la ha hecho

412
00:18:31,589 --> 00:18:33,430
él, la está usando la clase alumno

413
00:18:33,430 --> 00:18:35,509
pues no detecta nada

414
00:18:35,509 --> 00:18:37,269
y lo que ocurre es que

415
00:18:37,269 --> 00:18:38,930
esto devolverá un null

416
00:18:38,930 --> 00:18:41,490
y no pasa nada, ese null se guarda

417
00:18:41,490 --> 00:18:43,289
en el array y ya está, con lo cual

418
00:18:43,289 --> 00:18:44,910
tendremos los alumnos en el array

419
00:18:44,910 --> 00:18:47,130
y en algunos sitios puede haber null

420
00:18:47,130 --> 00:18:49,210
aquellos en los cuales hemos intentado

421
00:18:49,210 --> 00:18:51,230
meter un alumno con edad negativa

422
00:18:51,230 --> 00:18:53,009
como el método

423
00:18:53,009 --> 00:18:55,150
al ver que era negativo

424
00:18:55,150 --> 00:18:55,990
ha devuelto un null

425
00:18:55,990 --> 00:18:59,190
pues ya está, ha devuelto un null

426
00:18:59,190 --> 00:19:01,150
no ha pasado nada y ese null se ha quedado en el array

427
00:19:01,150 --> 00:19:02,809
entonces, hombre

428
00:19:02,809 --> 00:19:05,250
si este método está bien documentado

429
00:19:05,250 --> 00:19:07,450
cuando nosotros estamos usando aquí

430
00:19:07,450 --> 00:19:09,210
el crear alumno

431
00:19:09,210 --> 00:19:11,609
estamos mirando bien la documentación

432
00:19:11,609 --> 00:19:12,829
decimos, ah, cuidado

433
00:19:12,829 --> 00:19:15,150
que aquí me dicen la documentación

434
00:19:15,150 --> 00:19:17,069
Velastegui no está

435
00:19:17,069 --> 00:19:21,230
Es que no viene

436
00:19:21,230 --> 00:19:26,769
No lo coja el teléfono

437
00:19:26,769 --> 00:19:29,369
Ya es que el email de Duca Marino lo va a leer

438
00:19:29,369 --> 00:19:31,269
A ver

439
00:19:31,269 --> 00:19:33,230
¿Velastegui viene a alguna otra clase?

440
00:19:35,369 --> 00:19:36,450
¿Paulo, viene algo?

441
00:19:38,410 --> 00:19:40,569
Pues decirle que se pase por secretaría

442
00:19:40,569 --> 00:19:43,390
Tenéis que decirle que se pase por secretaría

443
00:19:43,390 --> 00:19:44,509
Vale, pero si no lo pueden localizarle

444
00:19:44,509 --> 00:19:46,130
Vale

445
00:19:46,130 --> 00:19:48,569
¿Vale? A vosotros que os hará caso, pues lo decís.

446
00:19:50,210 --> 00:19:50,569
Vale.

447
00:19:51,190 --> 00:19:53,289
Bueno, pues entonces, si el método está bien documentado,

448
00:19:53,390 --> 00:19:55,950
el que lo usa dirá, uy, ojo, que puede haber un null.

449
00:19:56,450 --> 00:19:57,970
Voy a verificarlo con un if.

450
00:19:58,430 --> 00:20:01,990
Y si no es null, pues, y si es null, decirle,

451
00:20:02,069 --> 00:20:03,190
oye, es metiño negativo.

452
00:20:04,009 --> 00:20:05,410
Primero, se complica la aplicación.

453
00:20:05,930 --> 00:20:08,849
Segundo, tú tienes que estar bien atento a la documentación

454
00:20:08,849 --> 00:20:10,829
para ver que esto puede generar un null.

455
00:20:11,529 --> 00:20:14,430
Pero si no lo estás, tú ahora ya metes los alumnos,

456
00:20:14,509 --> 00:20:16,069
te pones a hacer esto y ¿qué te va a salir?

457
00:20:16,130 --> 00:20:18,690
un null pointer exception tremendo aquí

458
00:20:18,690 --> 00:20:19,769
¿verdad?

459
00:20:20,569 --> 00:20:22,490
llegarás ahí y te saldrá un null pointer exception

460
00:20:22,490 --> 00:20:24,869
porque llegas a un alumno

461
00:20:24,869 --> 00:20:25,369
que es null

462
00:20:25,369 --> 00:20:28,089
llegas a un alumno que es null

463
00:20:28,089 --> 00:20:30,529
null.getAño null pointer exception

464
00:20:30,529 --> 00:20:33,089
vale, luego es mucho mejor

465
00:20:33,089 --> 00:20:34,930
que crear alumno

466
00:20:34,930 --> 00:20:36,329
te avise

467
00:20:36,329 --> 00:20:38,109
de que el alumno

468
00:20:38,109 --> 00:20:40,450
de que el año es negativo mediante una excepción

469
00:20:40,450 --> 00:20:42,710
es muchísimo mejor, es una forma de comunicación

470
00:20:42,710 --> 00:20:43,490
muchísimo mejor

471
00:20:43,490 --> 00:20:45,170
y eso es lo que dice

472
00:20:45,170 --> 00:20:47,069
El siguiente apartado

473
00:20:47,069 --> 00:20:48,369
Dice

474
00:20:48,369 --> 00:20:50,369
Oye

475
00:20:50,369 --> 00:20:53,190
Crea una excepción para ese error

476
00:20:53,190 --> 00:20:54,269
Que tú quieres comunicar

477
00:20:54,269 --> 00:20:56,430
Que el año de nacimiento no es válido

478
00:20:56,430 --> 00:20:57,170
Porque es negativo

479
00:20:57,170 --> 00:20:58,069
Crea esa excepción

480
00:20:58,069 --> 00:21:01,069
Y usa esa excepción para que tu método avise

481
00:21:01,069 --> 00:21:03,430
Pues venga, vamos a crear la excepción

482
00:21:03,430 --> 00:21:05,809
Que avise de eso que queremos comunicar

483
00:21:05,809 --> 00:21:07,809
Bueno, pues nosotros aquí

484
00:21:07,809 --> 00:21:09,549
Normalmente en un paquete aparte

485
00:21:09,549 --> 00:21:18,650
Creamos la excepción

486
00:21:18,650 --> 00:21:20,349
una nueva clase

487
00:21:20,349 --> 00:21:29,609
¡ay! ¡ah! ¡qué hijo, eh!

488
00:21:29,630 --> 00:21:30,829
no vería ni el new siquiera

489
00:21:30,829 --> 00:21:33,650
vale, pues entonces, ¿qué queremos comunicar?

490
00:21:33,990 --> 00:21:36,329
año no válido, año nacimiento no válido

491
00:21:36,329 --> 00:21:41,079
si la única

492
00:21:41,079 --> 00:21:42,980
causa de invalidez del año

493
00:21:42,980 --> 00:21:45,099
es que sea negativo, podríamos ser incluso más claros

494
00:21:45,099 --> 00:21:46,980
con el nombre, año nacimiento

495
00:21:46,980 --> 00:21:48,279
negativo, exception

496
00:21:48,279 --> 00:21:51,140
vale, no es que sea

497
00:21:51,140 --> 00:21:52,779
obligatorio acabar los nombres en exception

498
00:21:52,779 --> 00:21:55,019
pero es una pauta

499
00:21:55,019 --> 00:21:56,599
de programación que facilita

500
00:21:56,599 --> 00:21:58,559
que nos entendamos todos

501
00:21:58,559 --> 00:22:02,079
entonces si esto queremos que sea una clase excepción

502
00:22:02,079 --> 00:22:03,039
tiene que heredar

503
00:22:03,039 --> 00:22:05,119
tiene que heredar

504
00:22:05,119 --> 00:22:07,799
de exception o de algo que la inserta

505
00:22:07,799 --> 00:22:08,559
en la jerarquía

506
00:22:08,559 --> 00:22:11,039
pues vamos a hacer la heredera de exception

507
00:22:11,039 --> 00:22:13,660
ahora ya está insertada

508
00:22:13,660 --> 00:22:15,099
en la jerarquía, hereda de exception

509
00:22:15,099 --> 00:22:17,440
vale, pues vamos a hacerle un constructor

510
00:22:17,440 --> 00:22:19,559
porque se hereda todo menos los constructores

511
00:22:19,559 --> 00:22:21,500
ya sabéis, pues vamos a hacerle

512
00:22:21,500 --> 00:22:22,160
un constructor

513
00:22:22,160 --> 00:22:33,690
vamos a hacerle un constructor

514
00:22:33,690 --> 00:22:36,589
y aquí recordad que el constructor

515
00:22:36,589 --> 00:22:38,730
lo hacíamos apoyándonos

516
00:22:38,730 --> 00:22:40,410
en el constructor de la superclase

517
00:22:40,410 --> 00:22:42,950
de exception y la superclase

518
00:22:42,950 --> 00:22:44,609
tiene un constructor al que

519
00:22:44,609 --> 00:22:45,869
tú le pasas un mensajito

520
00:22:45,869 --> 00:22:48,569
un string y ese

521
00:22:48,569 --> 00:22:50,809
string lo usa

522
00:22:50,809 --> 00:22:52,630
para inicializar la variable

523
00:22:52,630 --> 00:22:54,789
de la excepción que tiene la causa del error

524
00:22:54,789 --> 00:22:56,789
¿vale? porque la clase

525
00:22:56,789 --> 00:22:58,569
exception es una clase que tiene ya

526
00:22:58,569 --> 00:23:00,769
variables suyas, que las hereda esta

527
00:23:00,769 --> 00:23:02,849
y una de las que tiene es la variable

528
00:23:02,849 --> 00:23:04,349
message o como se llame

529
00:23:04,349 --> 00:23:06,569
que es la que guarda la causa del error

530
00:23:06,569 --> 00:23:09,950
pues esa variable se inicializa

531
00:23:09,950 --> 00:23:11,769
a través del constructor este de exception

532
00:23:11,769 --> 00:23:14,009
entonces aquí ponemos

533
00:23:14,009 --> 00:23:14,970
la causa que queremos

534
00:23:14,970 --> 00:23:17,690
el año

535
00:23:17,690 --> 00:23:20,190
introducido es

536
00:23:20,190 --> 00:23:21,089
negativo

537
00:23:21,089 --> 00:23:23,329
esta es la causa de error

538
00:23:23,329 --> 00:23:26,250
que queremos que refleje esta excepción

539
00:23:26,250 --> 00:23:27,950
esta es la causa de error

540
00:23:27,950 --> 00:23:28,970
que queremos que refleje

541
00:23:28,970 --> 00:23:31,789
pues nada, ya cuando la instanciemos

542
00:23:31,789 --> 00:23:32,890
esa causa de error

543
00:23:32,890 --> 00:23:35,009
va a ir a la variable

544
00:23:35,009 --> 00:23:39,309
mensaje que guarda el mensaje, la excepción ya está

545
00:23:39,309 --> 00:23:44,230
y ahora ya hay que decidir en qué momento queremos avisar de que eso ha ocurrido

546
00:23:44,230 --> 00:23:48,089
¿en qué momento queremos avisar de que eso ha ocurrido? pues en el método crear alumno

547
00:23:48,089 --> 00:23:52,230
ahí queremos avisar de que eso ha ocurrido, si el año es negativo

548
00:23:52,230 --> 00:23:55,509
entonces nada de devolver null, de devolver null nada

549
00:23:55,509 --> 00:24:00,150
si el año es negativo, lo que hacemos en lugar de devolver un null

550
00:24:00,150 --> 00:24:04,210
como si todo fuera perfecto, nada hubiera pasado, pero simplemente el objeto alumno es null

551
00:24:04,210 --> 00:24:06,369
en lugar de hacer eso, como si no hubiera pasado

552
00:24:06,369 --> 00:24:07,930
decimos, eh, claro que ha pasado algo

553
00:24:07,930 --> 00:24:10,150
ha pasado algo muy grave, que es

554
00:24:10,150 --> 00:24:12,430
que el año es negativo y yo te aviso

555
00:24:12,430 --> 00:24:14,390
lanzando una excepción, que una excepción

556
00:24:14,390 --> 00:24:16,190
es la forma en la que te digo, esto

557
00:24:16,190 --> 00:24:18,289
hay que hacer algo con ello, la aplicación

558
00:24:18,289 --> 00:24:20,450
no debería seguir por este camino

559
00:24:20,450 --> 00:24:22,410
¿cómo se lanza una excepción? ya sabemos

560
00:24:22,410 --> 00:24:24,609
que es throw, y ahora ya instanciamos

561
00:24:24,609 --> 00:24:25,690
el objeto excepción

562
00:24:25,690 --> 00:24:28,690
pues nada, instanciamos el objeto excepción

563
00:24:28,690 --> 00:24:41,640
ala

564
00:24:41,640 --> 00:24:43,079
instanciado

565
00:24:43,079 --> 00:24:46,059
Vamos a importarlo

566
00:24:46,059 --> 00:24:51,559
Vale, pues este método

567
00:24:51,559 --> 00:24:52,720
Ahora ya tiene dos opciones

568
00:24:52,720 --> 00:24:53,799
Que el año sea negativo

569
00:24:53,799 --> 00:24:55,980
Entonces avisa, ha habido una excepción

570
00:24:55,980 --> 00:24:57,859
Y ya para el método

571
00:24:57,859 --> 00:24:59,180
Completamente para

572
00:24:59,180 --> 00:25:01,240
Y el control vuelve al que lo llamó

573
00:25:01,240 --> 00:25:02,059
En este caso el main

574
00:25:02,059 --> 00:25:05,240
Que el año no ha sido negativo

575
00:25:05,240 --> 00:25:06,619
No ha habido un throw

576
00:25:06,619 --> 00:25:08,319
Con lo cual ni se ha lanzado excepción

577
00:25:08,319 --> 00:25:09,500
Ni se ha parado el método

578
00:25:09,500 --> 00:25:11,259
Seguimos por aquí y devolvemos el objeto

579
00:25:11,259 --> 00:25:15,079
Vale, pues entonces ahora

580
00:25:15,079 --> 00:25:16,720
pregunta

581
00:25:16,720 --> 00:25:19,299
¿por qué me sobrescribe

582
00:25:19,299 --> 00:25:21,440
el rojo

583
00:25:21,440 --> 00:25:22,220
el compilador?

584
00:25:23,279 --> 00:25:25,539
no me leáis lo que te avisa el Eclipse

585
00:25:25,539 --> 00:25:29,900
sí, pero está ya importado

586
00:25:29,900 --> 00:25:31,180
está ya

587
00:25:31,180 --> 00:25:33,500
o sea, eso ya me ha dado

588
00:25:33,500 --> 00:25:35,299
un error antes y ese ya lo ha arreglado

589
00:25:35,299 --> 00:25:36,339
este es otro

590
00:25:36,339 --> 00:25:44,170
ya, pero es otra cosa

591
00:25:44,170 --> 00:25:47,470
eso sí, a ver, me dice, oye, vamos a ver

592
00:25:47,470 --> 00:25:49,890
si este método lanza una excepción

593
00:25:49,890 --> 00:25:52,170
si este método lanza una excepción

594
00:25:52,170 --> 00:25:53,809
la cabecera del método

595
00:25:53,809 --> 00:25:55,430
o sea, lanza, es posible

596
00:25:55,430 --> 00:25:56,710
que la lance, es posible

597
00:25:56,710 --> 00:25:59,630
la cabecera del método tiene que avisar

598
00:25:59,630 --> 00:26:01,309
para que el que lo llame

599
00:26:01,309 --> 00:26:03,569
sepa que puede ser lanzada la excepción

600
00:26:03,569 --> 00:26:04,410
sepa que puede

601
00:26:04,410 --> 00:26:06,990
no es que haya que pasársela por parámetro

602
00:26:06,990 --> 00:26:07,930
porque la crea él

603
00:26:07,930 --> 00:26:12,069
pero tiene que avisar la propia cabecera

604
00:26:12,069 --> 00:26:13,809
que puede que la lance

605
00:26:13,809 --> 00:26:15,710
porque el que llama el método

606
00:26:15,710 --> 00:26:17,769
el que llama el método de lo que hay dentro

607
00:26:17,769 --> 00:26:19,769
no tiene ni idea ni tiene por qué saberla

608
00:26:19,769 --> 00:26:22,109
Esa es la encapsulación de la relación entre dos objetos.

609
00:26:22,970 --> 00:26:28,789
El que llama al método de otro, lo único de lo que dispone es de la cabecera.

610
00:26:29,990 --> 00:26:37,849
De lo que devuelve, del nombre, de lo que recibe, de si es estático o no, para saber si lo puede llamar con el nombre de la clase o no.

611
00:26:38,369 --> 00:26:40,549
Y de si puede que lance excepción o no.

612
00:26:41,089 --> 00:26:44,630
Esa es la única información que tiene que tener el que llama al método.

613
00:26:44,630 --> 00:26:46,450
nombre para poder llamarlo

614
00:26:46,450 --> 00:26:49,190
lo que devuelve para recoger

615
00:26:49,190 --> 00:26:50,490
la variable correspondiente

616
00:26:50,490 --> 00:26:53,710
los parámetros que necesita para pasárselos

617
00:26:53,710 --> 00:26:55,069
static

618
00:26:55,069 --> 00:26:57,269
para ver como lo puede llamar

619
00:26:57,269 --> 00:26:58,990
con objeto o con nombre de clase

620
00:26:58,990 --> 00:27:01,309
y throws para saber

621
00:27:01,309 --> 00:27:03,650
si puede que lance excepción o puede que no

622
00:27:03,650 --> 00:27:07,289
eso es lo que el que llama el método tiene que conocer

623
00:27:07,289 --> 00:27:07,829
lo único

624
00:27:07,829 --> 00:27:11,309
eso es lo que se llama una API en general

625
00:27:11,309 --> 00:27:13,990
las siglas API de Application Program Interface

626
00:27:13,990 --> 00:27:15,490
Significan eso, es

627
00:27:15,490 --> 00:27:18,730
¿Cuál es la información que tú tienes

628
00:27:18,730 --> 00:27:20,309
Del código que estás usando?

629
00:27:20,829 --> 00:27:21,910
Eso es lo que significa API

630
00:27:21,910 --> 00:27:24,170
¿Qué es? ¿Tu interfaz de programación cuál es?

631
00:27:25,170 --> 00:27:26,210
Interfaz significa

632
00:27:26,210 --> 00:27:28,390
El punto de comunicación

633
00:27:28,390 --> 00:27:29,230
Entre dos cosas

634
00:27:29,230 --> 00:27:31,130
Eso significa interfaz en realidad

635
00:27:31,130 --> 00:27:32,849
El punto de comunicación entre dos cosas

636
00:27:32,849 --> 00:27:34,329
Entonces API es

637
00:27:34,329 --> 00:27:37,349
Ese punto de comunicación entre dos cosas

638
00:27:37,349 --> 00:27:38,829
El que llama el método y el método

639
00:27:38,829 --> 00:27:40,569
Ese punto de comunicación, ¿qué tiene?

640
00:27:41,150 --> 00:27:43,309
Pues tiene esto, esto es una API

641
00:27:43,309 --> 00:27:45,609
este es el punto de comunicación

642
00:27:45,609 --> 00:27:46,930
entre el que llama al método

643
00:27:46,930 --> 00:27:48,230
y el propio método

644
00:27:48,230 --> 00:27:50,289
bueno, pues nos está diciendo eso

645
00:27:50,289 --> 00:27:52,750
oye, te falta dar esa información

646
00:27:52,750 --> 00:27:54,730
te falta decir

647
00:27:54,730 --> 00:27:55,849
que puede

648
00:27:55,849 --> 00:27:59,049
que este método

649
00:27:59,049 --> 00:27:59,750
llame a este

650
00:27:59,750 --> 00:28:03,369
y ahora ya esta cabecera ya tiene toda la información

651
00:28:03,369 --> 00:28:05,049
que necesita

652
00:28:05,049 --> 00:28:06,309
el que lo llama para trabajar

653
00:28:06,309 --> 00:28:09,170
lo que hace dentro, le da exactamente igual

654
00:28:09,170 --> 00:28:10,809
lo que hace, de hecho es que no lo tiene

655
00:28:10,809 --> 00:28:12,930
por qué conocer, es una información oculta

656
00:28:12,930 --> 00:28:15,710
esto está encapsulado, ya lo tiene todo

657
00:28:15,710 --> 00:28:19,329
vale, pues ya está, entonces a nosotros ahora en nuestro main

658
00:28:19,329 --> 00:28:20,450
si

659
00:28:20,450 --> 00:28:24,410
una vez que ha cambiado la clase alumno

660
00:28:24,410 --> 00:28:27,849
ahora ya a este main le han cambiado las condiciones del juego

661
00:28:27,849 --> 00:28:30,470
le han cambiado las reglas del juego, se las han cambiado

662
00:28:30,470 --> 00:28:34,529
y esto, que antes ni tenía errores de compilación

663
00:28:34,529 --> 00:28:38,069
ni tenía errores de nada, pues el que está en el repositorio

664
00:28:38,069 --> 00:28:40,369
trabajando en paralelo con el otro, que están subiendo

665
00:28:40,369 --> 00:28:42,890
sincronizados con el repositorio, con github

666
00:28:42,890 --> 00:28:44,910
con el que sea, están sincronizados

667
00:28:44,910 --> 00:28:46,609
a este de repente

668
00:28:46,609 --> 00:28:49,029
cuando se ha sincronizado

669
00:28:49,029 --> 00:28:50,170
con el repositorio

670
00:28:50,170 --> 00:28:52,589
sin haber cambiado nada de su propio código

671
00:28:52,589 --> 00:28:53,650
se le pone esto en rojo

672
00:28:53,650 --> 00:28:56,690
antes lo tenía todo perfecto

673
00:28:56,690 --> 00:28:58,630
lo tenía todo perfecto pero el problema era una caca

674
00:28:58,630 --> 00:29:00,670
porque si metía un año negativo

675
00:29:00,670 --> 00:29:02,089
le iba a salir un null pointer exception

676
00:29:02,089 --> 00:29:03,970
en los de compilación ninguno

677
00:29:03,970 --> 00:29:05,730
pero a la hora de ejecutar la liaba

678
00:29:05,730 --> 00:29:07,930
como el usuario metía uno en negativo

679
00:29:07,930 --> 00:29:10,670
bueno, pues ahora se ha sincronizado con el repositorio

680
00:29:10,670 --> 00:29:12,549
porque está trabajando en equipo

681
00:29:12,549 --> 00:29:14,650
con el del proyecto y de repente

682
00:29:14,650 --> 00:29:16,690
le aparece esto. Esto ya sí

683
00:29:16,690 --> 00:29:18,109
que es una forma mejor de programar

684
00:29:18,109 --> 00:29:20,710
porque ahora ya el que está desarrollando esta parte

685
00:29:20,710 --> 00:29:22,609
del proyecto dice, uy

686
00:29:22,609 --> 00:29:23,690
¿y aquí qué pasa?

687
00:29:24,589 --> 00:29:26,309
Pues aquí pasa lo que me están diciendo.

688
00:29:26,430 --> 00:29:28,529
Te dice, cuidado cuando uses el método.

689
00:29:29,049 --> 00:29:30,470
Cuidado. Porque

690
00:29:30,470 --> 00:29:32,730
puede ser que te salga

691
00:29:32,730 --> 00:29:34,730
esta excepción. Si es

692
00:29:34,730 --> 00:29:36,609
que se ha metido un número negativo.

693
00:29:37,130 --> 00:29:37,490
Cuidado.

694
00:29:38,569 --> 00:29:40,349
Entonces, el que está

695
00:29:40,349 --> 00:29:42,250
trabajando en esta parte del proyecto

696
00:29:42,250 --> 00:29:44,750
tiene que decidir

697
00:29:44,750 --> 00:29:45,789
qué pasa en ese caso

698
00:29:45,789 --> 00:29:47,309
tiene que decidir

699
00:29:47,309 --> 00:29:49,430
¿vale?

700
00:29:49,490 --> 00:29:49,809
entonces

701
00:29:49,809 --> 00:29:51,349
recordad que hay dos opciones

702
00:29:51,349 --> 00:29:52,609
¿qué dos opciones

703
00:29:52,609 --> 00:29:53,250
tenemos aquí

704
00:29:53,250 --> 00:29:54,769
cuando hay una posible

705
00:29:54,769 --> 00:29:55,490
excepción

706
00:29:55,490 --> 00:29:56,329
que puede salir?

707
00:29:57,910 --> 00:29:59,450
¿qué dos alternativas

708
00:29:59,450 --> 00:30:00,089
puedo tomar?

709
00:30:02,589 --> 00:30:03,150
¿capturarla?

710
00:30:03,630 --> 00:30:03,789
o

711
00:30:03,789 --> 00:30:05,670
efectivamente

712
00:30:05,670 --> 00:30:06,769
puedes decir

713
00:30:06,769 --> 00:30:07,089
ah no

714
00:30:07,089 --> 00:30:08,710
voy a capturarla

715
00:30:08,710 --> 00:30:09,609
hacer un try catch

716
00:30:09,609 --> 00:30:10,009
y decir

717
00:30:10,009 --> 00:30:10,710
inténtalo

718
00:30:10,710 --> 00:30:11,890
si la

719
00:30:11,890 --> 00:30:13,349
si te sale fenomenal

720
00:30:13,349 --> 00:30:14,069
si no

721
00:30:14,069 --> 00:30:14,670
vete al catch

722
00:30:14,670 --> 00:30:15,710
y continúa el programa, va a decir

723
00:30:15,710 --> 00:30:18,470
como hayan metido un negativo

724
00:30:18,470 --> 00:30:20,009
quiero que pare el programa

725
00:30:20,009 --> 00:30:22,029
no quiero que pase nada más

726
00:30:22,029 --> 00:30:24,589
tú ahí tienes que decidir, que quieres que ocurra

727
00:30:24,589 --> 00:30:26,210
si nos vamos a la opción cómoda

728
00:30:26,210 --> 00:30:27,490
que es, uy, si metes un negativo

729
00:30:27,490 --> 00:30:30,509
programa parado, se acabó

730
00:30:30,509 --> 00:30:32,309
avisa, pues entonces haríamos el

731
00:30:32,309 --> 00:30:36,049
throws, vale, esta sería

732
00:30:36,049 --> 00:30:38,009
la opción cómoda

733
00:30:38,009 --> 00:30:39,789
se quita el error de compilación

734
00:30:39,789 --> 00:30:41,289
se quita el error de compilación

735
00:30:41,289 --> 00:30:44,069
vale, este programa

736
00:30:44,069 --> 00:30:45,990
ya estaría terminado, pero como

737
00:30:45,990 --> 00:30:47,269
alguien meta un número negativo

738
00:30:47,269 --> 00:30:49,309
salen las letras rojas

739
00:30:49,309 --> 00:30:51,789
y de hecho

740
00:30:51,789 --> 00:30:53,750
voy a cambiar esto por un scan

741
00:30:53,750 --> 00:30:55,950
para, bueno, nos alargamos mucho

742
00:30:55,950 --> 00:30:57,049
y nos pasan luego las otras

743
00:30:57,049 --> 00:30:59,890
pero vamos, yo creo que

744
00:30:59,890 --> 00:31:01,750
no hace falta para que lo sigáis

745
00:31:01,750 --> 00:31:03,049
entonces si

746
00:31:03,049 --> 00:31:05,410
alguien mete un número negativo

747
00:31:05,410 --> 00:31:07,150
al llegar aquí, ¡pam!

748
00:31:07,789 --> 00:31:09,170
aparecen las letras rojas

749
00:31:09,170 --> 00:31:12,029
y el programa se para, se acabó, no sigue

750
00:31:12,029 --> 00:31:13,509
el programa se ha parado, no sigue

751
00:31:13,509 --> 00:31:15,769
¿qué decimos?

752
00:31:15,769 --> 00:31:17,730
hombre no, tampoco seas tan radical

753
00:31:17,730 --> 00:31:19,789
que no pare el programa solo

754
00:31:19,789 --> 00:31:21,210
porque meta un negativo

755
00:31:21,210 --> 00:31:23,410
avísale, dale una oportunidad

756
00:31:23,410 --> 00:31:25,170
de mejorar, de intentarlo

757
00:31:25,170 --> 00:31:27,029
y que el programa siga

758
00:31:27,029 --> 00:31:29,150
bueno, pues entonces

759
00:31:29,150 --> 00:31:30,250
hacemos un try catch

760
00:31:30,250 --> 00:31:32,970
y ahora ya en el try catch uno hace

761
00:31:32,970 --> 00:31:35,009
el try catch que le dé la gana

762
00:31:35,009 --> 00:31:41,150
vale, yo no quiero propagar

763
00:31:41,150 --> 00:31:43,049
que eso es una caca, es de vagos

764
00:31:43,049 --> 00:31:44,849
y de gente que quiere que sus programas sean

765
00:31:44,849 --> 00:31:46,710
lo menos robustos del mundo, no quiero propagar

766
00:31:46,710 --> 00:31:48,849
quiero hacer un try catch

767
00:31:48,849 --> 00:31:54,779
vale, entonces aquí ya uno decide

768
00:31:54,779 --> 00:31:57,319
aquí ya uno decide

769
00:31:57,319 --> 00:31:58,799
intenta crear el alumno

770
00:31:58,799 --> 00:32:00,960
que lo consigues, fenomenal

771
00:32:00,960 --> 00:32:02,680
que no lo consigues, que quieres que pase

772
00:32:02,680 --> 00:32:04,740
pues aquí decidimos

773
00:32:04,740 --> 00:32:07,099
podríamos meter esto

774
00:32:07,099 --> 00:32:08,799
en un bucle, por ejemplo, de tal forma

775
00:32:08,799 --> 00:32:11,319
que estuviera todo el rato pidiendo años

776
00:32:11,319 --> 00:32:13,420
y salga del bucle

777
00:32:13,420 --> 00:32:14,819
cuando ya se ha metido un positivo

778
00:32:14,819 --> 00:32:16,519
lo que fuera, lo que queramos

779
00:32:16,519 --> 00:32:19,059
por ejemplo, vamos a suponer que lo que

780
00:32:19,059 --> 00:32:21,039
hacemos es, si has metido un negativo

781
00:32:21,039 --> 00:32:23,519
Creamos un alumno que ha nacido en el año cero

782
00:32:23,519 --> 00:32:24,579
Por ejemplo

783
00:32:24,579 --> 00:32:26,940
Entonces podríamos hacer esto, a lo mejor

784
00:32:26,940 --> 00:32:29,779
Lo que el programador

785
00:32:29,779 --> 00:32:31,619
Decida acorde con lo que

786
00:32:31,619 --> 00:32:33,200
Quiere el que va a usar la aplicación

787
00:32:33,200 --> 00:32:49,359
¿Vale?

788
00:32:51,309 --> 00:32:53,109
Nombre más y cero

789
00:32:53,109 --> 00:32:58,250
Ah, que no, es que lo que estoy haciendo con esto es crear alumno

790
00:32:58,250 --> 00:33:01,329
Alumno punto

791
00:33:01,329 --> 00:33:03,750
Crear alumno

792
00:33:03,750 --> 00:33:10,940
Vale, ay, perdón, perdón

793
00:33:10,940 --> 00:33:11,259
¿Eh?

794
00:33:12,680 --> 00:33:14,599
No, no, no, espera, espera, no, no, claro

795
00:33:14,599 --> 00:33:26,609
Claro, o sea, lo que decidas hacer

796
00:33:26,609 --> 00:33:28,950
He puesto esto por poner algo, lo que tú decidas hacer

797
00:33:28,950 --> 00:33:31,029
O crear una lopeza

798
00:33:31,029 --> 00:33:32,170
Es que a ver, lo que he puesto es una tontería

799
00:33:32,170 --> 00:33:33,150
Me estoy dando cuenta ahora

800
00:33:33,150 --> 00:33:35,829
Porque me va a volver a obligar la excepción

801
00:33:35,829 --> 00:33:38,329
O sea, que la decisión que he tomado precisamente es la más estúpida

802
00:33:38,329 --> 00:33:39,890
Que uno podría tomar aquí

803
00:33:39,890 --> 00:33:42,210
Entonces aquí lo natural sería

804
00:33:42,210 --> 00:33:43,230
Decirle

805
00:33:43,230 --> 00:33:48,089
No has podido, el alumno

806
00:33:48,089 --> 00:33:50,009
Esa laña es negativa, vuelve a intentarlo

807
00:33:50,009 --> 00:33:51,769
O sea, volverlo a crear

808
00:33:51,769 --> 00:33:53,230
porque me meto en un bucle infinito

809
00:33:53,230 --> 00:33:55,230
de capturas excepciones, es un poco tonto

810
00:33:55,230 --> 00:33:56,630
entonces

811
00:33:56,630 --> 00:34:06,839
lo que fuera, lo que uno quisiera

812
00:34:06,839 --> 00:34:08,079
¿vale? lo que uno quisiera

813
00:34:08,079 --> 00:34:10,679
entonces hombre, aquí tendría sentido

814
00:34:10,679 --> 00:34:12,800
ahora, si realmente quiero tener creados

815
00:34:12,800 --> 00:34:13,760
todos los alumnos

816
00:34:13,760 --> 00:34:17,099
hacer un do while o simplemente

817
00:34:17,099 --> 00:34:18,039
decrementarla ahí

818
00:34:18,039 --> 00:34:21,019
decrementarla para que se esté en ese alumno insistiendo

819
00:34:21,019 --> 00:34:22,719
insistiendo, insistiendo, por ejemplo

820
00:34:22,719 --> 00:34:24,320
podríamos hacer esto

821
00:34:24,320 --> 00:34:28,769
esto sí que tendría un poquito más de

822
00:34:28,769 --> 00:34:30,530
más de sentido

823
00:34:30,530 --> 00:34:33,110
y es más cómodo que meter este try-catch

824
00:34:33,110 --> 00:34:34,289
en un while, ¿verdad?

825
00:34:37,250 --> 00:34:38,429
intenta crear el alumno

826
00:34:38,429 --> 00:34:40,769
¿qué has podido? genial, se acabó

827
00:34:40,769 --> 00:34:42,050
te vas al siguiente

828
00:34:42,050 --> 00:34:43,809
¿qué no has podido? el año es negativo

829
00:34:43,809 --> 00:34:45,010
e ahí

830
00:34:45,010 --> 00:34:48,610
va uno para atrás

831
00:34:48,610 --> 00:34:50,809
para que te quedes en el mismo sitio

832
00:34:50,809 --> 00:34:54,699
no, no hace falta

833
00:34:54,699 --> 00:34:55,800
con esto ya no hace falta el do while

834
00:34:55,800 --> 00:34:57,380
claro, porque el for

835
00:34:57,380 --> 00:34:59,579
aquí tengo un for

836
00:34:59,579 --> 00:35:02,400
entonces cuando ya he terminado esto

837
00:35:02,400 --> 00:35:04,420
El for incrementa el i

838
00:35:04,420 --> 00:35:05,940
Si yo no tengo decrementado que antes

839
00:35:05,940 --> 00:35:07,039
Se queda en el mismo sitio que estaba

840
00:35:07,039 --> 00:35:10,570
Claro, pero

841
00:35:10,570 --> 00:35:13,090
Es que te lo va a pedir insistentemente

842
00:35:13,090 --> 00:35:15,150
Porque va a estar plantado en ese i todo el rato

843
00:35:15,150 --> 00:35:16,750
Es que el for no va a avanzar

844
00:35:16,750 --> 00:35:18,650
Claro, el for no va a avanzar

845
00:35:18,650 --> 00:35:19,789
Se va a quedar en ese i todo el rato

846
00:35:19,789 --> 00:35:23,389
Claro, se va a quedar atascado en ese i

847
00:35:23,389 --> 00:35:24,230
¿Vale?

848
00:35:24,590 --> 00:35:26,010
Bueno, sería una posibilidad

849
00:35:26,010 --> 00:35:28,670
¿Vale? Por ejemplo, o lo que fuera

850
00:35:28,670 --> 00:35:31,349
¿Vale? Aquí lo que nos importa es

851
00:35:31,349 --> 00:35:33,769
Que esto, el hecho de que hayamos

852
00:35:33,769 --> 00:35:35,710
puesto aquí el

853
00:35:35,710 --> 00:35:37,869
throw y el throws

854
00:35:37,869 --> 00:35:40,530
al que está usando ese software

855
00:35:40,530 --> 00:35:42,329
pues hombre, tiene esa

856
00:35:42,329 --> 00:35:44,369
información directamente y le obligamos

857
00:35:44,369 --> 00:35:46,170
a que decida, que tome una decisión

858
00:35:46,170 --> 00:35:48,269
y ya no se queda el programa a expensas

859
00:35:48,269 --> 00:35:50,489
de los null y del null pointer exception

860
00:35:50,489 --> 00:35:52,409
¿vale?

861
00:35:54,579 --> 00:35:55,559
vale, entonces

862
00:35:55,559 --> 00:35:57,440
para terminar esto

863
00:35:57,440 --> 00:36:00,079
y paramos, para terminar esto

864
00:36:00,079 --> 00:36:02,260
esta excepción

865
00:36:02,260 --> 00:36:04,179
que yo he hecho aquí, esta excepción

866
00:36:04,179 --> 00:36:06,000
hereda directamente de excepción

867
00:36:06,000 --> 00:36:08,099
recordad que eso implica

868
00:36:08,099 --> 00:36:10,039
que es una excepción de las que se llaman

869
00:36:10,039 --> 00:36:11,840
verificadas por código

870
00:36:11,840 --> 00:36:13,780
verificadas en tiempo de compilación

871
00:36:13,780 --> 00:36:16,119
es decir, este de aquí

872
00:36:16,119 --> 00:36:17,519
que ha usado este método

873
00:36:17,519 --> 00:36:20,159
ha tenido que optar

874
00:36:20,159 --> 00:36:22,019
por try, catch o por throws para seguir

875
00:36:22,019 --> 00:36:23,840
si no, no podía seguir

876
00:36:23,840 --> 00:36:25,980
porque tenía ya un error de compilación directamente

877
00:36:25,980 --> 00:36:26,719
¿vale?

878
00:36:27,699 --> 00:36:30,059
¿por qué hemos elegido que esa excepción sea así?

879
00:36:30,139 --> 00:36:31,860
porque nos ha parecido, es evidente, grave

880
00:36:31,860 --> 00:36:33,440
para nuestro programa

881
00:36:33,440 --> 00:36:35,679
nos ha parecido lo suficientemente grave

882
00:36:35,679 --> 00:36:37,780
para obligar al que use el método a decir

883
00:36:37,780 --> 00:36:38,059
oye

884
00:36:38,059 --> 00:36:41,920
eso, esa es la pregunta

885
00:36:41,920 --> 00:36:43,420
entonces si a nosotros nos parece una excepción

886
00:36:43,420 --> 00:36:45,519
que sí, que queremos que se lance si hay un problema

887
00:36:45,519 --> 00:36:47,739
pero no queremos

888
00:36:47,739 --> 00:36:49,400
verificarla en tiempo de compilación

889
00:36:49,400 --> 00:36:52,039
no queremos que en tiempo de compilación sea comprobada

890
00:36:52,039 --> 00:36:53,900
y tratada, sino simplemente

891
00:36:53,900 --> 00:36:56,000
que cuando aparezca sea lanzada y ya está

892
00:36:56,000 --> 00:36:57,480
¿qué cambio haríamos?

893
00:36:58,760 --> 00:36:59,840
pues en lugar de hacer

894
00:36:59,840 --> 00:37:02,159
la heredera de exception, la haríamos heredera

895
00:37:02,159 --> 00:37:02,800
de

896
00:37:02,800 --> 00:37:05,360
RuntimeException que era una subclase

897
00:37:05,360 --> 00:37:07,940
si la hacemos heredera de esta

898
00:37:07,940 --> 00:37:10,099
se convierte

899
00:37:10,099 --> 00:37:11,059
en una

900
00:37:11,059 --> 00:37:13,400
excepción flojita

901
00:37:13,400 --> 00:37:15,860
como más light, más flojita

902
00:37:15,860 --> 00:37:17,940
entonces el que la está

903
00:37:17,940 --> 00:37:19,980
usando, aunque no hiciéramos el try-catch

904
00:37:19,980 --> 00:37:22,219
aunque no lo hiciéramos

905
00:37:22,219 --> 00:37:31,500
el compilador

906
00:37:31,500 --> 00:37:33,219
no nos daría ningún problema

907
00:37:33,219 --> 00:37:33,920
el programa

908
00:37:33,920 --> 00:37:36,420
el programa parecería igual

909
00:37:36,420 --> 00:37:39,119
pero en tiempo de compilación

910
00:37:39,119 --> 00:37:39,860
a mí no me para

911
00:37:39,860 --> 00:37:42,500
yo puedo programar, pero claro

912
00:37:42,500 --> 00:37:44,079
en tiempo de ejecución me va a salir igual

913
00:37:44,079 --> 00:37:46,940
va a ser lanzada igual y va a funcionar igual

914
00:37:46,940 --> 00:37:48,780
va a parar el código

915
00:37:48,780 --> 00:37:49,940
y va a mostrar las letras

916
00:37:49,940 --> 00:37:52,760
pero en tiempo de compilación no me obliga a mí

917
00:37:52,760 --> 00:37:54,639
a capturarla, es como el null pointer exception

918
00:37:54,639 --> 00:37:56,420
el null pointer exception nos aparece

919
00:37:56,420 --> 00:37:58,059
cuando ha habido ese error

920
00:37:58,059 --> 00:38:00,960
y nosotros hemos podido escribir el código

921
00:38:00,960 --> 00:38:03,300
sin necesidad de hacer un try-cat de null pointer exception

922
00:38:03,300 --> 00:38:05,159
ni de hacer un throw, no lo hemos tenido que hacer

923
00:38:05,159 --> 00:38:25,019
Pero es que si hubiéramos tenido que hacer un throws o un try-catch de todos los posibles null pointer exception, el código se quedaría enorme. Entonces, nosotros podríamos elegir que esta excepción fuera de esas, de las que no está obligada a ser capturada, pero bueno, tiene esa pega que luego el programa se queda más flojo para el tiempo de ejecución.

924
00:38:25,019 --> 00:38:27,880
Porque puede salir y parar el programa

925
00:38:27,880 --> 00:38:28,659
Y ya está

926
00:38:28,659 --> 00:38:31,099
Venga, pues ahora sí que

927
00:38:31,099 --> 00:38:33,019
Sí que paramos aquí un

928
00:38:33,019 --> 00:38:35,940
Un momentito y voy a buscar otro

929
00:38:35,940 --> 00:38:37,400
Otro ejercicio