1
00:00:01,360 --> 00:00:03,040
Hola y bienvenidos a esta elección.

2
00:00:03,040 --> 00:00:07,270
A continuación vamos a ver el primer ejercicio del manejo de excepciones en Java.

3
00:00:07,270 --> 00:00:08,260
Están listos.

4
00:00:08,320 --> 00:00:15,810
Vamos bien como primer paso vamos a hacer cualquier proyecto que tengamos abierto y vamos a crear uno

5
00:00:15,810 --> 00:00:16,780
nuevo.

6
00:00:16,810 --> 00:00:22,240
En fin ni proyecto seleccionamos llama Wild Maybe en Java Application damos sigue Next.

7
00:00:22,630 --> 00:00:36,360
El nombre del proyecto se va a llamar manejo excepciones 1 y lo depositamos en la ruta de cursos Java.

8
00:00:36,620 --> 00:00:39,360
El nombre del grupo hoy día es MX con GM globalmente.

9
00:00:39,710 --> 00:00:44,270
La versión 1.0 y el nombre del paquete lo dejamos vacío.

10
00:00:44,270 --> 00:00:50,210
Damos clic en Finalizar y en esta elección lo que vamos a hacer es crear una clase de división.

11
00:00:50,210 --> 00:00:54,890
Posteriormente vamos a ejecutar una división errónea y lo que vamos a hacer es procesar esta excepción

12
00:00:55,130 --> 00:01:00,440
de la división con valores erróneos así que vamos a hacer lo siguiente Vamos a crear una clase llamada

13
00:01:00,440 --> 00:01:09,040
División damos clic derecho Nioh Java class la clave se llama división y la depositamos en el paquete

14
00:01:09,040 --> 00:01:09,520
de Domain

15
00:01:13,610 --> 00:01:17,950
quitamos los comentarios y de momento va a ser todo lo que vamos a hacer sobre esta clase.

16
00:01:18,020 --> 00:01:22,260
Vamos a agregar una segunda clase que se va a llamar operación excepción

17
00:01:28,580 --> 00:01:34,980
y la depositamos en el mismo paquete en el paquete de Domaine damos clic en Finalizar quitamos estos

18
00:01:34,980 --> 00:01:42,700
comentarios y de momento vamos a dejar hasta aquí este código y para definir una clase que va a manejar

19
00:01:42,760 --> 00:01:49,000
excepciones esta clase debe de extender de alguna de las clases decepción de la jerarquía de clases

20
00:01:49,170 --> 00:01:50,960
de la de acepciones en Java.

21
00:01:51,040 --> 00:01:57,430
La clase padre de todas las clases en Java es la clase voivoda y como subclase de la clase Truyol tenemos

22
00:01:57,430 --> 00:02:02,720
la clase exception así que esta clase va a extender la clase exception.

23
00:02:02,890 --> 00:02:09,850
Ahora vamos a crear un constructor para poder recibir el mensaje de la excepción creamos un constructor

24
00:02:09,850 --> 00:02:10,540
de esta clase

25
00:02:14,510 --> 00:02:21,170
este constructor va a recibir la variable de mensaje que es el mensaje de decepción que vamos a recibir

26
00:02:21,410 --> 00:02:26,550
en esta clase y esta clase lo que va a hacer es mandar a llamar el constructor de la clase padre en

27
00:02:26,560 --> 00:02:32,390
la clase exception y la pasamos el mensaje de la decepción que estamos recibiendo.

28
00:02:35,400 --> 00:02:40,920
Y con eso podemos crear clases personalizadas de excepciones en Java así que ya tenemos nuestra clase

29
00:02:40,930 --> 00:02:46,690
decepción operación decepción vamos ahora a nuestra clase de división y vamos a negar los atributos

30
00:02:49,010 --> 00:02:57,210
el primer atributo va a ser el numerador de la división y el segundo atributo de tipo entero va a ser

31
00:02:57,240 --> 00:03:06,030
el denominador ahora vamos a agregar un constructor de esta clase donde vamos a recibir los dos argumentos

32
00:03:06,240 --> 00:03:15,630
de tipo entero llamado numerador y denominador y para indicar que este constructor puede arrojar una

33
00:03:15,630 --> 00:03:16,530
excepción.

34
00:03:16,530 --> 00:03:22,140
Entonces vamos a utilizar la palabra reservada throws y lo que vamos a hacer te vamos a indicar que

35
00:03:22,140 --> 00:03:28,880
este constructor posiblemente dentro de su código puede arrojar la excepción de operación excepción

36
00:03:29,310 --> 00:03:31,740
así que eso es parte de la firma de los métodos.

37
00:03:32,070 --> 00:03:38,360
Podemos observar el modificador de acceso posteriormente el nombre de la clase ya que es un constructor.

38
00:03:38,360 --> 00:03:45,230
Posteriormente entre paréntesis y separado por los argumentos y finalmente indicamos si este constructor

39
00:03:45,350 --> 00:03:52,000
puede arrojar una excepción o no. Posteriormente agregamos el cuerpo de este constructor y es la firma

40
00:03:52,060 --> 00:03:56,710
de este constructor ahora vamos a revisar si el denominador

41
00:04:01,060 --> 00:04:05,910
es igual a cero entonces quiere decir que es una operación no válida.

42
00:04:06,040 --> 00:04:11,620
Por lo tanto lo que vamos a hacer es arrojar una nueva excepción para arrojar una nueva acepción en

43
00:04:11,620 --> 00:04:16,500
este momento vamos a crear un objeto de tipo exception vamos a utilizar la palabra reservada.

44
00:04:17,430 --> 00:04:21,240
Y lo que vamos a hacer es crear un nuevo objeto de nuestra clase que hemos creado.

45
00:04:21,250 --> 00:04:22,730
Operación excepción.

46
00:04:23,940 --> 00:04:32,450
Así que creamos un nuevo objeto Niu operación excepción y pasamos el mensaje a nuestro constructor según

47
00:04:32,450 --> 00:04:39,860
lo hemos definido vamos a recibir el mensaje de la excepción mandamos el mensaje del error denominador

48
00:04:41,980 --> 00:04:48,480
igual a cero así que con eso estamos arrojando una nueva excepción del tipo de la clase que hemos creado

49
00:04:48,480 --> 00:04:55,030
del tipo excepción para que podamos ejecutarlo según estamos observando en esta línea de código.

50
00:04:55,030 --> 00:04:58,680
Esta clase de operación excepción debe descender de la clase exception.

51
00:04:58,990 --> 00:05:04,330
Si esta clase no hubiera extendido la clase exception entonces el compilador nos marca que no podemos

52
00:05:04,540 --> 00:05:08,210
utilizar esta clase ya que no se puede convertir a un tipo a otro.

53
00:05:08,590 --> 00:05:15,040
Recordemos que la clase destructivos es la clase padre de todas las excepciones en Java y la clase excepción

54
00:05:15,310 --> 00:05:21,580
es una clase hija de la clase Weibo así que no podríamos utilizar esta sintaxis para arrojar una excepción

55
00:05:21,910 --> 00:05:26,470
de la clase operación excepción si esta clase no hubiera extendido de la clase exception.

56
00:05:26,580 --> 00:05:31,450
Así que guardamos cambios para que esto pueda ser válido y con eso ya podemos crear un nuevo objeto

57
00:05:31,450 --> 00:05:36,910
de tipo excepción de tipo Operación excepción y arrojar esta excepción y posteriormente en la firma

58
00:05:36,910 --> 00:05:42,220
del método indicamos que posiblemente se arroje una excepción en dado caso de que el denominador sea

59
00:05:42,220 --> 00:05:43,050
igual a cero.

60
00:05:43,240 --> 00:05:49,090
Si el denominador es diferente de cero entonces esta acepción no se arrojaría bien y si no entramos

61
00:05:49,110 --> 00:05:56,420
Essays entonces continuamos con el constructor inicializar los los atributos de nuestra clase

62
00:06:00,290 --> 00:06:07,330
con los argumentos que estamos recibiendo en este constructor inicializar los el numerador y el denominador

63
00:06:09,030 --> 00:06:12,350
para poder realizar la operación de división.

64
00:06:12,600 --> 00:06:20,000
Y finalmente agregamos un método que no va a regresar nada llamado visualizar operación

65
00:06:23,870 --> 00:06:36,920
y mandamos simplemente a consola el resultado de la división es y dividimos el numerador entre el denominador.

66
00:06:37,080 --> 00:06:43,370
Por ello es que el denominador no puede ser 0 y si fuera 0 desde la construcción de este objeto división

67
00:06:43,640 --> 00:06:49,040
entonces general haríamos esta excepción indicando al usuario que tenemos problemas para crear este

68
00:06:49,040 --> 00:06:50,150
objeto de división.

69
00:06:50,210 --> 00:06:52,240
Si el denominador es igual a cero.

70
00:06:52,520 --> 00:06:57,440
Por lo tanto al momento de visualizar la operación esta operación ya debería de ser válida ya que el

71
00:06:57,440 --> 00:06:59,920
denominador no puede ser igual a cero.

72
00:07:00,080 --> 00:07:03,020
Eso es todo el código respecto a nuestra clase división.

73
00:07:03,020 --> 00:07:09,370
Ahora vamos a crear una clase para poner a prueba esto sobre sus packages derecho new Java class el

74
00:07:09,380 --> 00:07:18,190
nombre de la clase se llama manejo excepciones 1 y el nombre del paquete se va a llamar test y damos

75
00:07:18,190 --> 00:07:27,040
clic en Finalizar quitamos estos comentarios agregamos un método main Public sati Main.

76
00:07:27,320 --> 00:07:29,950
Ahora vamos a poner a prueba nuestra clase Division.

77
00:07:30,260 --> 00:07:33,300
Vamos a crear un nuevo objeto de esta clase.

78
00:07:35,220 --> 00:07:42,180
Y le pasamos los valores de 10 en el numerador y vamos a poner a prueba la excepción vamos a pasar el

79
00:07:42,180 --> 00:07:44,190
denominador igual a cero.

80
00:07:44,220 --> 00:07:51,430
Importamos esta clase de división y podemos observar que el compilador en este caso el IDE nos está

81
00:07:51,430 --> 00:07:54,850
indicando que el constructor posiblemente pueda arrojar una excepción.

82
00:07:54,880 --> 00:08:01,070
Por lo tanto tenemos dos opciones podemos propagar la excepción utilizando la palabra reservada throws.

83
00:08:01,180 --> 00:08:08,310
Vamos a ver si damos clic sobre esto que sucede podemos observar que el método main además de la firma

84
00:08:08,310 --> 00:08:14,610
del método que ya hemos venido trabajando se le ha agregado que este método posiblemente pueda arrojar

85
00:08:14,610 --> 00:08:20,550
la acepción de operación excepción la misma que arroja este constructor de división.

86
00:08:20,730 --> 00:08:26,010
Así que con esto lo que estamos haciendo es propagar esta excepción y en la consola en dado caso de

87
00:08:26,010 --> 00:08:31,050
que suceda alguna excepción entonces se va a visualizar este error vamos a guardar cambios y vamos a

88
00:08:31,050 --> 00:08:31,620
ejecutar

89
00:08:39,150 --> 00:08:44,990
y podemos observar que se está lanzando una excepción debido a que el denominador es igual a cero así

90
00:08:44,990 --> 00:08:50,300
que se manda el mensaje y posteriormente se arroja la excepción el compilador nos indica dónde está

91
00:08:50,300 --> 00:08:50,800
el problema.

92
00:08:50,810 --> 00:08:57,760
En este caso en la clase división punto Java en la línea 10 y también dentro de la clase manejo decepciones

93
00:08:57,790 --> 00:09:03,680
1.La va en la línea 9 y si damos clic aquí nos lleva a la línea donde está el error.

94
00:09:03,680 --> 00:09:07,010
Así que aquí es donde se lanzó la excepción denominador igual a cero

95
00:09:10,190 --> 00:09:15,280
y en la parte inferior podemos observar lo que se conoce como la pila decepciones todas estas líneas

96
00:09:15,280 --> 00:09:22,900
que nos arrojan se conoce como el log o bitácora de error o la pila de errores y podemos ver también

97
00:09:22,900 --> 00:09:29,180
que la construcción del proyecto falló bien así que de esta manera estamos arrojando la excepción ya

98
00:09:29,180 --> 00:09:35,700
que el denominador fue igual a cero sin embargo esta es una manera en la cual estamos propagando la

99
00:09:35,700 --> 00:09:42,560
excepción vamos a manejar otra manera para que nuestro programa no termine de manera abrupta entonces

100
00:09:42,560 --> 00:09:47,390
lo que vamos a hacer no es propagar la excepción sino que lo que vamos a hacer es envolver esa excepción

101
00:09:47,660 --> 00:09:55,230
en un bloque Trui y Cacho así que la segunda opción válida que nos muestran nos indica que podemos envolver

102
00:09:55,500 --> 00:10:02,760
esta línea de código en un bloque y cache vamos a dar click y Podemos se va la sintaxis no se agrega

103
00:10:02,820 --> 00:10:03,700
el bloque try.

104
00:10:03,960 --> 00:10:08,700
Posteriormente abre llaves para inicializar el bloque de código y posteriormente dentro de este bloque

105
00:10:08,700 --> 00:10:13,230
de código tenemos la línea de código que posiblemente lanza esta excepción.

106
00:10:13,320 --> 00:10:18,510
Posteriormente cerramos este bloque de código y agregamos la palabra reservada cache y dentro de los

107
00:10:18,510 --> 00:10:24,450
paréntesis indicamos la posible excepción que pueda arrojar esta línea de código la cual estamos envolviendo

108
00:10:24,450 --> 00:10:30,240
con el bloque cazzo definimos el tipo de la variable el nombre de la variable en este caso se llama

109
00:10:30,300 --> 00:10:36,300
X decepción y aunque nos Sarea esta línea de código de momento no lo vamos a utilizar.

110
00:10:36,300 --> 00:10:39,980
Vamos a quitar esta línea y también quitamos estos importes.

111
00:10:40,020 --> 00:10:45,780
De momento esos import no los vamos a utilizar y con la variable x lo que podemos hacer es solicitar

112
00:10:45,870 --> 00:10:52,490
el mensaje de la excepción así que en dado caso de que ocurra una excepción entonces esta línea ya no

113
00:10:52,490 --> 00:10:57,680
va a terminar de manera abrupta ya no va a propagar la excepción sino que el bloque y cache.

114
00:10:57,980 --> 00:11:03,710
Precisamente lo que va a hacer es interceptar el error que se lance debido a esta línea de código.

115
00:11:03,710 --> 00:11:09,710
Aquí es donde se hace el caché de la excepción y posteriormente podemos ejecutar algún código para mostrar

116
00:11:09,710 --> 00:11:14,390
por ejemplo en este caso cuál fue la excepción pero que ya no termina de manera abrupta este código

117
00:11:14,660 --> 00:11:17,760
sino que pueda continuar con las siguientes líneas de código.

118
00:11:17,840 --> 00:11:19,430
Guardamos cambios y ejecutamos

119
00:11:22,670 --> 00:11:27,660
y podemos observar que nuestro código sea ejecutado de manera correcta se ha terminado de ejecutar vamos

120
00:11:27,660 --> 00:11:31,350
a mandar a consola este mensaje para que podamos visualizarlo

121
00:11:36,000 --> 00:11:37,650
guardamos cambios y ejecutamos

122
00:11:40,990 --> 00:11:43,070
y podemos observar el error.

123
00:11:43,070 --> 00:11:49,640
El error fue denominador igual a cero que fue precisamente el error que arrojamos en esa línea de código

124
00:11:50,060 --> 00:11:53,060
debido a que el denominador fue igual a cero en la llamada.

125
00:11:53,060 --> 00:11:58,730
A este constructor pero en este momento ya podríamos continuar con otras líneas de código

126
00:12:05,520 --> 00:12:07,290
el programa continúa.

127
00:12:07,530 --> 00:12:14,020
Guardamos cambios y ejecutamos y podemos observar que simplemente el programa continúa ya no termina

128
00:12:14,020 --> 00:12:20,740
de manera anormal así que aunque Podemos propagar esta excepción indicando en el método main que vamos

129
00:12:20,740 --> 00:12:26,110
a arrojar posiblemente esta excepción también podemos agregar un bloque Catch para no propagar esta

130
00:12:26,110 --> 00:12:32,590
excepción y la decisión de agregar un bloque cache o propagar la acepción en algunos casos es recomendable

131
00:12:32,590 --> 00:12:38,140
propagar la excepción a la clase que hizo la llamada a nuestros métodos que posiblemente arrojen excepciones

132
00:12:38,370 --> 00:12:44,040
o en otras ocasiones podemos envolver la línea que arroja una excepción en un bloque cazzo.

133
00:12:44,440 --> 00:12:45,480
Así que no es una regla.

134
00:12:45,490 --> 00:12:51,850
Podemos propagar o podemos envolver la excepción y para imprimir toda la pila de excepción podemos utilizar

135
00:12:51,850 --> 00:12:55,410
nuestro objeto de excepción y mandar a llamar el método Prin.

136
00:12:55,420 --> 00:12:58,300
Esta actuáis guardamos cambios y ejecutamos

137
00:13:01,620 --> 00:13:06,710
y podemos observar la pila decepciones en la clase división punto IAVA en la línea Díaz se lanzó la

138
00:13:06,700 --> 00:13:13,750
excepción y también posteriormente se propagó a la clase Maneco decepciones 1.ª IAVA en la línea 10.

139
00:13:13,750 --> 00:13:19,060
Sin embargo el programa continúa sin ningún problema esto solamente es informativo pero nuestro programa

140
00:13:19,060 --> 00:13:22,270
continúa y se ejecuta hasta el final sin ningún problema.

141
00:13:23,440 --> 00:13:28,300
Solamente tachamos esta excepción vamos a dejar hasta aquí este video y en el siguiente video vamos

142
00:13:28,300 --> 00:13:31,450
a ver algunas otras cuestiones del manejo de excepciones.

143
00:13:31,450 --> 00:13:33,490
Nos vemos en el siguiente video saludos.
