1
00:00:00,150 --> 00:00:00,720
Bienvenidos.

2
00:00:00,780 --> 00:00:04,680
Vamos a ver una introducción al manejo de errores excepciones en Java.

3
00:00:05,020 --> 00:00:10,020
Bien, existe una regla muy importante en el mundo de la programación en cualquier lenguaje, que lo

4
00:00:10,020 --> 00:00:13,560
más probable que nuestras aplicaciones ocurran errores.

5
00:00:13,680 --> 00:00:14,400
Y eso es así.

6
00:00:14,500 --> 00:00:15,960
Bueno, pero qué sucede realmente?

7
00:00:15,960 --> 00:00:18,000
Después de que pasa algo?

8
00:00:18,120 --> 00:00:19,110
Ocurre un error?

9
00:00:19,170 --> 00:00:20,250
Cómo se maneja el error?

10
00:00:20,280 --> 00:00:21,240
Quién lo maneja?

11
00:00:21,330 --> 00:00:24,120
Se puede recuperar o no nuestra aplicación?

12
00:00:24,270 --> 00:00:28,560
Son varias preguntas que iremos respondiendo en el transcurso de esta sección.

13
00:00:28,660 --> 00:00:29,190
Bueno, ya va.

14
00:00:29,190 --> 00:00:36,090
Utiliza excepciones que básicamente es un tipo especial de objetos que nos proporciona una forma simple

15
00:00:36,210 --> 00:00:39,730
y también desacoplar ya el manejo de error y desacoplar.

16
00:00:40,050 --> 00:00:46,560
Me refiero al código principal de nuestro programa desacoplar, por ejemplo, de la lógica negocio de

17
00:00:46,560 --> 00:00:47,700
nuestro código principal.

18
00:00:47,760 --> 00:00:48,600
Todo lo que sea error.

19
00:00:48,690 --> 00:00:51,210
Y eso le lleva a otro componente, a otra clase.

20
00:00:51,300 --> 00:00:54,000
Y de ahí podemos manejar todo los errores.

21
00:00:54,130 --> 00:00:57,030
Bien, entonces en esta sección aprenderemos que es una acepción.

22
00:00:57,060 --> 00:00:58,560
Cómo se puede lanzar?

23
00:00:58,620 --> 00:01:00,720
Cómo se puede capturar y manejar esto?

24
00:01:00,730 --> 00:01:01,140
Errores?

25
00:01:01,200 --> 00:01:02,460
Qué hacer con una acepción?

26
00:01:02,520 --> 00:01:03,660
Una vez que capturada.

27
00:01:03,750 --> 00:01:10,980
Y también cómo hacer un mejor uso de excepciones un poco más personalizadas que heredan de algunas clases.

28
00:01:11,100 --> 00:01:13,800
Decepción que nos proporciona el lenguaje Java.

29
00:01:13,930 --> 00:01:14,070
Bien.

30
00:01:14,100 --> 00:01:15,870
Pero la gran pregunta qué es lo que es una acepción?

31
00:01:15,990 --> 00:01:21,750
Ya vimos que en términos de programación es un objeto, pero conceptualmente es un evento que ocurre

32
00:01:21,750 --> 00:01:23,460
durante la ejecución del programa.

33
00:01:23,550 --> 00:01:28,500
Un evento que es un problema y que interrumpe el flujo normal, pero bien lo podemos manejar de tal

34
00:01:28,500 --> 00:01:30,300
forma que continúe.

35
00:01:30,330 --> 00:01:36,270
También capturamos el terror, lo manejamos de alguna forma, lo guardamos en el log que se yo, o damos

36
00:01:36,270 --> 00:01:41,160
un camino alternativo y continuamos siempre cuando el error no sea tan grave.

37
00:01:41,280 --> 00:01:43,680
Mucho lenguaje, por ejemplo, estructurados.

38
00:01:43,740 --> 00:01:49,470
Cuando ocurrió un error lo que hacían era detener la ejecución de la aplicación, o bien manejaba el

39
00:01:49,470 --> 00:01:56,160
error con if con else utilizando código de errores del tipo String o el tipo integer.

40
00:01:56,220 --> 00:02:02,070
Y al final era bastante engorroso porque estaba todo mezclado como código espagueti de forma estructurada

41
00:02:02,160 --> 00:02:05,340
con la lógica principal de nuestra aplicación.

42
00:02:05,480 --> 00:02:11,220
Bueno, y justamente lo que hace Java y la programación orientada objeto es manejar los errores de forma

43
00:02:11,220 --> 00:02:14,790
independiente de esa acoplada utilizando excepciones.

44
00:02:14,990 --> 00:02:19,260
Bien, veamos algunas características principales que también hemos mencionado.

45
00:02:19,530 --> 00:02:23,280
Separa el código que gestiona los errores del código principal de programa.

46
00:02:23,340 --> 00:02:30,120
Es muy importante porque desacople nuestro código mucho más limpio y también simple y fácil de seguir.

47
00:02:30,300 --> 00:02:34,230
También nos permite manejar el error y continuar con la ejecución del programa.

48
00:02:34,350 --> 00:02:35,520
También lo hemos mencionado.

49
00:02:35,640 --> 00:02:39,180
También permite agrupar y diferenciar entre diferentes tipos de errores.

50
00:02:39,240 --> 00:02:44,100
Claro, una excepción es una instancia, es un objeto, pero de una clase especial.

51
00:02:44,190 --> 00:02:47,130
Y podemos tener varias clases y podemos manejar excepciones.

52
00:02:47,220 --> 00:02:49,140
Por ejemplo, utilizando true y catch.

53
00:02:49,320 --> 00:02:50,730
Lo vamos a ver y capturar.

54
00:02:50,730 --> 00:02:53,610
Según ese tipo, decepción es mucho más personalizado.

55
00:02:53,760 --> 00:02:58,410
Otra característica es que propaga errores hacia arriba en la pila de llamada.

56
00:02:58,500 --> 00:03:04,620
Esta pila se le conoce como estac 3 o también conocida como pila decepciones como por ejemplo nuestra

57
00:03:04,620 --> 00:03:07,890
aplicación en la clase principal con el método main.

58
00:03:07,950 --> 00:03:13,650
Podríamos invocar algún método, pero ese método a su vez internamente llama otro objeto con otro método.

59
00:03:13,740 --> 00:03:19,740
Y así se van comunicando los objeto de forma cascada hasta que algún punto podría ocurrir un error en

60
00:03:19,740 --> 00:03:24,180
alguna clase y método X y se podría lanzar este error o excepción.

61
00:03:24,240 --> 00:03:30,000
Comienza a escalar, comienza a propagarse en cascada hacia los demás métodos hasta llegar al último

62
00:03:30,000 --> 00:03:33,750
método en el cual fue llamado en la clase principal con el método Main.

63
00:03:33,870 --> 00:03:39,990
Siempre cuando no se maneje o no se capture el error con el true catch en alguna clase intermedia,

64
00:03:40,080 --> 00:03:46,380
bien la sintaxis true catch y finally algún método de algún objeto podría lanzar una excepción y lo

65
00:03:46,380 --> 00:03:51,630
puedo manejar este error dentro del bloque try que se le conoce entonces en el TROI.

66
00:03:51,750 --> 00:03:56,670
Acá se delimita el contexto donde podría ocurrir una excepción, donde se podría lanzar.

67
00:03:56,780 --> 00:04:00,810
Entonces lo que hace el try es, como dice el nombre, tratar de ejecutar un código.

68
00:04:00,910 --> 00:04:02,040
Bueno, y se falla.

69
00:04:02,100 --> 00:04:05,560
Pasa al catch que sería la siguiente sentencia catch.

70
00:04:05,790 --> 00:04:08,130
Entonces el true trata ejecutar un código.

71
00:04:08,250 --> 00:04:09,660
Si todo sale bien, perfecto.

72
00:04:09,780 --> 00:04:15,240
Obviamente el catch no se ejecuta, pero si se lanza alguna excepción, el catch acá puede manejar esta

73
00:04:15,240 --> 00:04:16,950
acepción según un tipo atto.

74
00:04:17,100 --> 00:04:18,240
Entonces es muy parecido.

75
00:04:18,270 --> 00:04:24,930
Como un método se pasa por argumento el tipo o nombre de la clase de la acepción y también la variable

76
00:04:25,080 --> 00:04:25,710
de la acepción.

77
00:04:25,800 --> 00:04:26,610
Es decir, el objeto.

78
00:04:26,760 --> 00:04:31,470
Y dentro del catch lo manejamos de alguna forma y así podemos continuar con el flujo normal.

79
00:04:31,570 --> 00:04:37,740
Y también tenemos el finali, que también otra sentencia que siempre va al final después del trayec

80
00:04:37,740 --> 00:04:39,690
catch bueno y siempre se va a ejecutar.

81
00:04:39,780 --> 00:04:45,510
Es opcional este bloque lo podemos implementar o no. Y ahí podemos hacer algún código común si sale

82
00:04:45,510 --> 00:04:46,560
bien o si sale mal.

83
00:04:46,590 --> 00:04:52,770
Por ejemplo, cerrar algún recurso, alguna conexión de base dato, por ejemplo, cerrar algún archivo.

84
00:04:53,040 --> 00:04:55,140
Entonces dentro del catch, ahí podemos personalizarlo.

85
00:04:55,140 --> 00:04:59,920
Mensaje de error, quizás de forma más amistosa y lo podemos imprimir en la consola, en la.

86
00:04:59,980 --> 00:05:06,040
Pantalla al usuario con un mensaje más resumido, por ejemplo, a la medida y así continuar con la ejecución

87
00:05:06,160 --> 00:05:07,180
de nuestro programa.

88
00:05:07,440 --> 00:05:12,250
Pero no solamente podemos capturar o tener un solo cache, una sola excepción, también podemos tener

89
00:05:12,310 --> 00:05:15,190
en cascada varios catch y se van capturando.

90
00:05:15,230 --> 00:05:17,050
Bueno, pero siempre va entrar a uno solo.

91
00:05:17,170 --> 00:05:23,440
Es decir, al tipo de exepción que se lanzó entonces, según el tipo es el catch que se va a capturar.

92
00:05:23,530 --> 00:05:25,900
Bueno, también está muy relacionado con la herencia.

93
00:05:25,990 --> 00:05:33,280
Por ejemplo, podríamos tener una clase decepción padre e hijas y podríamos tener varios catch que atrapan

94
00:05:33,400 --> 00:05:40,750
lo distintos tipos de acepciones de la jerarquía desde la clases más específica o concretas, es decir,

95
00:05:40,810 --> 00:05:44,470
hijas hasta las clases más genéricas los padres.

96
00:05:44,620 --> 00:05:46,600
Bueno, veamos un ejemplo de captura.

97
00:05:46,600 --> 00:05:47,830
Hay múltiples excepciones.

98
00:05:47,950 --> 00:05:54,580
Acá tenemos un código que primero obtenemos un valor del tipo string utilizando get option point, un

99
00:05:54,580 --> 00:05:56,650
valor ingresado por el teclado, por el usuario.

100
00:05:56,860 --> 00:05:58,180
Por ejemplo, un entero.

101
00:05:58,450 --> 00:06:04,180
Entonces lo primero es convertir este valor, que es un tipo string que debería contener un número,

102
00:06:04,300 --> 00:06:07,270
un valor entero, convertirlo a un integer.

103
00:06:07,440 --> 00:06:11,890
Bien, y acá podría ocurrir, por ejemplo, o lanzarse al error number format exception.

104
00:06:12,040 --> 00:06:13,690
Ya lo hemos visto en ejemplo.

105
00:06:13,930 --> 00:06:18,220
Entonces el primer error que estamos capturando, que estamos manejando en caso de que ocurra.

106
00:06:18,310 --> 00:06:19,840
Pero luego la idea de dividir.

107
00:06:19,960 --> 00:06:20,560
Por ejemplo.

108
00:06:20,590 --> 00:06:23,470
10 dividido en este divisor, en este número.

109
00:06:23,570 --> 00:06:26,830
Ahora, si se convierte correctamente a un número, se divida.

110
00:06:26,920 --> 00:06:28,330
Pero qué pasa si este número cero.

111
00:06:28,420 --> 00:06:32,590
Recuerden que cada valor numérico dividido por cero es infinito.

112
00:06:32,650 --> 00:06:36,250
Por lo tanto lanzaría una excepción aritmética exception.

113
00:06:36,340 --> 00:06:37,510
No se puede ir por cero.

114
00:06:37,600 --> 00:06:42,880
Entonces eso lo manejamos con un segundo catch y va en orden primero Number formas deception, que es

115
00:06:42,880 --> 00:06:45,840
el primero que podría ocurrir en la conversión en el part Saint.

116
00:06:45,940 --> 00:06:48,100
Luego viene el de aritmética.

117
00:06:48,160 --> 00:06:49,450
Excepto con la división.

118
00:06:49,690 --> 00:06:55,210
Como mencioné, cuando se lanza un excepción en nuestra aplicación, lo que se hace es lanzar una instancia,

119
00:06:55,210 --> 00:06:56,980
un objeto de la clase Septo.

120
00:06:57,130 --> 00:07:03,970
Pues entre clases septón opuesto una clase hija o derivada normalmente la clases hijas que heredan decepción

121
00:07:04,090 --> 00:07:09,790
es para dar un tipo de error más específico, pero por lo general no agrega mucha funcionalidad extra,

122
00:07:09,910 --> 00:07:16,330
solo que al ser distinto o distintas implementaciones, distintos tipos nos permiten distinguir entre

123
00:07:16,330 --> 00:07:22,090
los distintos tipos, decepciones y cómo se manejan o capturar la de forma independiente en los catch.

124
00:07:22,390 --> 00:07:25,690
Manejar de forma personalizada cada tipo de excepción.

125
00:07:25,780 --> 00:07:31,360
Principalmente la clase septum tiene dos constructores y dos métodos importante por el constructor de

126
00:07:31,360 --> 00:07:32,430
la clase es hecho.

127
00:07:32,470 --> 00:07:35,890
Podemos pasar un string con el mensaje de error personalizado.

128
00:07:36,040 --> 00:07:41,110
Acá lo podemos indicar, se fijan, pero también lo podemos omitir y el mensaje sería NULL.

129
00:07:41,200 --> 00:07:42,370
El atributo mensaje.

130
00:07:42,580 --> 00:07:46,240
Entonces tenemos forma de crear o instanciar una acepción.

131
00:07:46,360 --> 00:07:48,670
Un objeto Exception y Tom-Tom importante.

132
00:07:48,730 --> 00:07:55,600
Uno es el get message get message, obtener el mensaje con el detalle de error o resumen del error y

133
00:07:55,810 --> 00:08:02,710
tenemos el print stack 3 que imprime la traza completa o la pila completa de las excepciones desde el

134
00:08:02,710 --> 00:08:04,480
origen donde ocurre el error.

135
00:08:04,570 --> 00:08:11,500
El método donde todo comienza, donde se lanza esta acepción hasta el primer método donde comienza la

136
00:08:11,500 --> 00:08:16,300
llamada de los métodos, como por ejemplo podría ser una clase con el método main.

137
00:08:16,420 --> 00:08:21,760
Acá tenemos la traza completa, que es muy importante para realizar el debug y poder detectar dónde

138
00:08:21,760 --> 00:08:22,600
se originó el error.

139
00:08:23,050 --> 00:08:28,870
Existen dos tipos de excepciones están las checked obsequiadas y checked no chequeada.

140
00:08:29,230 --> 00:08:34,110
Hay una jerarquía de clases para el manejo excepciones en Java, donde todo parte de la clase excepto

141
00:08:34,270 --> 00:08:36,240
la clase Exception es checked.

142
00:08:36,470 --> 00:08:42,160
Esto significa que nos obliga, nos obliga a manejar la acepción, ya sea con el trait catch o bien

143
00:08:42,220 --> 00:08:43,300
lanzarla en un método.

144
00:08:43,480 --> 00:08:48,580
Esto significa propagar la excepción a los demás métodos que nos están invocando, es decir, derivar

145
00:08:48,730 --> 00:08:54,520
el manejo de escepción al otro método que llaman al método donde ocurre la acepción y luego tenemos

146
00:08:54,520 --> 00:08:55,390
el tipo hand.

147
00:08:55,420 --> 00:09:02,080
Chequen o no chequeas que es de la clase Rink tan exception la clase Rank Taime Septón y su descendencia.

148
00:09:02,170 --> 00:09:07,450
Las clases hijas no están obligadas al manejo de error, ocurren en tiempo ejecución, se lanzan en

149
00:09:07,450 --> 00:09:10,150
tiempo ejecución, aunque igual las puedo manejar de forma explícita.

150
00:09:10,270 --> 00:09:13,120
De todas forma con el trait catch, pero no estamos obligados.

151
00:09:13,420 --> 00:09:19,570
Ejemplo típico el null Pointer Deception cuando una instancia null invocamos un método lanzate error

152
00:09:19,720 --> 00:09:21,280
aritmético Exception.

153
00:09:21,340 --> 00:09:25,600
Cuando dividimos por cero array index out of bound Exception.

154
00:09:25,630 --> 00:09:27,880
Cuando se desbordan un arreglo.

155
00:09:27,910 --> 00:09:31,360
Por ejemplo, queremos hacer un elemento que está fuera del límite.

156
00:09:31,480 --> 00:09:33,250
En fin, number format deception.

157
00:09:33,280 --> 00:09:37,480
También cuando queremos convertir un tipo string en un tipo entero.

158
00:09:37,600 --> 00:09:45,130
Y por otro lado las que son chequeas que si obligan en tiempo de compilación en el IDE, por ejemplo,

159
00:09:45,220 --> 00:09:50,080
a manejar el error input output exception alguna opción de entrada y salida.

160
00:09:50,170 --> 00:09:56,410
Si queremos abrir algún archivo, si queremos leer algún archivo o relacionado con paseando SQL Exception,

161
00:09:56,500 --> 00:09:58,480
también estamos obligado a manejar este error.

162
00:09:58,750 --> 00:09:59,830
Veamos también un ejemplo.

163
00:09:59,920 --> 00:10:01,810
Lo más completo de la jerarquía.

164
00:10:01,960 --> 00:10:07,970
Acá tenemos el objeto Exception, que finalmente es hija de la clase Fru Haider.

165
00:10:08,380 --> 00:10:13,930
Muy importante porque indica que un objeto lánzale se puede lanzar con el operador FRU.

166
00:10:14,020 --> 00:10:15,790
Después vamos a ver o la sentencia FRU.

167
00:10:15,880 --> 00:10:21,820
Pero también tiene un hermano la clase Exception, que es error, pero error es no chequeada.

168
00:10:21,940 --> 00:10:26,710
Por lo tanto, no se maneja con el trait catch, pero son errores de sistema por falta de memoria.

169
00:10:26,830 --> 00:10:33,100
O se dañó una parte del disco duro y no puede escribir alguna información, o no puede leer algún dato

170
00:10:33,100 --> 00:10:37,960
que está guardado en alguna partición, por ejemplo, o errores relacionado a la máquina virtual de

171
00:10:37,960 --> 00:10:38,410
Java.

172
00:10:38,470 --> 00:10:43,570
Pero más bien son propios del sistema y de recursos del sistema de CPU de memoria.

173
00:10:43,600 --> 00:10:43,970
En fin.

174
00:10:44,110 --> 00:10:48,730
Y no nos podemos recuperar de estos errores y todo lo que sea septón de nuestra aplicación.

175
00:10:48,890 --> 00:10:54,780
Y es así que le puedo manejar, ya sea reineta me section no chequeada no nos obliga a manejar estas

176
00:10:54,790 --> 00:11:01,240
opciones y del tipo exception que si nos obliga que son chequeada como por ejemplo bueno, interruptor

177
00:11:01,330 --> 00:11:08,500
Exception, SQL, Septón y o Exception y a su vez tenemos Not Found Exception y en ragtime.

178
00:11:08,590 --> 00:11:14,320
Bueno, muchas de las que hemos visto null pointer deception aritmética exception array index out of

179
00:11:14,320 --> 00:11:16,900
bonis action number fórmate hacer John.

180
00:11:17,020 --> 00:11:23,030
Bueno, en general, cuando implementar una que sea checked o implementar una que sea ancha.

181
00:11:23,410 --> 00:11:29,470
Claro, porque podemos personalizar y crear nuestras propias excepciones heredando ya sea deception.

182
00:11:29,560 --> 00:11:35,620
Si queremos implementar una chequeada o heredar de raiting, excepto que no sea chequeada.

183
00:11:35,710 --> 00:11:37,390
Entonces cuando implementar una.

184
00:11:37,390 --> 00:11:38,300
Cuando implementar otra?

185
00:11:38,380 --> 00:11:41,590
Bueno, hay una regla general que son para excepciones.

186
00:11:41,680 --> 00:11:45,340
Checker se usa cuando nuestra aplicación se puede recuperar del error.

187
00:11:45,490 --> 00:11:51,280
Es decir, es capaz de recuperarse y que lo tratemos de forma adecuada y continuar con el flujo mientras

188
00:11:51,280 --> 00:11:57,100
que las han chequeé cuando ocurre algún error grave de programación y no se puede hacer nada para recuperarse.

189
00:11:57,220 --> 00:11:58,240
Esa es la regla que hay.

190
00:11:58,420 --> 00:12:05,080
Aunque también hay excepciones, porque también podríamos tener alguna excepción no chequeada and checked

191
00:12:05,230 --> 00:12:06,350
del tipo right time.

192
00:12:06,490 --> 00:12:08,920
Como en ambas formas deception y si ocurren, error.

193
00:12:09,040 --> 00:12:14,300
Bueno, si no puedo convertir un string a un número, podríamos asignar un cero, por ejemplo, y poder

194
00:12:14,320 --> 00:12:16,150
continuar con el flujo normal de la aplicación.

195
00:12:16,300 --> 00:12:19,630
Se fijan o incluso aritmética exception se ocurre.

196
00:12:19,630 --> 00:12:24,190
La solución la puedo manejar y volver a appel el dato para que el usuario vuelva ingresar el número

197
00:12:24,310 --> 00:12:30,160
y esta vez no increase por ejemplo cero y puede ingresar otro número mayor que cero para que pueda ser

198
00:12:30,160 --> 00:12:30,820
divisible.

199
00:12:30,970 --> 00:12:33,070
En fin, hay diferentes escenarios.

200
00:12:33,250 --> 00:12:34,060
Continuemos.

201
00:12:34,210 --> 00:12:40,510
La cláusula frus en plural con s importante se utiliza en la declaración de métodos.

202
00:12:40,660 --> 00:12:48,250
Indica que este método dentro de su contexto, de sus llaves, va a lanzar algún tipo acepcion y estos

203
00:12:48,250 --> 00:12:50,560
tipos de sesiones lo tenemos que definir en el frus.

204
00:12:50,680 --> 00:12:55,930
En el caso de que lanza una sola, bueno, se define una sola, pero también podría lanzar varios tipos

205
00:12:55,990 --> 00:12:58,090
de secciones y ahí sería separar por coma.

206
00:12:58,210 --> 00:13:03,130
Entonces en el ejemplo tenemos una clase por ejemplo cliente repositorio con el método por Heidy y podría

207
00:13:03,130 --> 00:13:04,330
lanzar una acepción.

208
00:13:04,420 --> 00:13:07,810
Por ejemplo, si Leydi es 0, lanza una excepción.

209
00:13:07,960 --> 00:13:13,360
Bueno, y en la clase que invoca este método, ya sea una clase con el método main o cualquier otra,

210
00:13:13,450 --> 00:13:14,500
tiene que manejar este error.

211
00:13:14,620 --> 00:13:16,100
Entonces hay dos alternativas.

212
00:13:16,180 --> 00:13:23,260
Como hemos visto, una manejar con try catch este error, esta sección, o bien propagar la excepción

213
00:13:23,380 --> 00:13:25,180
hacia el siguiente método.

214
00:13:25,360 --> 00:13:30,550
Entonces también te indicando que el método main posiblemente lance la excepción Exception.

215
00:13:30,730 --> 00:13:36,940
Entonces los métodos deben capturar, manejar esta sección o bien propagar las o la excepción chequeada

216
00:13:37,030 --> 00:13:40,540
que pueden ser lanzadas dentro de su ámbito del método.

217
00:13:40,750 --> 00:13:42,430
Veamos la sentencia FROOT.

218
00:13:42,580 --> 00:13:47,140
Bueno, la sentencia FRU es justamente para lanzar una acepción dentro, un método.

219
00:13:47,230 --> 00:13:51,070
Acá tenemos ya el detalle de la clase cliente repositorio.

220
00:13:51,160 --> 00:13:54,820
El método por Heidy y cuando el índice da igual a cero.

221
00:13:54,880 --> 00:13:58,420
Creamos la instancia con New Exception y con el FRU.

222
00:13:58,540 --> 00:14:00,040
Lanzamos este objeto.

223
00:14:00,130 --> 00:14:01,000
Pero muy importante.

224
00:14:01,060 --> 00:14:02,810
Tiene que ser del tipo Exception.

225
00:14:02,920 --> 00:14:06,940
Recuerden que Exception hereda de la clase Fru Eubea.

226
00:14:07,150 --> 00:14:08,380
Es decir, se puede lanzar.

227
00:14:08,470 --> 00:14:09,880
No podemos lanzar con Froot.

228
00:14:09,880 --> 00:14:12,350
Cualquier objetos tiene que ser del tipo Freulein.

229
00:14:12,490 --> 00:14:16,870
Es decir, una excepción, ya sea Exception o una clase propia.

230
00:14:16,870 --> 00:14:19,900
Nuestra personalizada que hereden de esta clase de yaba bien.

231
00:14:19,900 --> 00:14:24,280
Crear una clase de excepción personalizada es bastante simple, porque solamente tenemos que heredar

232
00:14:24,370 --> 00:14:28,510
Deception en caso de que queramos que sea chequeada o Checker.

233
00:14:28,660 --> 00:14:34,190
O también podríamos extender de reineta es hecha si no queremos que sea chequeada, sino que sea aunt

234
00:14:34,250 --> 00:14:34,650
checked.

235
00:14:34,810 --> 00:14:39,590
Pero bueno, independiente de una u otra, utilizando herencia con stents.

236
00:14:39,730 --> 00:14:45,190
Entonces nuestra clase hereda de Exception de forma opcional, porque no es obligación implementar el

237
00:14:45,190 --> 00:14:47,470
constructor con un mensaje más personalizado.

238
00:14:47,590 --> 00:14:53,770
Porque recuerden, la clase de excepción tiene dos tipos de constructores principales uno vacío que

239
00:14:53,770 --> 00:14:55,210
no recibe ningún mensaje.

240
00:14:55,270 --> 00:14:58,810
Por lo tanto, el mensaje en NULL y otro con el mensaje de texto.

241
00:14:59,120 --> 00:15:04,760
Luego ya la podemos utilizar, por ejemplo, en nuestra clase repositorio en el método por Heidy y en

242
00:15:04,760 --> 00:15:11,900
vez de lanzar un tipo genérico Exception, ya estamos personalizando y lanzando, manejando una excepción

243
00:15:11,930 --> 00:15:15,920
personalizada, personalizada, excepto en este caso con un mensaje.

244
00:15:16,040 --> 00:15:17,630
Aydin no puede ser cero.

245
00:15:17,970 --> 00:15:22,730
Entonces saca acampemos el tipo y el tipo que se lanza también lo manejamos en el método.

246
00:15:22,820 --> 00:15:30,530
Acá se declara con la cláusula FRUS para propagar la sección a los métodos que están invocando el porahí.

247
00:15:30,680 --> 00:15:36,650
Entonces al final lo que hace es pasar la tarea de manejar la escepción al otro métodos a los métodos

248
00:15:36,650 --> 00:15:37,670
que invocan este método.

249
00:15:37,880 --> 00:15:40,130
Pero también podemos tener nuestra propia herencia.

250
00:15:40,130 --> 00:15:44,870
decepcionÃ, como teníamos en el ejemplo anterior, una clase personalizada Deception que hereda.

251
00:15:44,870 --> 00:15:46,190
Deception Perfecto.

252
00:15:46,220 --> 00:15:52,400
Pero también podemos tener otra clase más personalizada que le podríamos llamar No cero Heidy Exception,

253
00:15:52,520 --> 00:15:59,240
que hereda de Personalizada Septón se fijan y luego en nuestra clase repositorio acá podemos lanzar

254
00:15:59,300 --> 00:16:02,400
el tipo más genérico, por ejemplo personalizada Deception.

255
00:16:02,510 --> 00:16:08,990
Bueno, nunca bueno que sea tan tan genérico que lance excepciones, por ejemplo, sino que sea nuestra

256
00:16:08,990 --> 00:16:13,970
clase más genérica pero propia nuestra que estemos implementando que debe desechÃ.

257
00:16:14,150 --> 00:16:21,150
Entonces acá colocamos el tipo más genérico y lanzamos el tipo más concreto que es hija de esta clase

258
00:16:21,230 --> 00:16:23,840
padre personalizada, excepto se fijan.

259
00:16:23,990 --> 00:16:30,080
Entonces acá indicamos el tipo padre y acá lanzamos el tipo o la instancia hija.

260
00:16:30,170 --> 00:16:36,140
O bien lanzar el hijo llega indicar el hijo en el Stroud, pero siempre mejor que sea lo más genérico

261
00:16:36,140 --> 00:16:36,560
posible.

262
00:16:36,750 --> 00:16:38,840
Bien sobre escritura y manejo de excepción.

263
00:16:38,970 --> 00:16:45,170
Bueno, esto se aplica tanto a clases abstracta o clase padre con su reescritura de método, pero también

264
00:16:45,290 --> 00:16:46,610
a implementación interfaces.

265
00:16:46,730 --> 00:16:51,800
Recuerden que cuando tenemos una interfaz por ejemplo Cloud Repository, un método por Heidy.

266
00:16:51,950 --> 00:16:56,900
Acá también se tiene que definir las excepciones que iba a lanzar los métodos en la jerarquía, por

267
00:16:56,900 --> 00:16:58,980
ejemplo, por ahí va a lanzar personalizadas.

268
00:16:59,420 --> 00:17:05,210
Y por eso importante que sea el tipo más genérico posible de nuestras implementaciones, de nuestra

269
00:17:05,210 --> 00:17:07,340
jerarquía de clases, de excepciones.

270
00:17:07,520 --> 00:17:12,920
Claro, porque después en la clase concreta, por ejemplo cliente repositorio, mantenemos el tipo genérico,

271
00:17:12,950 --> 00:17:20,990
pero cada implementación puede lanzar su propia clase concreta, que es hija de la clase decepción más

272
00:17:20,990 --> 00:17:26,630
genérica que se está lanzando, en este caso personalizada septón como no 0 hay 10 Artiom, pero así

273
00:17:26,720 --> 00:17:29,420
podríamos tener distintas implementaciones, pero también.

274
00:17:29,540 --> 00:17:35,060
Otra alternativa es lanzar no solamente la genética, sino también la concreta.

275
00:17:35,300 --> 00:17:36,470
La hija.

276
00:17:36,890 --> 00:17:38,900
Acá eso sería lo más importante.

277
00:17:39,000 --> 00:17:40,730
Continuamos en la siguiente clase.