1
00:00:00,690 --> 00:00:04,009
luego tenemos la interfaz

2
00:00:04,009 --> 00:00:05,790
rogable que es la más genérica

3
00:00:05,790 --> 00:00:08,089
y luego de aquí heredan

4
00:00:08,089 --> 00:00:09,769
la superclase

5
00:00:09,769 --> 00:00:11,630
exceptio y la superclase error

6
00:00:11,630 --> 00:00:13,009
ahora mencionamos esta

7
00:00:13,009 --> 00:00:16,070
¿vale? y luego ya de esta

8
00:00:16,070 --> 00:00:17,410
pues heredan

9
00:00:17,410 --> 00:00:19,750
empiezan a heredar otras, hereda esta

10
00:00:19,750 --> 00:00:20,289
de aquí

11
00:00:20,289 --> 00:00:23,570
que esta, ahora cuando

12
00:00:23,570 --> 00:00:24,969
hagamos nuestras proyecciones

13
00:00:24,969 --> 00:00:27,550
lo veremos, es otra

14
00:00:27,550 --> 00:00:29,230
superclase en realidad

15
00:00:29,230 --> 00:00:31,250
para la mayoría de las excepciones.

16
00:00:32,729 --> 00:00:34,250
Esta sigue siendo súper clasa.

17
00:00:34,990 --> 00:00:37,929
Y luego ya a partir de aquí ya hay excepciones concretas.

18
00:00:38,530 --> 00:00:40,090
Pues esta, por ejemplo, que la conocemos,

19
00:00:40,469 --> 00:00:42,750
esta que a su vez está construida heredando de esta.

20
00:00:43,590 --> 00:00:45,890
A ver, lo único que nos importa es que las excepciones

21
00:00:45,890 --> 00:00:48,350
forman parte de una jerarquía, ¿vale?

22
00:00:48,390 --> 00:00:51,250
Que en última instancia todas se heredan de excepción,

23
00:00:51,390 --> 00:00:52,109
como vemos aquí,

24
00:00:52,109 --> 00:00:56,149
y por tanto, si uno hacía el catch este,

25
00:00:57,009 --> 00:00:58,710
que hemos puesto antes,

26
00:00:58,710 --> 00:01:00,929
pues cualquier excepción que se genere

27
00:01:00,929 --> 00:01:02,429
caería dentro de ese catch

28
00:01:02,429 --> 00:01:04,569
porque cualquier excepción que se genere

29
00:01:04,569 --> 00:01:05,670
hereda de esta

30
00:01:05,670 --> 00:01:08,870
entonces si se trae catch con excepción

31
00:01:08,870 --> 00:01:09,909
capturaría a todas

32
00:01:09,909 --> 00:01:12,549
pues captura a todas pero a cambio no podemos

33
00:01:12,549 --> 00:01:14,829
saber cuál es la que se ha generado

34
00:01:14,829 --> 00:01:15,670
bueno

35
00:01:15,670 --> 00:01:17,409
esta es la jerarquía

36
00:01:17,409 --> 00:01:20,290
¿qué es esto de error?

37
00:01:21,790 --> 00:01:22,769
a ver, lo de error

38
00:01:22,769 --> 00:01:24,750
es, hay otras cosas

39
00:01:24,750 --> 00:01:25,810
que pueden ocurrir

40
00:01:25,810 --> 00:01:28,269
que no están relacionadas

41
00:01:28,269 --> 00:01:30,370
con el programa

42
00:01:30,370 --> 00:01:32,430
en general. Estas, las que

43
00:01:32,430 --> 00:01:34,629
están aquí, que eran de exceptions, silencio,

44
00:01:35,069 --> 00:01:36,409
son cosas que están

45
00:01:36,409 --> 00:01:38,310
relacionadas con nuestro

46
00:01:38,310 --> 00:01:40,349
código. Pues

47
00:01:40,349 --> 00:01:41,909
que nos hemos salido

48
00:01:41,909 --> 00:01:44,349
de la RAI,

49
00:01:44,769 --> 00:01:46,530
que nos hemos salido

50
00:01:46,530 --> 00:01:48,549
aquí de la RAI a la hora de recorrerlo.

51
00:01:49,670 --> 00:01:50,230
Pues

52
00:01:50,230 --> 00:01:52,349
que hemos accedido

53
00:01:52,349 --> 00:01:54,290
a un puntero, a un objeto, perdón,

54
00:01:54,370 --> 00:01:56,390
que hemos accedido a un objeto que era nulo.

55
00:01:56,390 --> 00:01:59,569
las excepciones en general son cosas que han ocurrido

56
00:01:59,569 --> 00:02:01,310
en nuestro código

57
00:02:01,310 --> 00:02:03,430
y que se pueden resolver

58
00:02:03,430 --> 00:02:04,590
también vía código

59
00:02:04,590 --> 00:02:07,469
han ocurrido a consecuencia

60
00:02:07,469 --> 00:02:08,849
de sentencias que hemos hecho

61
00:02:08,849 --> 00:02:11,370
y que están pensadas

62
00:02:11,370 --> 00:02:13,349
como para que se puedan resolver vía código

63
00:02:13,349 --> 00:02:15,050
pues que este objeto lo anulo

64
00:02:15,050 --> 00:02:17,289
pues hombre, pues lo cambio para que no sea nulo

65
00:02:17,289 --> 00:02:18,990
que me he salido del array

66
00:02:18,990 --> 00:02:21,590
pues lo modifico para no salirme del array

67
00:02:21,590 --> 00:02:23,849
son situaciones generadas

68
00:02:23,849 --> 00:02:25,590
por el mal funcionamiento

69
00:02:25,590 --> 00:02:27,669
de nuestro código y que podemos arreglar

70
00:02:27,669 --> 00:02:30,150
bueno, pero hay otro concepto

71
00:02:30,150 --> 00:02:31,930
que se incluye también en esta jerarquía

72
00:02:31,930 --> 00:02:32,830
que es cosas

73
00:02:32,830 --> 00:02:35,210
que están fuera de nuestro control

74
00:02:35,210 --> 00:02:37,729
que pueden haber ocurrido porque de repente

75
00:02:37,729 --> 00:02:39,490
el sistema operativo se ha quedado sin memoria

76
00:02:39,490 --> 00:02:41,330
entonces cada vez que

77
00:02:41,330 --> 00:02:42,930
va llamando a métodos, pues

78
00:02:42,930 --> 00:02:45,669
sabemos, intuimos, porque a principio del curso

79
00:02:45,669 --> 00:02:47,710
un poco lo mencionamos, pues que según

80
00:02:47,710 --> 00:02:48,870
lo va llamando a métodos

81
00:02:48,870 --> 00:02:51,710
en una pila

82
00:02:51,710 --> 00:02:53,430
de la RAM se tienen que ir guardando

83
00:02:53,430 --> 00:02:55,110
las direcciones de

84
00:02:55,110 --> 00:02:57,150
programa, los contadores de programa

85
00:02:57,150 --> 00:02:58,490
que se llaman para que luego

86
00:02:58,490 --> 00:03:00,909
el estado operativo pueda ir devolviendo a los procesos

87
00:03:00,909 --> 00:03:03,009
de arriba, bueno, no me interesa

88
00:03:03,009 --> 00:03:04,990
meterme en esto, pero lo que quiero decir

89
00:03:04,990 --> 00:03:07,110
es que pueden ocurrir cosas también

90
00:03:07,110 --> 00:03:08,750
que no sean por nuestro código

91
00:03:08,750 --> 00:03:11,289
sino porque de repente el proceso

92
00:03:11,289 --> 00:03:13,069
se ha encontrado sin memoria

93
00:03:13,069 --> 00:03:15,009
¿vale? o ha desbordado

94
00:03:15,009 --> 00:03:17,030
la pila de los contadores de programa

95
00:03:17,030 --> 00:03:19,449
cosas que no están realmente relacionadas

96
00:03:19,449 --> 00:03:21,069
con lo que nosotros estamos

97
00:03:21,069 --> 00:03:23,210
programando, sino que están

98
00:03:23,210 --> 00:03:25,629
fuera un poquito de nuestro control

99
00:03:25,629 --> 00:03:27,949
entonces, esas cosas

100
00:03:27,949 --> 00:03:29,389
se las llama errores

101
00:03:29,389 --> 00:03:30,669
se las llama errores

102
00:03:30,669 --> 00:03:33,810
y también son lanzables

103
00:03:33,810 --> 00:03:36,310
como las excepciones, también son lanzables

104
00:03:36,310 --> 00:03:38,030
y son clases como

105
00:03:38,030 --> 00:03:39,689
estas, pues por ejemplo esta

106
00:03:39,689 --> 00:03:42,370
out of memory error, esta go to flow error

107
00:03:42,370 --> 00:03:43,689
entonces en realidad

108
00:03:43,689 --> 00:03:46,169
funcionan igual que las excepciones

109
00:03:46,169 --> 00:03:48,090
se las puede lanzar

110
00:03:48,090 --> 00:03:49,409
igual que las excepciones

111
00:03:49,409 --> 00:03:50,090
con throw

112
00:03:50,090 --> 00:03:53,389
y se las puede capturar

113
00:03:53,389 --> 00:03:54,849
igual que las excepciones

114
00:03:54,849 --> 00:03:57,069
lo que pasa es que

115
00:03:57,069 --> 00:03:59,409
estas no están pensadas para capturarlas

116
00:03:59,409 --> 00:04:01,210
no están pensadas para capturarlas

117
00:04:01,210 --> 00:04:03,469
porque no son

118
00:04:03,469 --> 00:04:04,930
cosas que se pueden arreglar por código

119
00:04:04,930 --> 00:04:06,810
no las puedo arreglar yo por código

120
00:04:06,810 --> 00:04:09,229
entonces esas no se capturan

121
00:04:09,229 --> 00:04:10,669
pero se podría capturar

122
00:04:10,669 --> 00:04:12,750
entonces simplemente que sepáis

123
00:04:12,750 --> 00:04:15,550
que se pueden generar no solo excepciones

124
00:04:15,550 --> 00:04:16,569
sino también errores

125
00:04:16,569 --> 00:04:19,110
y ahora hacemos un ejemplo

126
00:04:19,110 --> 00:04:20,310
de cómo podemos crear un error.

127
00:04:21,209 --> 00:04:22,310
Podemos crear también errores.

128
00:04:23,290 --> 00:04:24,730
Entonces, que sepáis que existan,

129
00:04:24,790 --> 00:04:26,769
que existen también clases

130
00:04:26,769 --> 00:04:28,629
dentro de esta jerarquía

131
00:04:28,629 --> 00:04:31,069
que están programadas

132
00:04:31,069 --> 00:04:32,769
para representar

133
00:04:32,769 --> 00:04:35,069
cosas que

134
00:04:35,069 --> 00:04:37,069
se decide que no

135
00:04:37,069 --> 00:04:38,990
nos interesa arreglarlas por código.

136
00:04:39,350 --> 00:04:40,889
No nos interesa arreglarlas porque

137
00:04:40,889 --> 00:04:43,110
si ocurren que el programa se pare

138
00:04:43,110 --> 00:04:45,110
y ya está. Entonces, se distinguen

139
00:04:45,110 --> 00:04:46,790
conceptualmente, se distinguen

140
00:04:46,790 --> 00:04:48,910
las excepciones y los errores.

141
00:04:48,910 --> 00:04:57,910
Pero esto es una decisión anárquica, el que programa, el que ha hecho la máquina virtual, las librerías de la máquina virtual y ha hecho las clases, ha tomado decisiones suyas anárquicas.

142
00:04:59,329 --> 00:05:10,910
Se supone otra anárquica que las ha pensado, pero estas son decisiones tomadas y se ha decidido, pues venga, estas clases son excepciones, estas son errores, son decisiones, se podrían cambiar en cualquier momento, claro, rehaciendo esas librerías.

143
00:05:10,910 --> 00:05:30,129
Bueno, pues esas decisiones dicen unas cuantas clases son las que le dan deception y recogen la mayoría de las situaciones que hemos identificado que pueden ocurrir y cuando yo haga mi código, si identifico que han pasado, las lanzo a control, lo que hemos visto.

144
00:05:30,129 --> 00:05:56,350
Vale, asumo que hay otra serie de posibilidades que pueden también ocurrir, pero en ese caso yo interpreto que no me apetece que el programa continúe si han ocurrido, no me apetece, pues las programo dentro de la jerarquía como clases que heredan de estas, de ROT, y son lanzables igual que estas y capturables igual que esas, pero conceptualmente representan otra cosa.

145
00:05:56,350 --> 00:05:59,009
y cuando son lanzadas

146
00:05:59,009 --> 00:06:01,009
no se espera que se capturen

147
00:06:01,009 --> 00:06:03,110
no se espera, lo que se espera es que el programa

148
00:06:03,110 --> 00:06:05,069
se pare, porque lo que ha ocurrido pues es grave

149
00:06:05,069 --> 00:06:06,910
¿vale? lo que ha ocurrido es grave

150
00:06:06,910 --> 00:06:09,170
y no esperamos seguir si nos hemos quedado

151
00:06:09,170 --> 00:06:10,930
sin memoria o si la pila se ha desbordado

152
00:06:10,930 --> 00:06:13,110
en ese caso no esperamos que el programa

153
00:06:13,110 --> 00:06:15,170
siga, no esperamos, se para y ya está

154
00:06:15,170 --> 00:06:17,290
¿vale? bueno, pues eso

155
00:06:17,290 --> 00:06:18,889
por un lado, pero vamos, que funcionan igual

156
00:06:18,889 --> 00:06:21,209
bueno, vale

157
00:06:21,209 --> 00:06:21,930
pues entonces

158
00:06:21,930 --> 00:06:24,189
ahora ya vamos a

159
00:06:24,189 --> 00:06:27,379
ver algún ejemplo

160
00:06:27,379 --> 00:06:32,579
Bueno, pues este es el programita que vimos el otro día

161
00:06:32,579 --> 00:06:33,720
Vimos como efectivamente

162
00:06:33,720 --> 00:06:36,040
Nosotros ya podemos

163
00:06:36,040 --> 00:06:37,199
Silencio

164
00:06:37,199 --> 00:06:40,500
Cuando queramos y nos da la gana lanzar excepciones

165
00:06:40,500 --> 00:06:42,600
Porque es nuestra forma

166
00:06:42,600 --> 00:06:44,000
Silencio

167
00:06:44,000 --> 00:06:49,319
Porque es nuestra forma

168
00:06:49,319 --> 00:06:52,199
Desde los métodos de avisar que algo malo ha pasado

169
00:06:52,199 --> 00:06:53,459
¿Vale?

170
00:06:53,720 --> 00:06:55,279
Y por eso hicimos este ejemplo

171
00:06:55,279 --> 00:06:57,639
Por ejemplo, yo me hago un método

172
00:06:57,639 --> 00:07:00,100
Para hacer la raíz cuadrada de un numerito

173
00:07:00,100 --> 00:07:02,420
Vale, entonces

174
00:07:02,420 --> 00:07:05,220
este método solo me interesa

175
00:07:05,220 --> 00:07:06,980
que haga cosas, solo me interesa

176
00:07:06,980 --> 00:07:08,100
que tenga un resultado

177
00:07:08,100 --> 00:07:11,120
consentido, solo me interesa que tenga un resultado

178
00:07:11,120 --> 00:07:13,139
válido, si este número

179
00:07:13,139 --> 00:07:15,339
es mayor o igual que cero

180
00:07:15,339 --> 00:07:17,740
silencio

181
00:07:17,740 --> 00:07:20,860
si no, no me interesa

182
00:07:20,860 --> 00:07:23,100
vale, pues entonces

183
00:07:23,100 --> 00:07:24,839
una posibilidad es efectivamente

184
00:07:24,839 --> 00:07:26,759
en mi caso raro

185
00:07:26,759 --> 00:07:28,639
que es que el número sea negativo

186
00:07:28,639 --> 00:07:31,180
en mi caso raro, decido

187
00:07:31,180 --> 00:07:32,319
que lanzo una excepción

188
00:07:32,319 --> 00:07:35,600
y lanzar una excepción

189
00:07:35,600 --> 00:07:37,160
a ver, os queréis callar

190
00:07:37,160 --> 00:07:38,980
todos los que estéis hablando

191
00:07:38,980 --> 00:07:40,920
whatsappearos

192
00:07:40,920 --> 00:07:43,519
escribidos por aquí, pero no hagáis ruido

193
00:07:43,519 --> 00:07:44,860
¿vale?

194
00:07:47,439 --> 00:07:48,819
bueno, pues en este caso

195
00:07:48,819 --> 00:07:51,240
mi caso raro es que el número sea negativo

196
00:07:51,240 --> 00:07:53,160
pues lo que dijimos el otro día

197
00:07:53,160 --> 00:07:54,779
yo puedo optar por avisar

198
00:07:54,779 --> 00:07:56,019
con el valor de retorno

199
00:07:56,019 --> 00:07:58,480
pero en este caso, ¿qué hago? devuelvo un cero

200
00:07:58,480 --> 00:08:00,560
y digo, si devuelvo un cero

201
00:08:00,560 --> 00:08:01,800
es que

202
00:08:01,800 --> 00:08:04,040
y pongo aquí, es que el número

203
00:08:04,040 --> 00:08:05,139
era negativo

204
00:08:05,139 --> 00:08:08,240
pues mal, y que pasa si le doy

205
00:08:08,240 --> 00:08:10,079
un 0 aquí, en ese caso

206
00:08:10,079 --> 00:08:12,240
devolveré un 0 porque la raíz de 0 es 0

207
00:08:12,240 --> 00:08:14,060
pero no estoy diciendo que haya

208
00:08:14,060 --> 00:08:16,279
ido algo mal, no, estoy devolviendo la raíz de 0

209
00:08:16,279 --> 00:08:17,639
entonces

210
00:08:17,639 --> 00:08:19,879
usar el valor de retorno

211
00:08:19,879 --> 00:08:22,180
para indicar que ha pasado un error

212
00:08:22,180 --> 00:08:23,500
como código de control

213
00:08:23,500 --> 00:08:26,379
pues muchas veces no procede

214
00:08:26,379 --> 00:08:28,360
porque esta variable

215
00:08:28,360 --> 00:08:30,579
ya tiene un uso, que es guardar el resultado

216
00:08:30,579 --> 00:08:31,199
ya lo tiene

217
00:08:31,199 --> 00:08:33,740
vale, pues aviso de mi caso raro con esto

218
00:08:33,740 --> 00:08:35,139
y ya sabemos cómo avisar, throw

219
00:08:35,139 --> 00:08:37,840
instancio del objeto excepción

220
00:08:37,840 --> 00:08:38,399
que yo quiera

221
00:08:38,399 --> 00:08:41,960
aquí vimos como ejemplo, pues mira, lanzo este

222
00:08:41,960 --> 00:08:43,279
pero esto es una tontería

223
00:08:43,279 --> 00:08:45,539
porque entonces, aquí

224
00:08:45,539 --> 00:08:46,980
cuando yo ejecute esto

225
00:08:46,980 --> 00:08:49,159
pues lo que ocurre

226
00:08:49,159 --> 00:08:53,990
es que, ah bueno, que lo había

227
00:08:53,990 --> 00:09:04,340
capturado, cuando yo lance

228
00:09:04,340 --> 00:09:04,919
esto

229
00:09:04,919 --> 00:09:08,200
lo que ocurre es que

230
00:09:08,200 --> 00:09:10,460
me dice, ha habido excepción de null pointer exception

231
00:09:10,460 --> 00:09:12,840
pues muy mal explicado, no ha habido excepción

232
00:09:12,840 --> 00:09:14,960
de null pointer exception, ha habido excepción

233
00:09:14,960 --> 00:09:16,899
de que el número era negativo

234
00:09:16,899 --> 00:09:18,779
y no hay raíz para número negativo

235
00:09:18,779 --> 00:09:20,320
luego

236
00:09:20,320 --> 00:09:21,679
en esta situación

237
00:09:21,679 --> 00:09:25,039
no hay una excepción

238
00:09:25,039 --> 00:09:26,879
ya creada que se adapte

239
00:09:26,879 --> 00:09:28,940
a lo mío, yo querría

240
00:09:28,940 --> 00:09:30,279
que hubiera una excepción que fuera

241
00:09:30,279 --> 00:09:33,059
número negativo exception, pero esa excepción

242
00:09:33,059 --> 00:09:35,220
no existe porque un número negativo

243
00:09:35,220 --> 00:09:37,200
en sí no es un error

244
00:09:37,200 --> 00:09:38,840
un número negativo es un número negativo

245
00:09:38,840 --> 00:09:41,240
para mí lo es en este caso

246
00:09:41,240 --> 00:09:42,980
para mí lo es, pero en general no lo es

247
00:09:42,980 --> 00:09:45,159
entonces no hay una excepción ya creada que sea

248
00:09:45,159 --> 00:09:46,620
número negativo excepción

249
00:09:46,620 --> 00:09:49,120
¿por qué va a haber una excepción ya creada que sea

250
00:09:49,120 --> 00:09:51,379
número negativo excepción? si eso en sí no es un problema

251
00:09:51,379 --> 00:09:53,000
bueno, pues entonces

252
00:09:53,000 --> 00:09:54,120
¿qué hacemos aquí?

253
00:09:54,940 --> 00:09:57,259
pues nos creamos nuestras propias excepciones

254
00:09:57,259 --> 00:09:58,919
¿vale?

255
00:09:58,940 --> 00:10:01,240
que es lo habitual, uno cuando hace un desarrollo

256
00:10:01,240 --> 00:10:02,620
grande, una aplicación grande

257
00:10:02,620 --> 00:10:04,860
y la tiene ya diseñada, contemplada y dice

258
00:10:04,860 --> 00:10:06,840
vamos a ver, de mis clases

259
00:10:06,840 --> 00:10:09,259
si mis métodos, qué cosas

260
00:10:09,259 --> 00:10:10,500
pueden ocurrir

261
00:10:10,500 --> 00:10:12,940
que me induzcan

262
00:10:12,940 --> 00:10:15,120
a que mis métodos avisen de que ha ocurrido algo mal

263
00:10:15,120 --> 00:10:16,740
pues que el número sea negativo

264
00:10:16,740 --> 00:10:18,779
que la edad sea menor de 18

265
00:10:18,779 --> 00:10:21,019
que el color de pelo sea pelirrojo

266
00:10:21,019 --> 00:10:22,580
en esos casos

267
00:10:22,580 --> 00:10:24,460
yo quiero avisar de que ha ocurrido algo raro

268
00:10:24,460 --> 00:10:25,419
que se lance una excepción

269
00:10:25,419 --> 00:10:28,039
pues tendré que hacer excepciones para eso

270
00:10:28,039 --> 00:10:30,320
porque esas excepciones obviamente no están hechas

271
00:10:30,320 --> 00:10:32,379
no está hecha la excepción pelo pelirrojo

272
00:10:32,379 --> 00:10:34,460
excepción o edad menor que 18 excepción

273
00:10:34,460 --> 00:10:35,820
no existen, las tendré que hacer yo

274
00:10:35,820 --> 00:10:38,639
Y esa es la manera de hacerlo

275
00:10:38,639 --> 00:10:40,679
Bueno, pues en este caso, obviamente

276
00:10:40,679 --> 00:10:43,899
Por tanto, no optaríamos por lanzar esta excepción

277
00:10:43,899 --> 00:10:45,039
Sino por hacer una nuestra

278
00:10:45,039 --> 00:10:49,059
¿Vale? Pues ¿cómo programamos una excepción?

279
00:10:49,100 --> 00:10:51,120
Una excepción es una clase, ya lo hemos dicho

280
00:10:51,120 --> 00:10:53,519
Pues venga, vámonos a nuestro proyecto

281
00:10:53,519 --> 00:10:55,379
Que estaba por aquí, ejemplo excepciones

282
00:10:55,379 --> 00:11:00,009
Y ahora, claro, estoy haciendo todo el mismo paquete

283
00:11:00,009 --> 00:11:01,350
Lo normal es que hubiera un paquete

284
00:11:01,350 --> 00:11:03,470
Que fuera el paquete para las clases excepción

285
00:11:03,470 --> 00:11:04,590
Y habría excepción

286
00:11:04,590 --> 00:11:08,669
menor de edad

287
00:11:08,669 --> 00:11:09,190
exception

288
00:11:09,190 --> 00:11:11,389
pelo pelirrojo exception

289
00:11:11,389 --> 00:11:12,429
las que fueran

290
00:11:12,429 --> 00:11:15,389
yo lo estoy metiendo todo en el mismo paquete prueba

291
00:11:15,389 --> 00:11:17,830
pues venga, primero identificamos

292
00:11:17,830 --> 00:11:19,769
¿qué error

293
00:11:19,769 --> 00:11:21,169
es el que yo quiero identificar aquí?

294
00:11:21,769 --> 00:11:23,210
que el número sea negativo

295
00:11:23,210 --> 00:11:24,570
pues bueno, elijo un nombre

296
00:11:24,570 --> 00:11:27,470
para esa excepción, lo normal por convenio

297
00:11:27,470 --> 00:11:28,809
para que todos nos entendamos

298
00:11:28,809 --> 00:11:30,210
es que

299
00:11:30,210 --> 00:11:33,169
acabe en exception, porque así el código

300
00:11:33,169 --> 00:11:35,129
queda más claro. Y así se ve

301
00:11:35,129 --> 00:11:36,990
rápidamente que esa clase es una clase

302
00:11:36,990 --> 00:11:37,850
de tipo excepción.

303
00:11:38,870 --> 00:11:48,139
Pues venga. Y uno le pone el nombre

304
00:11:48,139 --> 00:11:49,799
que le dé la gana. Da igual que sea muy largo.

305
00:11:50,440 --> 00:11:52,080
Da lo mismo. Que fijaos qué nombres

306
00:11:52,080 --> 00:11:54,039
tienen ya. Arraindes, out of bound,

307
00:11:54,139 --> 00:11:56,360
exception. Ya son muy largos.

308
00:11:56,460 --> 00:11:58,019
¿Por qué? Cuanto más explicativo, mejor.

309
00:11:58,299 --> 00:11:59,580
¿Qué más me da que el nombre sea largo?

310
00:12:01,320 --> 00:12:02,399
Pues tú pon lo que quieras.

311
00:12:02,440 --> 00:12:04,000
Yo he puesto, cuidado, número negativo,

312
00:12:04,100 --> 00:12:04,440
exception.

313
00:12:06,159 --> 00:12:09,440
Esto. ¿Vale?

314
00:12:12,600 --> 00:12:13,740
¿Vale? Esta es mi excepción.

315
00:12:14,019 --> 00:12:27,929
Vale, entonces, para que sea una clase excepción tengo que meterla dentro de la jerarquía, tengo que meterla dentro de la jerarquía para convertirla en excepción, hacerla throwable, lanzable.

316
00:12:28,470 --> 00:12:32,990
Si no la hago heredera de throwable, el throw no la va a admitir.

317
00:12:33,509 --> 00:12:37,049
Recordar que este objeto está para luego lanzarlo con un throw.

318
00:12:37,210 --> 00:12:39,230
Throw new, cuidado patatín.

319
00:12:39,230 --> 00:12:42,590
pues para poder ser lanzada con un throw

320
00:12:42,590 --> 00:12:44,889
tiene que implementar la interfaz

321
00:12:44,889 --> 00:12:46,809
throwable, que es la que la hace lanzable

322
00:12:46,809 --> 00:12:48,850
entonces si quiero que esto sea una clase

323
00:12:48,850 --> 00:12:50,710
excepción, tiene que entrar

324
00:12:50,710 --> 00:12:53,049
en la jerarquía de excepciones para heredar

325
00:12:53,049 --> 00:12:54,990
todo lo que la convierte

326
00:12:54,990 --> 00:12:56,809
en excepción, desde el momento

327
00:12:56,809 --> 00:12:58,490
que una clase entra en una jerarquía

328
00:12:58,490 --> 00:13:00,929
hereda todo lo que haya en las superclases

329
00:13:00,929 --> 00:13:02,029
de arriba, lo hereda todo

330
00:13:02,029 --> 00:13:05,190
y ya puede empezar a comportarse

331
00:13:05,190 --> 00:13:06,309
como todo eso que hereda

332
00:13:06,309 --> 00:13:08,889
bueno pues entonces vamos a

333
00:13:08,889 --> 00:13:11,190
meterla dentro de esa jerarquía

334
00:13:11,190 --> 00:13:13,049
haciendo la heredera

335
00:13:13,049 --> 00:13:17,480
de esta

336
00:13:17,480 --> 00:13:21,620
que hemos visto en la jerarquía que existe

337
00:13:21,620 --> 00:13:23,580
¿vale?

338
00:13:23,659 --> 00:13:25,519
entonces, las vamos a hacer herederas

339
00:13:25,519 --> 00:13:27,360
normalmente, de runtime

340
00:13:27,360 --> 00:13:29,840
exception o de exception, que es más general

341
00:13:29,840 --> 00:13:31,559
luego ya vemos la diferencia

342
00:13:31,559 --> 00:13:32,200
entre las dos

343
00:13:32,200 --> 00:13:35,039
ahora mismo elijo esta porque me va a ser

344
00:13:35,039 --> 00:13:37,320
me va a facilitar una cosa, pero luego ya

345
00:13:37,320 --> 00:13:39,379
diremos que cambia si la hago

346
00:13:39,379 --> 00:13:40,580
heredera de exception, sin más

347
00:13:40,580 --> 00:13:43,820
¿Vale? O sea, en la jerarquía que he mostrado antes

348
00:13:43,820 --> 00:13:47,120
En la jerarquía que he mostrado antes

349
00:13:47,120 --> 00:13:49,200
Teníamos estas dos

350
00:13:49,200 --> 00:13:50,840
Y estas de aquí

351
00:13:50,840 --> 00:13:53,600
Que ya eran excepciones concretas asociadas a cosas concretas

352
00:13:53,600 --> 00:13:54,960
Error de entrada y salida

353
00:13:54,960 --> 00:13:57,120
Error de fichero no encontrado

354
00:13:57,120 --> 00:13:58,639
Error de socket

355
00:13:58,639 --> 00:14:00,940
Error de que me he salido de los índices

356
00:14:00,940 --> 00:14:02,740
¿Vale? Estas ya son concretas

357
00:14:02,740 --> 00:14:04,580
Estas son superclases

358
00:14:04,580 --> 00:14:06,960
Superclases de las que yo haré

359
00:14:06,960 --> 00:14:09,039
Que mis propias excepciones se hereden

360
00:14:09,039 --> 00:14:11,179
o bien de esta o bien de esta

361
00:14:11,179 --> 00:14:14,039
luego vemos la diferencia

362
00:14:14,039 --> 00:14:14,779
entre las dos

363
00:14:14,779 --> 00:14:17,860
ahora mismo voy a meter esta clase nueva

364
00:14:17,860 --> 00:14:19,740
que he hecho en mi jerarquía heredando de esta

365
00:14:19,740 --> 00:14:22,039
porque me va a facilitar

366
00:14:22,039 --> 00:14:23,580
las cosas, ahora veremos por qué

367
00:14:23,580 --> 00:14:25,440
pues con eso ya la meto en mi jerarquía

368
00:14:25,440 --> 00:14:27,419
bueno, pues la hago

369
00:14:27,419 --> 00:14:29,320
que herede

370
00:14:29,320 --> 00:14:31,559
de roomtime exception

371
00:14:31,559 --> 00:14:34,159
pues ala, ahí está

372
00:14:34,159 --> 00:14:35,039
heredando de esa

373
00:14:35,039 --> 00:14:38,490
entonces como sabéis

374
00:14:38,490 --> 00:14:40,470
cuando uno le da de otro

375
00:14:40,470 --> 00:14:42,789
se le da todo menos los constructores

376
00:14:42,789 --> 00:14:44,669
se le da todo menos los constructores

377
00:14:44,669 --> 00:14:46,730
bueno, pues entonces aquí tendría sentido

378
00:14:46,730 --> 00:14:48,129
hacer un constructor

379
00:14:48,129 --> 00:14:54,220
recordad que los constructores

380
00:14:54,220 --> 00:14:56,120
se tienen que llamar

381
00:14:56,120 --> 00:14:58,659
igual que la clase

382
00:14:58,659 --> 00:15:00,899
que instancia

383
00:15:00,899 --> 00:15:02,600
este sería

384
00:15:02,600 --> 00:15:03,320
mi constructor

385
00:15:03,320 --> 00:15:06,299
¿vale? entonces

386
00:15:06,299 --> 00:15:08,940
constructores

387
00:15:08,940 --> 00:15:10,659
uno puede hacer

388
00:15:10,659 --> 00:15:11,220
los que quiera

389
00:15:11,220 --> 00:15:15,179
vale, recordad que los constructores de las subclases

390
00:15:15,179 --> 00:15:18,139
suelen hacerse apoyándose en llamadas

391
00:15:18,139 --> 00:15:19,840
de los constructores de las superclases

392
00:15:19,840 --> 00:15:21,379
mediante el término super, ¿verdad?

393
00:15:22,399 --> 00:15:25,159
bueno, pues la superclase runtime exception

394
00:15:25,159 --> 00:15:27,340
esta clase de aquí, esta

395
00:15:27,340 --> 00:15:29,740
tiene un constructor

396
00:15:29,740 --> 00:15:36,379
tiene el constructor sin parámetros

397
00:15:36,379 --> 00:15:37,379
¿vale?

398
00:15:38,159 --> 00:15:39,879
y luego tiene un constructor

399
00:15:39,879 --> 00:15:42,179
con un parámetro

400
00:15:42,179 --> 00:15:43,720
este de aquí

401
00:15:43,720 --> 00:15:46,879
este parámetro

402
00:15:46,879 --> 00:15:49,759
a su vez runtime exception como hereda de exception

403
00:15:49,759 --> 00:15:51,679
construye el constructor

404
00:15:51,679 --> 00:15:53,220
pasando este parámetro

405
00:15:53,220 --> 00:15:55,080
al constructor de exception

406
00:15:55,080 --> 00:15:56,820
porque runtime exception hereda

407
00:15:56,820 --> 00:15:59,220
de exception que hemos visto en la jerarquía

408
00:15:59,220 --> 00:16:00,779
hereda de exception

409
00:16:00,779 --> 00:16:03,559
y esta variable mensaje de aquí

410
00:16:03,559 --> 00:16:05,779
que es heredada de exception

411
00:16:05,779 --> 00:16:06,360
también

412
00:16:06,360 --> 00:16:08,970
vale

413
00:16:08,970 --> 00:16:17,740
si entramos en exception que a su vez

414
00:16:17,740 --> 00:16:18,740
hereda de este de aquí

415
00:16:18,740 --> 00:16:22,100
bueno pues para no perdernos más

416
00:16:22,100 --> 00:16:35,070
Y esta propiedad mensaje que viene heredada desde arriba, esta propiedad mensaje, ¿qué valor tiene?

417
00:16:35,210 --> 00:16:42,289
Pues tiene casualmente el valor que se nos muestra en las letras rojas cuando se nos muestra una explicación.

418
00:16:42,850 --> 00:16:45,710
Se han salido ustedes los índices, se han salido no sé qué.

419
00:16:46,370 --> 00:16:52,909
Pues lo que muestra el print extract trace, aparte de mostrar en qué línea de código se produjo la excepción,

420
00:16:52,909 --> 00:16:54,629
muestra un mensaje que nos lo explica.

421
00:16:54,629 --> 00:16:56,210
pues ese mensaje

422
00:16:56,210 --> 00:16:59,149
lo saca de esta variable

423
00:16:59,149 --> 00:17:00,730
lo saca de esa variable

424
00:17:00,730 --> 00:17:02,190
entonces

425
00:17:02,190 --> 00:17:04,029
aquí lo natural sería

426
00:17:04,029 --> 00:17:06,210
instanciar en realidad

427
00:17:06,210 --> 00:17:08,589
o sea, sobrescribir el constructor

428
00:17:08,589 --> 00:17:10,710
que inicializa esta variable

429
00:17:10,710 --> 00:17:27,039
¿vale? y ahora yo

430
00:17:27,039 --> 00:17:29,160
cuando yo instancie esta excepción

431
00:17:29,160 --> 00:17:30,480
cuando yo instancie

432
00:17:30,480 --> 00:17:32,900
le paso al constructor

433
00:17:32,900 --> 00:17:35,099
como parámetro el mensaje explicativo

434
00:17:35,099 --> 00:17:37,059
que quiero que tenga esa excepción

435
00:17:37,059 --> 00:17:38,980
el mensaje explicativo que quiero que tenga

436
00:17:38,980 --> 00:17:41,000
y ese mensaje explicativo

437
00:17:41,000 --> 00:17:43,019
irá a través de la llamada

438
00:17:43,019 --> 00:17:44,740
del constructor de arriba a la variable

439
00:17:44,740 --> 00:17:47,019
mensaje de la que luego tira el print extract

440
00:17:47,019 --> 00:17:48,440
trace, la que luego tira

441
00:17:48,440 --> 00:17:50,279
entonces de esta manera

442
00:17:50,279 --> 00:17:53,039
inicializo con este parámetro

443
00:17:53,039 --> 00:17:54,720
con el string que yo quiera darle

444
00:17:54,720 --> 00:17:57,160
con este parámetro inicializo esa propiedad

445
00:17:57,160 --> 00:17:58,880
de ese objeto

446
00:17:58,880 --> 00:18:01,099
una propiedad que se le dada, por eso no la

447
00:18:01,099 --> 00:18:02,819
tengo aquí, que se le dada

448
00:18:02,819 --> 00:18:04,680
y esa propiedad

449
00:18:04,680 --> 00:18:06,759
explica, su uso es explicar

450
00:18:06,759 --> 00:18:08,960
qué significa esa excepción,

451
00:18:09,019 --> 00:18:09,579
qué significa.

452
00:18:10,619 --> 00:18:11,799
Y el print extra trace,

453
00:18:11,880 --> 00:18:12,759
si luego lo llamo,

454
00:18:13,680 --> 00:18:14,640
usa ese mensajito,

455
00:18:15,180 --> 00:18:15,880
usa ese mensaje.

456
00:18:16,460 --> 00:18:17,460
Bueno, pues yo para construir

457
00:18:17,460 --> 00:18:18,299
mi propia excepción,

458
00:18:18,380 --> 00:18:18,799
ya la tengo,

459
00:18:19,039 --> 00:18:19,839
yo no tengo que hacer más,

460
00:18:20,839 --> 00:18:21,599
porque lo que importa

461
00:18:21,599 --> 00:18:22,339
de esa excepción

462
00:18:22,339 --> 00:18:23,880
es esa variable,

463
00:18:24,039 --> 00:18:25,019
esa propiedad mensaje

464
00:18:25,019 --> 00:18:25,960
que tiene la explicación,

465
00:18:26,180 --> 00:18:27,380
esa propiedad es heredada,

466
00:18:27,500 --> 00:18:28,519
no tengo que volverla a escribir,

467
00:18:28,579 --> 00:18:29,099
es heredada,

468
00:18:29,799 --> 00:18:30,740
porque esto recordad

469
00:18:30,740 --> 00:18:31,799
que va heredando de runtime,

470
00:18:31,920 --> 00:18:32,720
runtime a su vez

471
00:18:32,720 --> 00:18:33,380
es heredada de exception,

472
00:18:33,519 --> 00:18:34,720
y exception de throwable,

473
00:18:35,440 --> 00:18:36,480
esa propiedad es heredada,

474
00:18:36,759 --> 00:18:38,839
y además yo la voy a inicializar

475
00:18:38,839 --> 00:18:40,299
le voy a dar un valor a través del constructor

476
00:18:40,299 --> 00:18:42,819
no tengo que hacer más con la excepción

477
00:18:42,819 --> 00:18:43,839
ya está, ya está creada

478
00:18:43,839 --> 00:18:45,440
esta es mi propia excepción

479
00:18:45,440 --> 00:18:48,299
luego aquí, lo único importante es

480
00:18:48,299 --> 00:18:50,640
que yo elija un nombre

481
00:18:50,640 --> 00:18:51,960
que explique

482
00:18:51,960 --> 00:18:53,920
bien lo que hace

483
00:18:53,920 --> 00:18:56,200
para que luego mi código sea más claro

484
00:18:56,200 --> 00:18:58,880
cuando se vea el throw, pues se vea que lo que yo estoy lanzando

485
00:18:58,880 --> 00:19:00,660
efectivamente está asociado con lo que ha ocurrido

486
00:19:00,660 --> 00:19:03,220
lo más importante para hacer uno la excepción

487
00:19:03,220 --> 00:19:04,759
es que elija bien el nombre

488
00:19:04,759 --> 00:19:06,220
nada más, que lo elija

489
00:19:06,220 --> 00:19:09,980
vale, pues mi excepción ya está

490
00:19:09,980 --> 00:19:12,200
pues entonces yo ahora en mi método

491
00:19:12,200 --> 00:19:13,240
en este método de aquí

492
00:19:13,240 --> 00:19:16,220
cuando pasa eso

493
00:19:16,220 --> 00:19:18,480
que yo he asociado al error

494
00:19:18,480 --> 00:19:19,380
de número negativo

495
00:19:19,380 --> 00:19:22,680
pues ahora lanzaré esa excepción

496
00:19:22,680 --> 00:19:38,710
y en el constructor

497
00:19:38,710 --> 00:19:39,950
de número negativo exception

498
00:19:39,950 --> 00:19:42,049
lo he hecho, ¿verdad?

499
00:19:42,130 --> 00:19:45,089
el constructor de esta excepción

500
00:19:45,089 --> 00:19:46,549
lo he hecho para pasarle aquí

501
00:19:46,549 --> 00:19:48,029
el mensajito de que quiera que se explique

502
00:19:48,029 --> 00:19:50,869
no puedo hacer la raíz

503
00:19:50,869 --> 00:19:52,990
lo voy a poner mayúscula para que se vea bien luego cuando

504
00:19:52,990 --> 00:19:53,609
aparezca

505
00:19:53,609 --> 00:19:57,369
no puedo hacer la raíz

506
00:19:57,369 --> 00:19:58,349
de un

507
00:19:58,349 --> 00:20:00,970
número

508
00:20:00,970 --> 00:20:02,170
negativo

509
00:20:02,170 --> 00:20:07,750
vale, ese es el mensajito que quiero que aparezca

510
00:20:07,750 --> 00:20:10,049
y ya está

511
00:20:10,049 --> 00:20:11,529
y ahora este método

512
00:20:11,529 --> 00:20:13,650
ya está mucho mejor hecho, ya es un código

513
00:20:13,650 --> 00:20:14,250
mucho mejor

514
00:20:14,250 --> 00:20:17,490
es un método que le paso un número

515
00:20:17,490 --> 00:20:19,569
hace la raíz

516
00:20:19,569 --> 00:20:20,109
de ese número

517
00:20:20,109 --> 00:20:22,890
pero yo como programador me he dado cuenta

518
00:20:22,890 --> 00:20:24,190
de que si le paso un negativo

519
00:20:24,190 --> 00:20:26,809
tengo una complicación

520
00:20:26,809 --> 00:20:29,210
y es que en ese caso no puedo hacer la raíz

521
00:20:29,210 --> 00:20:30,789
tendré que indicar

522
00:20:30,789 --> 00:20:32,890
de alguna manera que no he podido cumplir

523
00:20:32,890 --> 00:20:35,089
con mi cometido, tendré que indicarlo de alguna manera

524
00:20:35,089 --> 00:20:36,789
pues indico

525
00:20:36,789 --> 00:20:38,869
que no he podido cumplir con mi cometido

526
00:20:38,869 --> 00:20:40,809
lanzando la excepción

527
00:20:40,809 --> 00:20:42,470
y lanzando además

528
00:20:42,470 --> 00:20:44,890
un objeto excepción que está creado

529
00:20:44,890 --> 00:20:46,329
específicamente para esa causa

530
00:20:46,329 --> 00:20:48,289
que está creado para esa causa

531
00:20:48,289 --> 00:20:49,910
No me aprovecho de otro

532
00:20:49,910 --> 00:20:51,069
Porque entonces lo hago muy

533
00:20:51,069 --> 00:20:53,369
Confuso

534
00:20:53,369 --> 00:20:55,029
Lo hago muy confuso todo

535
00:20:55,029 --> 00:20:58,349
Vale, pues entonces

536
00:20:58,349 --> 00:21:00,049
Ahora ya tenemos nuestro método bien hecho

537
00:21:00,049 --> 00:21:02,170
Ahora, que yo lo llamo

538
00:21:02,170 --> 00:21:02,829
Con el 12

539
00:21:02,829 --> 00:21:04,789
Ningún problema

540
00:21:04,789 --> 00:21:07,369
Me muestra

541
00:21:07,369 --> 00:21:10,150
Bueno, como no le he metido

542
00:21:10,150 --> 00:21:11,630
En un sistema, pues no me muestra nada

543
00:21:11,630 --> 00:21:16,700
Vale

544
00:21:16,700 --> 00:21:23,490
Pues nada, yo llamo ahora ya

545
00:21:23,490 --> 00:21:24,890
A mi método

546
00:21:24,890 --> 00:21:28,109
raíz con 12, vale, en este caso

547
00:21:28,109 --> 00:21:29,690
12 es positivo, lo llamo

548
00:21:29,690 --> 00:21:31,890
y muy bien, me saca

549
00:21:31,890 --> 00:21:33,670
la raíz de 12

550
00:21:33,670 --> 00:21:35,950
vale, porque no ha habido ningún problema

551
00:21:35,950 --> 00:21:37,430
hemos llamado a método raíz

552
00:21:37,430 --> 00:21:40,109
como el número no era negativo

553
00:21:40,109 --> 00:21:41,910
ha ido por aquí y me ha devuelto

554
00:21:41,910 --> 00:21:44,109
la raíz de 12 como valor de retorno

555
00:21:44,109 --> 00:21:45,549
lo ha mostrado y se acabó, vale

556
00:21:45,549 --> 00:21:47,910
ahora llegamos al método con un

557
00:21:47,910 --> 00:21:50,269
número negativo, menos 12

558
00:21:50,269 --> 00:21:54,440
llegamos con

559
00:21:54,440 --> 00:21:55,259
un número negativo

560
00:21:55,259 --> 00:21:58,180
y efectivamente me ha dicho

561
00:21:58,180 --> 00:22:00,099
excepción, la máquina virtual

562
00:22:00,099 --> 00:22:01,559
ha visto un throw

563
00:22:01,559 --> 00:22:04,140
y ya sabemos lo que pasa cuando ve un throw

564
00:22:04,140 --> 00:22:06,339
que muestra las letras

565
00:22:06,339 --> 00:22:07,019
rojas

566
00:22:07,019 --> 00:22:09,880
que avisan de lo que ha pasado

567
00:22:09,880 --> 00:22:12,180
y en esas letras rojas

568
00:22:12,180 --> 00:22:13,079
se incluye

569
00:22:13,079 --> 00:22:15,680
esa variable mensaje

570
00:22:15,680 --> 00:22:17,519
que está en la excepción

571
00:22:17,519 --> 00:22:19,599
se incluye esa variable mensaje

572
00:22:19,599 --> 00:22:21,420
entonces cuando más explicativo sea mejor

573
00:22:21,420 --> 00:22:23,480
porque es lo que se va a encontrar

574
00:22:23,480 --> 00:22:25,500
el que está haciendo el, ¿vale?

575
00:22:27,839 --> 00:22:28,900
Pues esto es lo que me sale.

576
00:22:30,700 --> 00:22:31,920
Entonces, mucho mejor así

577
00:22:31,920 --> 00:22:34,319
que no que me salga un null pointer exception

578
00:22:34,319 --> 00:22:36,039
como antes, porque el null pointer exception

579
00:22:36,039 --> 00:22:37,960
no me estaba explicando qué ocurría.

580
00:22:38,579 --> 00:22:39,480
No me estaba explicando.

581
00:22:40,039 --> 00:22:42,500
Este sí me está diciendo, cuidado, número negativo

582
00:22:42,500 --> 00:22:44,039
y luego encima, por si no me ha quedado claro,

583
00:22:44,240 --> 00:22:46,240
con el nombre de la clase todavía no me ha quedado claro,

584
00:22:46,980 --> 00:22:47,960
pues tengo el mensajito.

585
00:22:48,480 --> 00:22:50,039
Es que no puedes acelerar el número negativo.

586
00:22:50,039 --> 00:22:50,579
Y ya está.

587
00:22:51,900 --> 00:22:54,420
¿Vale? Entonces así es como programaríamos.

588
00:22:55,180 --> 00:22:56,759
vale, aquí

589
00:22:56,759 --> 00:22:59,539
como ya vimos el otro día, el programa se ha parado

590
00:22:59,539 --> 00:23:01,400
claro, porque como no está capturada

591
00:23:01,400 --> 00:23:03,559
la excepción, no hay try-catch, se ha parado

592
00:23:03,559 --> 00:23:05,279
y al adiós no hemos llegado, claro

593
00:23:05,279 --> 00:23:07,539
¿que queremos capturar

594
00:23:07,539 --> 00:23:09,420
la excepción para que el programa no se pare

595
00:23:09,420 --> 00:23:11,339
y siga? pues lo de

596
00:23:11,339 --> 00:23:13,160
pues lo que teníamos hecho antes

597
00:23:13,160 --> 00:23:14,920
ah bueno, que tenía cambiado

598
00:23:14,920 --> 00:23:17,900
ponemos un try-catch

599
00:23:17,900 --> 00:23:22,079
y ya está

600
00:23:22,079 --> 00:23:26,220
y aquí

601
00:23:26,220 --> 00:23:28,539
si soy muy

602
00:23:28,539 --> 00:23:30,480
vaga, pues puedo hacer esto

603
00:23:30,480 --> 00:23:38,140
vale

604
00:23:38,140 --> 00:23:41,319
entonces cualquier excepción que se genere

605
00:23:41,319 --> 00:23:42,079
cualquiera

606
00:23:42,079 --> 00:23:45,359
incluido esta, porque esta le da de excepción

607
00:23:45,359 --> 00:23:47,220
incluido esa, va a ir a este catch

608
00:23:47,220 --> 00:23:49,039
va a ir a este catch cualquiera

609
00:23:49,039 --> 00:23:52,559
y si soy más

610
00:23:52,559 --> 00:23:54,980
precisa y quiero distinguir cada excepción

611
00:23:54,980 --> 00:23:56,720
pues pondría

612
00:23:56,720 --> 00:23:58,700
toda, vamos a ejecutar primero esta

613
00:23:58,700 --> 00:24:00,579
para ver que efectivamente se captura

614
00:24:00,579 --> 00:24:02,400
entonces que se va a hacer

615
00:24:02,400 --> 00:24:04,700
lo que haya en el catch, vamos a imaginar

616
00:24:04,700 --> 00:24:06,240
que yo pongo pues

617
00:24:06,240 --> 00:24:12,390
error, pues esto es lo que

618
00:24:12,390 --> 00:24:14,470
voy a ver en este caso, voy a ver error

619
00:24:14,470 --> 00:24:16,130
y además el programa va a seguir

620
00:24:16,130 --> 00:24:18,509
que es lo importante, además va a seguir, no se va a parar

621
00:24:18,509 --> 00:24:20,410
vale, yo ejecuto

622
00:24:20,410 --> 00:24:21,970
esto y me sale

623
00:24:21,970 --> 00:24:24,349
error porque es lo del catch, el programa

624
00:24:24,349 --> 00:24:26,390
no se para y seguimos con

625
00:24:26,390 --> 00:24:28,269
el adiós, el programa no se para

626
00:24:28,269 --> 00:24:28,990
vale

627
00:24:28,990 --> 00:24:32,230
que estoy en tiempo de desarrollo y quiero

628
00:24:32,230 --> 00:24:34,170
tener un poquito de más detalles de por qué

629
00:24:34,170 --> 00:24:36,250
ha ocurrido la excepción, hombre

630
00:24:36,250 --> 00:24:38,450
pues me aprovecho de los métodos de este objeto

631
00:24:38,450 --> 00:24:40,690
lo que hemos explicado antes

632
00:24:40,690 --> 00:24:42,130
este objeto

633
00:24:42,130 --> 00:24:44,150
es el pasado como parámetro

634
00:24:44,150 --> 00:24:45,450
que se ha instanciado aquí

635
00:24:45,450 --> 00:24:47,970
este objeto que se ha instanciado ahí

636
00:24:47,970 --> 00:24:49,890
después del throw

637
00:24:49,890 --> 00:24:51,710
este objeto que se instanció ahí

638
00:24:51,710 --> 00:24:54,049
es el que se ha pasado como parámetro

639
00:24:54,049 --> 00:24:54,910
y llega por aquí

640
00:24:54,910 --> 00:24:56,769
es este que llega por aquí

641
00:24:56,769 --> 00:24:59,529
puedo aprovecharme de métodos para hacer cosas

642
00:24:59,529 --> 00:25:00,890
entre ellos

643
00:25:00,890 --> 00:25:03,630
este, que es el que siempre nos encontramos

644
00:25:03,630 --> 00:25:05,990
de hecho me lo pone automáticamente el eclipse

645
00:25:05,990 --> 00:25:07,950
cuando hacemos un surround with trycatch

646
00:25:07,950 --> 00:25:09,569
me lo pone automáticamente

647
00:25:09,569 --> 00:25:11,789
¿y el print extract trace qué hace?

648
00:25:12,490 --> 00:25:14,569
pues es un system out de una información

649
00:25:14,569 --> 00:25:15,829
que coincide

650
00:25:15,829 --> 00:25:16,730
coincide

651
00:25:16,730 --> 00:25:20,529
con la que te saca la máquina virtual cuando no capturas

652
00:25:20,529 --> 00:25:21,950
y para el programa, coincide

653
00:25:21,950 --> 00:25:24,190
de hecho si ejecutamos esto

654
00:25:24,190 --> 00:25:28,309
pues vemos efectivamente que nos sale

655
00:25:28,309 --> 00:25:29,809
nos sale

656
00:25:29,809 --> 00:25:32,450
lo mismo que nos sale

657
00:25:32,450 --> 00:25:34,029
cuando no capturamos la excepción

658
00:25:34,029 --> 00:25:34,710
lo mismo

659
00:25:34,710 --> 00:25:37,009
porque el print

660
00:25:37,009 --> 00:25:39,009
stack trace

661
00:25:39,009 --> 00:25:41,109
saca eso, pero la diferencia

662
00:25:41,109 --> 00:25:42,890
es que aquí no se nos ha parado el programa

663
00:25:42,890 --> 00:25:44,930
no se nos ha parado, ha seguido con

664
00:25:44,930 --> 00:25:46,750
adiós, vale, aquí lo tenemos

665
00:25:46,750 --> 00:25:48,990
luego no se nos ha parado

666
00:25:48,990 --> 00:25:50,650
porque hay un try catch, no se nos ha parado

667
00:25:50,650 --> 00:25:52,950
pero el print stack trace

668
00:25:52,950 --> 00:25:54,529
me ha sacado esta información

669
00:25:54,529 --> 00:25:56,890
que en tiempo de desarrollo es útil, porque cuando yo estoy

670
00:25:56,890 --> 00:25:58,890
ejecutando esto, anda, que ha pasado

671
00:25:58,890 --> 00:25:59,930
pues tengo aquí la información

672
00:25:59,930 --> 00:26:03,049
cuando ya entrego este software

673
00:26:03,049 --> 00:26:04,650
al usuario que lo va a usar

674
00:26:04,650 --> 00:26:06,970
esto fuera, esto lo quito

675
00:26:06,970 --> 00:26:09,450
porque él no quiere ver esto

676
00:26:09,450 --> 00:26:11,109
él como mucho lo que quiere ver es

677
00:26:11,109 --> 00:26:20,740
esto, por ejemplo

678
00:26:20,740 --> 00:26:21,299
esto

679
00:26:21,299 --> 00:26:30,400
lo cambiaríamos a esto

680
00:26:30,400 --> 00:26:33,019
lo cambiaríamos

681
00:26:33,019 --> 00:26:34,940
a esto y ahora ya cuando ejecutamos esto

682
00:26:34,940 --> 00:26:36,920
pues ya el cliente verá, ah vale

683
00:26:36,920 --> 00:26:38,779
que he debido ponerlo negativo

684
00:26:38,779 --> 00:26:41,039
vale, hay que introducirlo positivo, vale

685
00:26:41,039 --> 00:26:44,240
pero esto

686
00:26:44,240 --> 00:26:46,279
lo pondremos cuando ya esto se lo

687
00:26:46,279 --> 00:26:47,279
entreguemos al usuario

688
00:26:47,279 --> 00:26:50,000
cuando estamos nosotros desarrollando

689
00:26:50,000 --> 00:26:51,900
lo que nos interesa

690
00:26:51,900 --> 00:26:53,339
es esto

691
00:26:53,339 --> 00:26:56,000
que es lo que nos informa

692
00:26:56,000 --> 00:26:57,660
de donde ha estado el fallo de nuestro código

693
00:26:57,660 --> 00:26:59,779
en que línea de código ha estado, donde tengo que meter para

694
00:26:59,779 --> 00:27:00,460
cambiarla

695
00:27:00,460 --> 00:27:02,779
yo hago esto

696
00:27:02,779 --> 00:27:05,759
y me saca esta información

697
00:27:05,759 --> 00:27:07,759
que es la que le vale al desarrollador

698
00:27:07,759 --> 00:27:09,619
porque el desarrollador ahora

699
00:27:09,619 --> 00:27:12,000
se viene aquí y pincha

700
00:27:12,000 --> 00:27:13,759
la línea de código que le ha dado el error

701
00:27:13,759 --> 00:27:15,539
oye, ¿dónde me ha dado? ah, aquí

702
00:27:15,539 --> 00:27:17,000
Ah, vale, me la ha dado aquí.

703
00:27:18,200 --> 00:27:18,519
¿Vale?

704
00:27:19,940 --> 00:27:21,299
¿Y esto de dónde me venía?

705
00:27:21,559 --> 00:27:24,319
Ah, me viene de la llamada método raíz.

706
00:27:24,460 --> 00:27:28,599
Entonces, uno va utilizando esta fila, esta traza,

707
00:27:29,099 --> 00:27:31,500
para irse yendo al código para cambiarlo,

708
00:27:31,619 --> 00:27:34,079
pero el usuario de la aplicación esta traza no le sirve para nada.

709
00:27:37,859 --> 00:27:39,180
Vale, ¿entendéis la diferencia, no?

710
00:27:44,799 --> 00:27:51,759
Bueno, entonces, está claro que uno puede hacer sus propias excepciones

711
00:27:51,759 --> 00:27:54,359
para que sus métodos vayan comunicando

712
00:27:54,359 --> 00:27:55,660
qué cosas han ocurrido

713
00:27:55,660 --> 00:27:59,680
que suponen un mal funcionamiento

714
00:27:59,680 --> 00:28:01,779
por causas controladas

715
00:28:01,779 --> 00:28:03,140
que se pueden cambiar por código.

716
00:28:04,400 --> 00:28:06,599
Se pueden cambiar porque introduzca un positivo

717
00:28:06,599 --> 00:28:07,779
y ya está, y no hay problema.

718
00:28:08,000 --> 00:28:08,980
No son errores en sí.

719
00:28:11,789 --> 00:28:13,970
Bueno, una cosa que no sé si ha quedado clara

720
00:28:13,970 --> 00:28:14,970
con el throw, quizá no.

721
00:28:16,049 --> 00:28:18,289
Cuando la máquina virtual encuentra un throw,

722
00:28:18,990 --> 00:28:19,730
encuentra un throw,

723
00:28:20,430 --> 00:28:21,430
lanza la excepción

724
00:28:21,430 --> 00:28:24,230
y si hay más cosas, silencio

725
00:28:24,230 --> 00:28:26,029
y si hay más cosas

726
00:28:26,029 --> 00:28:27,849
después del método, esas ya no se hacen

727
00:28:27,849 --> 00:28:29,430
esto es como si fuera un retun

728
00:28:29,430 --> 00:28:32,390
cuando en un método uno se encuentra un retun

729
00:28:32,390 --> 00:28:34,309
el método sale

730
00:28:34,309 --> 00:28:35,430
y da igual lo que hubiera después

731
00:28:35,430 --> 00:28:38,490
pues un throw instancia el objeto

732
00:28:38,490 --> 00:28:40,309
para que el método

733
00:28:40,309 --> 00:28:42,369
que lo llamo lo tenga ahí, para en el caso de haber

734
00:28:42,369 --> 00:28:44,210
catch, capturarlo

735
00:28:44,210 --> 00:28:46,170
y lanzarlo, si no hay catch nada, no sirve

736
00:28:46,170 --> 00:28:46,809
para nada ese objeto

737
00:28:46,809 --> 00:28:50,650
y además es como si hubiera un retun automáticamente

738
00:28:50,650 --> 00:28:52,490
Aquí es como si hubiera un return

739
00:28:52,490 --> 00:28:54,509
¿Vale?

740
00:29:03,480 --> 00:29:05,000
¿Veis? Aquí es como si hubiera un return

741
00:29:05,000 --> 00:29:06,759
Pero el propio compilador me dice

742
00:29:06,759 --> 00:29:09,440
Cuidado, a este código no llegas nunca

743
00:29:09,440 --> 00:29:12,079
Qué tontería que lo pongas porque nunca vas a llegar

744
00:29:12,079 --> 00:29:13,519
¿No? Ese es el mensaje

745
00:29:13,519 --> 00:29:14,759
Código inalcanzable

746
00:29:14,759 --> 00:29:17,180
Que nos dice a veces cuando hemos hecho un código

747
00:29:17,180 --> 00:29:18,400
Raro

748
00:29:18,400 --> 00:29:21,200
Código inalcanzable

749
00:29:21,200 --> 00:29:22,740
Después de un throw

750
00:29:22,740 --> 00:29:25,299
Se ignora todo lo que hay después

751
00:29:25,299 --> 00:29:26,619
Se acabó, se ignora

752
00:29:26,619 --> 00:29:29,160
un throw es como si llevaba un retun dentro

753
00:29:29,160 --> 00:29:30,819
es como si llevaba un retun

754
00:29:30,819 --> 00:29:32,819
cuando la máquina virtual ejecuta un throw

755
00:29:32,819 --> 00:29:35,000
lanza la excepción al de arriba

756
00:29:35,000 --> 00:29:35,819
al que lo llamó

757
00:29:35,819 --> 00:29:38,980
y el método se acabó, que hay cosas después

758
00:29:38,980 --> 00:29:41,019
pues esas cosas

759
00:29:41,019 --> 00:29:42,079
no se ejecutan

760
00:29:42,079 --> 00:29:44,599
imaginaos que aquí hay

761
00:29:44,599 --> 00:29:46,740
después de leerse, pues si hubiera una sentencia

762
00:29:46,740 --> 00:29:49,380
que fuera cualquier cosita

763
00:29:49,380 --> 00:29:58,869
claro, me dice código inalcanzable

764
00:29:58,869 --> 00:30:00,250
porque es o throw o retun

765
00:30:00,250 --> 00:30:01,329
con lo cual aquí no llega nunca

766
00:30:01,329 --> 00:30:04,430
entonces voy a cambiar el

767
00:30:04,430 --> 00:30:06,109
return un segundito

768
00:30:06,109 --> 00:30:08,490
para que me lo meta

769
00:30:08,490 --> 00:30:09,130
en una variable

770
00:30:09,130 --> 00:30:20,119
ahora el resultado este

771
00:30:20,119 --> 00:30:21,900
lo meto aquí

772
00:30:21,900 --> 00:30:28,589
vale, ahora ya os muestro el mensajito

773
00:30:28,589 --> 00:30:29,869
de despedida, lo que sea

774
00:30:29,869 --> 00:30:32,210
y ahora ya devuelvo el resultado

775
00:30:32,210 --> 00:30:33,829
vale

776
00:30:33,829 --> 00:30:36,650
he cambiado el código guardando el resultado

777
00:30:36,650 --> 00:30:37,730
una variable intermedia

778
00:30:37,730 --> 00:30:38,869
que lanzo al final

779
00:30:38,869 --> 00:30:40,509
entonces esta sentencia

780
00:30:40,509 --> 00:30:42,650
si yo voy por el else

781
00:30:42,650 --> 00:30:44,390
obviamente se ejecuta

782
00:30:44,390 --> 00:30:46,849
pero si voy por el if

783
00:30:46,849 --> 00:30:48,789
lanza la excepción

784
00:30:48,789 --> 00:30:50,789
y se acabó, ya no va a hacer

785
00:30:50,789 --> 00:30:52,890
nada más, se acabó

786
00:30:52,890 --> 00:30:53,829
¿verdad?

787
00:30:54,309 --> 00:30:55,710
o sea, si yo ahora en mi main

788
00:30:55,710 --> 00:30:58,329
llamo a método raíz

789
00:30:58,329 --> 00:31:00,109
pasándole un positivo

790
00:31:00,109 --> 00:31:07,470
pues efectivamente

791
00:31:07,470 --> 00:31:09,029
me muestra el mensajito

792
00:31:09,029 --> 00:31:11,269
me muestra la raíz y adiós

793
00:31:11,269 --> 00:31:13,509
pero si llamo

794
00:31:13,509 --> 00:31:15,009
a este método con un negativo

795
00:31:15,009 --> 00:31:17,470
esto ya no me lo muestra

796
00:31:17,470 --> 00:31:18,910
porque a eso no llega

797
00:31:18,910 --> 00:31:19,930
¿Vale?

798
00:31:24,299 --> 00:31:24,579
¿Veis?

799
00:31:24,619 --> 00:31:25,039
Ha lanzado

800
00:31:25,039 --> 00:31:26,359
este es el print extract trace

801
00:31:26,359 --> 00:31:28,180
y no ha hecho más

802
00:31:28,180 --> 00:31:28,720
no ha hecho más

803
00:31:28,720 --> 00:31:29,339
dentro del método

804
00:31:29,339 --> 00:31:29,920
no lo ha hecho

805
00:31:29,920 --> 00:31:33,450
luego el throw

806
00:31:33,450 --> 00:31:34,930
asociadlo a que también

807
00:31:34,930 --> 00:31:36,069
lleva un return incorporado

808
00:31:36,069 --> 00:31:37,029
o sea el método termina

809
00:31:37,029 --> 00:31:38,250
se crea el objeto

810
00:31:38,250 --> 00:31:39,109
se lanza para arriba

811
00:31:39,109 --> 00:31:40,029
y se acabó

812
00:31:40,029 --> 00:31:41,789
¿Vale?

813
00:31:41,869 --> 00:31:42,329
Pues ya está

814
00:31:42,329 --> 00:31:42,710
así

815
00:31:42,710 --> 00:31:43,849
programaríamos

816
00:31:43,849 --> 00:31:44,450
haciendo nuestras

817
00:31:44,450 --> 00:31:45,269
propias excepciones

818
00:31:45,269 --> 00:31:46,369
crear una clase excepción

819
00:31:46,369 --> 00:31:47,410
es tan sencillo como esto

820
00:31:47,410 --> 00:31:48,930
hacer la heredera

821
00:31:48,930 --> 00:31:49,690
de run time

822
00:31:49,690 --> 00:31:50,349
exception

823
00:31:50,349 --> 00:31:51,650
o de exception sin más

824
00:31:51,650 --> 00:31:52,490
ahora es cuando vamos

825
00:31:52,490 --> 00:31:54,329
incorporar la diferencia entre hacer la ladera de una

826
00:31:54,329 --> 00:31:57,579
o de otra. Ponerle un

827
00:31:57,579 --> 00:31:58,660
constructor, es lo habitual.

828
00:31:59,720 --> 00:32:01,599
Aquí, si queremos, a veces lo que

829
00:32:01,599 --> 00:32:03,440
hacemos para facilitarnos el trabajo,

830
00:32:04,200 --> 00:32:06,079
si no queremos cada vez que la instanciemos

831
00:32:06,079 --> 00:32:07,619
tener que

832
00:32:07,619 --> 00:32:08,359
escribir esto,

833
00:32:10,019 --> 00:32:11,359
pues podemos hacer un constructor

834
00:32:11,359 --> 00:32:13,880
con parámetros donde pongo yo un mensajito

835
00:32:13,880 --> 00:32:15,500
para que sea siempre el mismo.

836
00:32:16,579 --> 00:32:17,579
Podríamos hacer esto.

837
00:32:28,920 --> 00:32:30,160
Hacernos un constructor

838
00:32:30,160 --> 00:32:31,140
sin parámetros

839
00:32:31,140 --> 00:32:33,980
para permitir la instanciación

840
00:32:34,259 --> 00:32:35,539
más fácil, sin parámetros

841
00:32:35,539 --> 00:32:38,079
y llamar al constructor de super

842
00:32:38,079 --> 00:32:40,200
pasándole ya, en lugar

843
00:32:40,200 --> 00:32:41,480
de un parámetro que yo le pase

844
00:32:41,480 --> 00:32:43,880
le paso ya el mensajito que yo quiera

845
00:32:43,880 --> 00:32:55,230
entonces así, desde la propia

846
00:32:55,230 --> 00:32:57,049
clase excepción ya dejo fijado el mensaje

847
00:32:57,049 --> 00:32:58,950
ya lo dejo fijado, asumo

848
00:32:58,950 --> 00:33:01,069
que siempre que yo instancie esto

849
00:33:01,069 --> 00:33:03,210
siempre quiero poner este mensaje

850
00:33:03,210 --> 00:33:05,029
bueno, pues eso me lo puedo

851
00:33:05,029 --> 00:33:06,710
hacer más cómodo, porque ahora cuando

852
00:33:06,710 --> 00:33:09,009
instancio la excepción desde aquí

853
00:33:09,009 --> 00:33:10,849
pues la puedo instanciar así

854
00:33:10,849 --> 00:33:12,349
por ejemplo, la instancio

855
00:33:12,349 --> 00:33:14,230
con el constructor sin parámetros

856
00:33:14,230 --> 00:33:25,829
bueno y así es más fácil

857
00:33:25,829 --> 00:33:26,789
y más rápido de escribir

858
00:33:26,789 --> 00:33:29,829
uso el constructor sin parámetros

859
00:33:29,829 --> 00:33:31,349
para instanciarla, uso este

860
00:33:31,349 --> 00:33:33,589
y este constructor

861
00:33:33,589 --> 00:33:34,490
sin parámetros

862
00:33:34,490 --> 00:33:36,829
llame

863
00:33:36,829 --> 00:33:39,089
a ver que no tengo el punto y coma

864
00:33:39,089 --> 00:33:40,849
ahí

865
00:33:40,849 --> 00:33:43,470
y este constructor sin parámetros

866
00:33:43,470 --> 00:33:45,309
ya está fijando el mensajito que sea

867
00:33:45,309 --> 00:33:46,869
ya lo está fijando

868
00:33:46,869 --> 00:33:49,529
entonces de hecho ahora si ejecutamos

869
00:33:49,529 --> 00:33:50,309
el main

870
00:33:50,309 --> 00:33:59,380
bueno, pues me ha sacado el mensajito que yo he puesto en la clase

871
00:33:59,380 --> 00:34:01,259
este, me ha sacado este

872
00:34:01,259 --> 00:34:07,970
vale, pues así haríamos

873
00:34:07,970 --> 00:34:09,590
nuestras clases de excepción

874
00:34:09,590 --> 00:34:12,050
y no tienen más, elegimos

875
00:34:12,050 --> 00:34:13,110
silencio

876
00:34:13,110 --> 00:34:16,269
elegimos una clase de excepción

877
00:34:16,269 --> 00:34:17,789
por cada posible causa de error

878
00:34:17,789 --> 00:34:19,510
que contemplemos nosotros que puede salir

879
00:34:19,510 --> 00:34:21,550
y luego las lanzamos de esta manera

880
00:34:21,550 --> 00:34:23,489
y ya vemos como funciona

881
00:34:23,489 --> 00:34:25,650
vale, pues que nos falta

882
00:34:25,650 --> 00:34:27,829
diferencia

883
00:34:27,829 --> 00:34:29,909
entre hacerla

884
00:34:29,909 --> 00:34:32,110
heredera de esta

885
00:34:32,110 --> 00:34:34,309
o hacerla

886
00:34:34,309 --> 00:34:36,349
heredera de exception sin más

887
00:34:36,349 --> 00:34:38,230
¿vale? esto ya es

888
00:34:38,230 --> 00:34:40,170
muy cortito, vale, vamos a aprovechar

889
00:34:40,170 --> 00:34:42,070
y paramos aquí unos minutitos y luego ya

890
00:34:42,070 --> 00:34:44,289
completamos con esto y ponemos a unos ejercicios