1
00:00:00,920 --> 00:00:04,200
Bien vamos a continuar con nuestra aplicación de manejo de excepciones 2

2
00:00:07,150 --> 00:00:07,990
sobre sus paquetes.

3
00:00:07,990 --> 00:00:12,470
Vamos a dar clic derecho nio ya la clase y vamos a crear la clase.

4
00:00:12,700 --> 00:00:21,310
Manejo excepciones 2 y la depositamos en el paquete de texto y damos clic en Finalizar quitamos estos

5
00:00:21,310 --> 00:00:28,330
comentarios agregamos un método main y vamos a crear la siguiente variable.

6
00:00:30,200 --> 00:00:34,970
Una variable de tipo acceso datos que es el tipo de interface y lo vamos a asignar a un objeto de tipo

7
00:00:34,990 --> 00:00:36,180
implementación Maisí.

8
00:00:45,230 --> 00:00:46,580
Importamos estas clases

9
00:00:49,210 --> 00:00:55,700
debido a que vamos a usar varias clases ponemos punto asterisco y ya tenemos acceso a todas estas clases.

10
00:00:55,780 --> 00:01:02,530
Ahora vamos a cambiar el estado del simulador error verdadero así que mandamos a llamar el método simular

11
00:01:02,560 --> 00:01:07,370
error y le ponemos el valor de verdadero el valor de True.

12
00:01:07,530 --> 00:01:12,960
Ahora vamos a crear un método para simular la ejecución de alguna operación utilizando algunos de los

13
00:01:12,960 --> 00:01:18,240
objetos que implementan la interface ya sea la implementación de Maisí o de Oracle así que vamos a crear

14
00:01:18,270 --> 00:01:25,860
el método ejecutar le vamos a pasar el objeto de datos y le pasamos la operación que queremos ejecutar.

15
00:01:25,980 --> 00:01:33,720
En este caso queremos ejecutar la operación de listar y vamos a crear este método agregamos el método

16
00:01:33,720 --> 00:01:43,480
Privat Static no regresa nada es de tipo Void se llama ejecutar y va a recibir un objeto de tipo interface

17
00:01:45,260 --> 00:01:47,220
para hacerlo lo más genérico posible.

18
00:01:47,270 --> 00:01:52,520
También se llama datos y recibe un string con la acción a ejecutar

19
00:01:56,350 --> 00:02:01,210
y ahora lo que hacemos es que vamos a comprobar el tipo de acción que se quiere ejecutar.

20
00:02:01,600 --> 00:02:08,350
Así que preguntamos si lo que se desea es ejecutar la acción de listar si listar es igual a la acción

21
00:02:08,350 --> 00:02:12,010
que se ha proporcionado entonces se va a ejecutar cierto código.

22
00:02:12,220 --> 00:02:21,340
De lo contrario preguntamos si se desea ejecutar por ejemplo la acción de insertar si la acción es igual

23
00:02:21,370 --> 00:02:28,980
a insertar entonces se va a ejecutar cierto código de lo contrario si no coincide en ninguno de los

24
00:02:28,980 --> 00:02:38,670
otros casos Entonces mandamos a imprimir el mensaje no se proporcionó ninguna acción conocida bien y

25
00:02:38,680 --> 00:02:42,850
ahora en la parte del código para listar lo que vamos a hacer es mandar a llamar.

26
00:02:42,850 --> 00:02:48,760
El método de listar del objeto que hemos recibido y en el caso de insertar vamos a hacer lo mismo se

27
00:02:48,760 --> 00:02:52,910
manda llamar el método de insertar ya que se ha seleccionado esta acción.

28
00:02:53,050 --> 00:02:58,390
Sin embargo debido a que estos métodos pueden arrojar una excepción entonces el compilador nos está

29
00:02:58,390 --> 00:03:03,920
indicando que debemos de reportar esta excepción o envolverla en un bloque y cazzo.

30
00:03:04,090 --> 00:03:09,130
En este caso vamos a envolverla para poner en práctica lo que hemos hecho hasta el momento pero también

31
00:03:09,130 --> 00:03:15,030
si no queremos envolverla en un bloque troikas simplemente podríamos reportarla bien así que envolvemos

32
00:03:15,240 --> 00:03:20,470
esta acepción en un bloque Cazzo y podemos observar que el método de listar ya está envuelto en un bloque

33
00:03:20,750 --> 00:03:27,270
y cazzo quitamos esta línea de código y podemos observar que la excepción que se está procesando es

34
00:03:27,270 --> 00:03:34,380
la excepción padre acceso datos exception ya que es la excepción que indicamos en los métodos de la

35
00:03:34,380 --> 00:03:39,660
interfase es la excepción que se va a reportar pero internamente estos métodos de insertar y de listar

36
00:03:40,980 --> 00:03:46,860
como podemos observar arrojan un tipo de excepción hija bien se podría manejar una sola acepción pero

37
00:03:46,860 --> 00:03:52,500
es común en Java que tengamos una jerarquía de clases y así poder separar y clasificar cada una de las

38
00:03:52,500 --> 00:03:54,870
clases de excepción de mejor manera.

39
00:03:54,870 --> 00:04:00,420
Ahora si revisamos la implementación por ejemplo de mi ciclo de oración en el método de listar

40
00:04:03,690 --> 00:04:09,510
podemos observar que se está arrojando internamente la excepción de lectura datos exception así que

41
00:04:09,540 --> 00:04:15,410
internamente también aquí en el jazz podríamos procesar no la acepción genérica sino podríamos empezar

42
00:04:15,420 --> 00:04:21,480
procesando la decepción de menor jerarquía esto debido a que un bloque try catch puede procesar varios

43
00:04:21,480 --> 00:04:24,610
bloques Gazza y al final podemos agregar el bloque final.

44
00:04:25,020 --> 00:04:29,910
Así que vamos a agregar varios bloques cazzo pero si vamos a procesar varias excepciones ya están relacionadas

45
00:04:29,910 --> 00:04:30,760
entre ellas.

46
00:04:30,780 --> 00:04:36,500
Entonces primero debemos de procesar la decepción de menor jerarquía es decir las decepciones hijas.

47
00:04:36,630 --> 00:04:44,770
Así que agregamos lo siguiente vamos a agregar otra excepción hija y la primera excepción que vamos

48
00:04:44,770 --> 00:04:47,110
a tratar de procesar cuando mandemos a llamar.

49
00:04:47,110 --> 00:04:53,620
El método de listar es lectura datos exception vamos a importar esta clase

50
00:04:56,510 --> 00:05:00,950
importamos todo el paquete para que podamos utilizar cualquiera de estas clases.

51
00:05:00,970 --> 00:05:03,480
Estas clases ya no los vamos a utilizar vamos a quitarlas.

52
00:05:04,330 --> 00:05:09,000
Bien así que podemos observar que en dado caso de que este método de listar lanza alguna excepción primero

53
00:05:09,000 --> 00:05:15,360
vamos a comenzar procesando las decepciones de menor jerarquía y si se ha procesado esta excepción podemos

54
00:05:15,360 --> 00:05:19,730
mandar un mensaje error de lectura.

55
00:05:19,730 --> 00:05:25,040
Esto es debido a que si invertimos y ponemos primero la excepción de mayor jerarquía entonces ya no

56
00:05:25,040 --> 00:05:30,080
va a procesar las excepciones de menor jerarquía por lo tanto si vamos a procesar varias excepciones

57
00:05:30,260 --> 00:05:37,680
como hemos comentado primero debemos poner las excepciones de menor jerarquía y posteriormente si estamos

58
00:05:37,680 --> 00:05:42,930
procesando la excepción padre entonces ya no fue un error tan detallado como el error de lectura sino

59
00:05:42,930 --> 00:05:45,960
simplemente es un error de acceso a datos.

60
00:05:46,050 --> 00:05:51,390
Pero ya no tenemos el detalle de esa opción de lectura sino solamente un error de acceso a datos es

61
00:05:51,390 --> 00:05:55,950
un error más genérico e incluso podríamos continuar procesando excepciones.

62
00:05:55,950 --> 00:06:03,600
Ahora podríamos procesar una excepción todavía más genérica como lo es la excepción de tipo exception

63
00:06:05,890 --> 00:06:10,600
esto en caso de que no se haya lanzado ninguna de esas excepciones sino que sea lanzado otro tipo de

64
00:06:10,600 --> 00:06:18,590
decepción y en este caso indicamos que ocurrió un error general pero ya no tenemos el detalle si fue

65
00:06:18,590 --> 00:06:26,240
de acceso a datos o si fue lectura de datos y además como parte de esta revisión podemos agregar el

66
00:06:26,240 --> 00:06:31,160
bloque finalice este bloque final y siempre se va a ejecutar independientemente de que ocurra algún

67
00:06:31,160 --> 00:06:34,910
error o no sin embargo procesar Farinelli es opcional

68
00:06:45,620 --> 00:06:50,630
es opcional pero siempre se va a ejecutar así que simplemente es para que podamos observar cómo es que

69
00:06:50,630 --> 00:06:53,110
estamos procesando cada una de las excepciones.

70
00:06:53,150 --> 00:06:58,070
Bien podríamos quedarnos por ejemplo con la acepción más genérica o por ejemplo también con la excepción

71
00:06:58,130 --> 00:07:02,140
más específica ya es decisión nuestra qué tipo de acepción queremos procesar.

72
00:07:02,330 --> 00:07:08,270
Si a nivel más genérico o más detallado y también el bloque final es opcional podemos utilizarlo o no.

73
00:07:08,630 --> 00:07:13,160
Normalmente se utiliza este bloque final para cerrar por ejemplo alguna conexión a base de datos que

74
00:07:13,160 --> 00:07:19,310
tengamos abierta pero es opcional utilizar este bloque de código bien vamos a hacer lo mismo en la llamada

75
00:07:19,460 --> 00:07:20,920
al método de listar.

76
00:07:21,350 --> 00:07:23,290
Vamos a envolverlo en un bloque catch

77
00:07:26,660 --> 00:07:31,650
y en este caso vamos a dejarlo genérico únicamente vamos a procesar la acepción de acceso datos exception

78
00:07:34,550 --> 00:07:41,300
y mandamos el mensaje esa opción de acceso a datos agregamos el bloque final y

79
00:07:44,880 --> 00:07:47,580
de igual manera procesar este bloque es opcional

80
00:07:53,780 --> 00:08:02,890
quitamos estas líneas de código y en cada uno de los casos podemos mandar a imprimir el mensaje o por

81
00:08:02,890 --> 00:08:06,430
ejemplo la pila decepciones como lo hemos hecho anteriormente.

82
00:08:06,430 --> 00:08:08,740
En este caso simplemente vamos a mandar a imprimir la pila

83
00:08:19,530 --> 00:08:21,620
y el iDEN nos marca un warning.

84
00:08:21,960 --> 00:08:28,080
En este caso el warning nos indica que debemos de remover la impresión del esta actuáis pero si lo mandamos

85
00:08:28,080 --> 00:08:28,890
a la consola

86
00:08:31,760 --> 00:08:33,990
entonces ya nos quita este warning.

87
00:08:34,280 --> 00:08:41,490
Simplemente estamos indicando que la excepción en dado caso de que ocurra se mande a la consola

88
00:08:44,800 --> 00:08:46,240
hacemos lo mismo en este método

89
00:08:49,940 --> 00:08:52,410
y con eso ya tenemos todo el código que necesitamos.

90
00:08:52,410 --> 00:08:57,030
Como hemos comentado en este método de insertar también podemos procesar cada una de las excepciones

91
00:08:57,300 --> 00:08:59,770
desde la más específica hasta la más genérica.

92
00:08:59,790 --> 00:09:04,680
Sin embargo en este caso vamos a dejarlo simplemente con este código para que también vean la diferencia

93
00:09:04,860 --> 00:09:06,230
pero ya es decisión nuestra.

94
00:09:06,270 --> 00:09:08,230
Qué tipo de opciones queremos procesar.

95
00:09:09,570 --> 00:09:15,720
Así que con esto mandamos a llamar el método ejecutar hemos indicado que si vamos a simular un error

96
00:09:15,870 --> 00:09:22,160
por lo tanto se debería de lanzar una excepción de tipo lectura datos exception cuando mandemos a llamar.

97
00:09:22,170 --> 00:09:25,410
El método de listar así que guardamos cambios y ejecutamos

98
00:09:37,310 --> 00:09:42,830
y podemos ver que hemos entrado al detalle de error lectura ya no se ha ejecutado ningún otro bloque

99
00:09:43,040 --> 00:09:48,860
catch sino que en este caso únicamente se ejecutó este bloque cache y de aquí pasa directamente al bloque

100
00:09:48,860 --> 00:09:49,910
final.

101
00:09:50,150 --> 00:09:55,310
De todas maneras cualquier detalle con esto pueden ejecutarlo paso a paso pero básicamente lo que hizo

102
00:09:55,520 --> 00:09:59,170
fue que entró a este detalle ya que es el tipo de sección que se lanzó.

103
00:09:59,270 --> 00:10:04,970
Se ejecuta estas líneas de código y de aquí pasa directamente al bloque final y es todo lo que hace

104
00:10:05,000 --> 00:10:12,960
este código así que se manda el mensaje error de lectura se manda imprimir el error de lectura de datos

105
00:10:13,440 --> 00:10:17,040
y la pila de excepciones indicando dónde está el problema

106
00:10:22,070 --> 00:10:25,730
bien así que ya está funcionando correctamente nuestra simulación de error.

107
00:10:25,730 --> 00:10:32,510
Si cambiamos por ejemplo la bandera a falso para que no se simule un error entonces ya no hay ningún

108
00:10:32,510 --> 00:10:39,260
problema en ejecutar el método de listar se manda el mensaje de listar desde igual y se ejecuta el bloque

109
00:10:39,260 --> 00:10:39,930
final.

110
00:10:40,100 --> 00:10:44,900
Como hemos comentado el bloque final siempre se va a ejecutar independientemente que se lance una excepción

111
00:10:44,930 --> 00:10:51,560
o no cualquier duda pueden ejecutar eso también paso a paso bien y por último vamos a poner a prueba

112
00:10:51,860 --> 00:10:53,100
la implementación de Oracle

113
00:10:57,190 --> 00:10:58,630
creamos la variable datos dos

114
00:11:02,590 --> 00:11:04,540
creamos el objeto de implementación de Oracle

115
00:11:11,920 --> 00:11:18,760
y la variable datos los indicamos que sí vamos a simular un error y mandamos a llamar el método de ejecutar

116
00:11:19,480 --> 00:11:28,510
le pasamos la variable datos dos y vamos a simular el método de insertar y punto y coma.

117
00:11:28,910 --> 00:11:32,390
Y con eso ya tenemos todo nuestro código guardamos cambios y ejecutamos

118
00:11:35,890 --> 00:11:41,260
y podemos ver que en este caso estamos simulando un error al momento de insertar un registro simulando

119
00:11:41,260 --> 00:11:46,810
la inserción de un registro se manda a acepción de acceso datos ya que es la acepción más genérica que

120
00:11:46,810 --> 00:11:51,880
hemos procesado en este caso no procesamos la acepción más específica pero bien podríamos hacerlo también

121
00:11:52,280 --> 00:11:59,360
y posteriormente se manda el mensaje error de escritura de datos y la pila de excepciones también se

122
00:11:59,360 --> 00:12:06,440
procesa lo que finalice independientemente de que ocurra algún error o no. Ahora si cambiamos la bandera

123
00:12:07,400 --> 00:12:14,490
para que no se lance ningún error guardamos cambios y ejecutamos y podemos observar que se procesa correctamente

124
00:12:14,490 --> 00:12:20,650
el método insertar desde Oracle y se ejecuta el bloque final así que con esto hemos puesto en práctica

125
00:12:20,650 --> 00:12:23,410
cada uno de los conceptos que más vamos a estar trabajando.

126
00:12:23,410 --> 00:12:29,230
Cuando manejamos el tema de secciones en Java bien eso es todo esta elección y nos vemos en el siguiente

127
00:12:29,230 --> 00:12:29,770
vídeo.

128
00:12:29,830 --> 00:12:30,490
Saludos.