1
00:00:00,760 --> 00:00:06,620
Hola bienvenidos a este ejemplo 2 del manejo de decepciones bien lo que vamos a trabajar es el diagrama

2
00:00:06,620 --> 00:00:11,080
de clases que estamos observando vamos a retomar el proyecto de interfases que trabajamos.

3
00:00:11,120 --> 00:00:17,180
Acceso a datos con la implementación de Oracle y Maisí y posteriormente lo que vamos a hacer es crear

4
00:00:17,210 --> 00:00:19,860
otro paquete para el manejo de excepciones.

5
00:00:19,880 --> 00:00:25,640
Vamos a crear una clase decepciones llamado acceso datos exception la cual extiende la clase exception

6
00:00:25,960 --> 00:00:33,080
y vamos a crear dos clases hijas escritura datos X y lectura datos X y vamos a simular excepciones al

7
00:00:33,080 --> 00:00:38,990
momento de escribir o leer datos cuando estamos realizando las operaciones de listar o insertar información

8
00:00:39,170 --> 00:00:40,530
en una base de datos.

9
00:00:40,640 --> 00:00:45,350
Pero todo esto va a ser simulado el tema real de manejo de base datos lo vamos a ver en el nivel de

10
00:00:45,350 --> 00:00:50,900
Java con JDBC en este caso vamos a trabajar con el concepto de manejo de excepciones pero vamos a simular

11
00:00:50,900 --> 00:00:56,990
estos ejemplos de escribir o leer información de una base de datos y posteriormente vamos a crear una

12
00:00:56,990 --> 00:01:01,970
clase de prueba manejo de excepciones 2 así que vamos a realizar el siguiente código

13
00:01:06,050 --> 00:01:10,010
vamos a ver nuestro proyecto que ya hemos venido trabajando de manejo de interfaces

14
00:01:12,780 --> 00:01:20,900
cerramos el otro proyecto de manejo de excepciones cerramos todas estas clases y vamos a crear una copia

15
00:01:20,900 --> 00:01:24,740
de este proyecto Manejo de interfaces damos clic derecho copy

16
00:01:28,140 --> 00:01:30,750
y el proyecto se va a llamar manejo excepciones.

17
00:01:30,810 --> 00:01:31,200
2

18
00:01:34,080 --> 00:01:41,090
y lo depositamos en la misma carpeta cursos diagonal Java damos siguen copy y vamos a cambiar el nombre

19
00:01:41,090 --> 00:01:48,950
del proyecto de manejo de acepciones 2 damos el derecho reanime y cambiamos el display NAICM y el artefacto

20
00:01:53,900 --> 00:01:55,340
manejo excepciones 2

21
00:01:58,500 --> 00:02:03,470
y damos siguen Okkhoy y cerramos el nombre del proyecto Manejo interfaces damos clic derecho Clowes

22
00:02:04,430 --> 00:02:10,160
bien y ahora vamos a empezar a crear nuestra clase de decepción sobre son los packages damos el derecho

23
00:02:10,160 --> 00:02:20,630
no ya va a clase y creamos la clase acceso datos X decepción y el nombre del paquete va a hacer excepciones.

24
00:02:20,830 --> 00:02:21,880
Damos clic en Finalizar

25
00:02:26,620 --> 00:02:31,360
posteriormente vamos a crear otra clase dentro de este mismo paquete damos un derecho Nioh a la clase

26
00:02:31,870 --> 00:02:39,790
el nombre de la clase es escritura datos X decepción y la depositamos en el paquete decepciones y damos

27
00:02:39,790 --> 00:02:47,860
fuguen finalizar quitamos estos comentarios y finalmente agregamos la clase de lectura

28
00:02:50,840 --> 00:02:57,160
datos X la depositamos en el mismo paquete y damos en finalizar

29
00:03:01,190 --> 00:03:05,700
y vamos a empezar a modificar estas clases para que esa clase la podamos utilizar dentro del manejo

30
00:03:05,700 --> 00:03:13,820
de excepciones debe descender de la clase exception recordemos que si utilizamos la clase exception

31
00:03:13,820 --> 00:03:18,830
como la clase padre entonces estas clases se conocen como de tipo check exception.

32
00:03:18,890 --> 00:03:24,370
Por lo tanto se debe reportar o agregar un bloque y cache para manejar esas excepciones.

33
00:03:24,620 --> 00:03:31,130
Si no quisiéramos reportar estas decepciones o agregar un bloque Reixach entonces tendríamos que extender

34
00:03:31,220 --> 00:03:37,310
la clase runtime exception ya que la subclases de esta clase se conocen como de tipo un check exception

35
00:03:37,880 --> 00:03:42,310
es decir que no las tenemos que reportar y así nuestro código quedaría más limpio.

36
00:03:42,410 --> 00:03:47,420
Pero en este caso para poner en práctica la sintaxis del manejo de excepciones vamos a dejarla como

37
00:03:47,420 --> 00:03:55,920
de tipo check exception y posteriormente creamos un constructor de esta clase de acceso datos X recibimos

38
00:03:55,920 --> 00:04:04,670
un mensaje y mandamos a llamar al constructor de la clase padre para pasarle este mensaje y con eso

39
00:04:04,670 --> 00:04:07,300
ya construimos correctamente esta clase de excepción.

40
00:04:08,970 --> 00:04:16,110
Posteriormente modificamos esta clase de escritura de datos X que tiene de su clase padre acceso datos

41
00:04:16,530 --> 00:04:23,490
X la cual por extender de la clase acceso a datos X y a su vez esta clase extender decepción entonces

42
00:04:23,490 --> 00:04:30,120
en automático esta clase va a ser de tipo CHEC exception agregamos un constructor de esta clase

43
00:04:33,540 --> 00:04:42,610
recibimos el mensaje y mandamos a llamar el constructor de la clase padre le pasamos el valor de mensaje

44
00:04:43,600 --> 00:04:49,250
y hacemos lo mismo en la clase de lectura datos es Epsom extiende la clase.

45
00:04:49,260 --> 00:04:52,290
Acceso datos X.

46
00:04:52,590 --> 00:04:54,650
Agregamos un constructor de esta clase

47
00:05:01,950 --> 00:05:09,420
y mandamos a llamar el constructor de la clase padre le pasamos el mensaje y con eso ya hemos construido

48
00:05:09,750 --> 00:05:14,870
todas las excepciones que vamos a utilizar en nuestro programa para simular las posibles excepciones

49
00:05:15,060 --> 00:05:17,240
al momento de trabajar con una base de datos.

50
00:05:17,490 --> 00:05:19,670
Pero recordemos que todo esto es simulado.

51
00:05:19,980 --> 00:05:26,220
Ahora vamos a modificar nuestra interfase acceso datos vamos a agregar un método llamado simular error

52
00:05:29,460 --> 00:05:39,490
agregamos el método Public abstract va a ser el tipo bait se llama simular error y recibe un Juliano

53
00:05:41,550 --> 00:05:44,020
para saber si vamos a simular el error o no..

54
00:05:44,250 --> 00:05:48,960
Posteriormente en las clases que implementan esta interface vamos a sobreescribir este método

55
00:05:51,720 --> 00:05:56,190
así que damos clic sobre hacer lo que nos muestran y damos clic para que implemente todos los métodos

56
00:05:56,190 --> 00:06:03,950
abstractos en este caso el método que nos falta de simular error quitamos esta línea de código y agregamos

57
00:06:03,950 --> 00:06:09,720
un atributo privado de tipo volia no llamado simular error

58
00:06:13,440 --> 00:06:20,930
y dentro de este método vamos a inicializar esta variable simular error y agregamos el método G.T.

59
00:06:21,050 --> 00:06:27,080
Recordemos que debido a que es Juliano entonces en lugar de G.T utilizamos is así que agregamos el método

60
00:06:27,110 --> 00:06:29,690
públic bullían es

61
00:06:33,470 --> 00:06:34,430
simular error

62
00:06:39,780 --> 00:06:46,450
y retornamos el atributo simular error y ahora lo que vamos a hacer es que dentro de los métodos insertar

63
00:06:46,540 --> 00:06:55,760
o listar vamos a preguntar en primer lugar si vamos a simular un error así que si se va a simular un

64
00:06:55,760 --> 00:07:02,400
error entonces vamos a reportar la excepción al momento de intentar ejecutar el método de insertar.

65
00:07:02,480 --> 00:07:09,170
Entonces si vamos a simular el error arrojamos un error de escritura de datos para arrojar un error

66
00:07:09,200 --> 00:07:19,460
utilizamos la palabra reservada throw y creamos un nuevo objeto de tipo escritura de datos X y mandamos

67
00:07:19,460 --> 00:07:20,150
el mensaje

68
00:07:24,150 --> 00:07:26,310
Error de escritura de datos

69
00:07:29,230 --> 00:07:31,420
de lo contrario si no vamos a simular este error

70
00:07:38,930 --> 00:07:45,090
entonces simplemente mandamos el mensaje insertar desde Maisí cual importamos esta clase de escritura

71
00:07:45,090 --> 00:07:51,990
de datos exception pero ahora debido a que estamos arrojando una excepción entonces tenemos que reportar

72
00:07:51,990 --> 00:07:55,530
también esta excepción o agregarla en un bloque y cache.

73
00:07:55,560 --> 00:08:01,050
En este momento conviene reportarla para que sepamos dentro de la clase de prueba que vamos a crear

74
00:08:01,310 --> 00:08:07,350
que vamos a arrojar una excepción así que vamos a indicar throws pero tenemos varias opciones podemos

75
00:08:07,350 --> 00:08:10,730
reportar desde la clase padre hasta clases hijas.

76
00:08:11,190 --> 00:08:14,660
Recordemos que la clase padre es exception.

77
00:08:14,940 --> 00:08:20,500
Posteriormente tenemos acceso a datos exception y posteriormente tenemos escritura de datos exception.

78
00:08:20,520 --> 00:08:28,170
Esta es la jerarquía de clases según vimos en el diagrama o M.L así que lo que vamos a hacer es reportar

79
00:08:28,230 --> 00:08:31,950
la clase padre acceso datos exception

80
00:08:34,790 --> 00:08:36,020
importamos esta clase

81
00:08:38,750 --> 00:08:44,390
importamos todas las clases para que podamos acceder pero debido a que estamos ya reportando una decepción

82
00:08:44,630 --> 00:08:48,980
entonces con esto ya estamos rompiendo con la firma del método de la interfase.

83
00:08:48,980 --> 00:08:54,740
Por lo tanto la interface también debe de reportar una posible excepción así que dentro de la interfase

84
00:08:54,800 --> 00:09:00,290
acceso datos en el método insertar vamos a reportar también esta excepción.

85
00:09:01,490 --> 00:09:07,310
Tanto para el método insertar como para el método de listar por ello es que estamos utilizando la clase

86
00:09:07,310 --> 00:09:09,240
padre acceso datos.

87
00:09:09,320 --> 00:09:14,510
También podríamos indicar la clase exception para hacer más genérico nuestro código pero en este momento

88
00:09:14,510 --> 00:09:21,340
es suficiente con la clase padre y posteriormente internamente estamos decidiendo qué tipo de decepción

89
00:09:21,340 --> 00:09:28,280
vamos a arrojar en este caso la acepción escritura datos es Epsom y hacemos lo mismo con el método de

90
00:09:28,280 --> 00:09:31,250
listar vamos a reportar esta excepción de listar

91
00:09:34,240 --> 00:09:36,670
agregamos el código para simular un error

92
00:09:41,890 --> 00:09:43,460
si vamos a simular un error.

93
00:09:43,570 --> 00:09:53,770
Entonces vamos a arrojar una excepción de tipo lectura datos exception y mandamos el mensaje Error de

94
00:09:53,770 --> 00:09:55,540
lectura de datos

95
00:10:01,350 --> 00:10:07,440
de lo contrario si no reportamos esta excepción entonces simplemente mandamos el mensaje listar desde

96
00:10:07,440 --> 00:10:07,960
Maisí cual

97
00:10:12,040 --> 00:10:18,970
aquí me faltó ya que estamos creando un nuevo objeto de tipo exception throw Nioh lectura de datos exception

98
00:10:20,280 --> 00:10:23,910
aquí estamos creando el nuevo objeto y lo estamos lanzando

99
00:10:26,900 --> 00:10:30,500
así que de esta manera ya tenemos completo la implementación de Maisí.

100
00:10:31,040 --> 00:10:35,940
Tenemos que ser estos mismos cambios en la clase de implementación de Oracle.

101
00:10:36,320 --> 00:10:39,860
Así que abrimos esta clase y hacemos los cambios respectivos

102
00:10:42,870 --> 00:10:44,850
vamos a arrojar una excepción de tipo padre

103
00:10:48,960 --> 00:10:54,580
importábamos esta clase agregamos la propiedad de simular error

104
00:11:05,770 --> 00:11:11,110
agregamos también este código para recuperar el atributo de simular error y también para establecer

105
00:11:11,140 --> 00:11:19,210
el valor de simular error y además modificamos los métodos para saber si estamos simulando el error

106
00:11:19,590 --> 00:11:25,730
si arroja la excepción de lo contrario simplemente mandamos el mensaje así que podemos apoyarnos de

107
00:11:25,730 --> 00:11:26,420
este código

108
00:11:32,920 --> 00:11:35,380
pero el mensaje es insertar desde Oracle

109
00:11:38,140 --> 00:11:41,860
para el método de insertar y para el método de listar hacemos lo mismo.

110
00:11:46,180 --> 00:11:47,980
Va a ser listar desde Oracle

111
00:11:51,250 --> 00:11:59,030
importamos estas clases e importamos todo el paquete para que tengamos acceso a todas las clases de

112
00:11:59,060 --> 00:12:02,520
decepciones.

113
00:12:02,820 --> 00:12:09,030
Y con eso ya tenemos toda la modificación a nuestro proyecto y solamente resta crear la clase de prueba

114
00:12:09,240 --> 00:12:13,860
para revisar que funciona correctamente toda la configuración decepciones que hemos agregado a nuestro

115
00:12:13,860 --> 00:12:15,100
proyecto.

116
00:12:15,270 --> 00:12:20,730
La clase de prueba de manejo de interfaces de momento ya no lo vamos a utilizar vamos a dar clic derecho

117
00:12:20,820 --> 00:12:26,950
y borramos todo este paquete bien vamos a dejar hasta aquí este video y en el siguiente video vamos

118
00:12:26,950 --> 00:12:32,250
a crear la prueba para probar cada una de las clases que hemos modificado para el manejo de excepciones.

119
00:12:32,320 --> 00:12:33,680
Nos vemos en el siguiente video.

120
00:12:33,760 --> 00:12:34,360
Saludos.