Hola bienvenidos a este ejemplo 2 del manejo de decepciones bien lo que vamos a trabajar es el diagrama
de clases que estamos observando vamos a retomar el proyecto de interfases que trabajamos.
Acceso a datos con la implementación de Oracle y Maisí y posteriormente lo que vamos a hacer es crear
otro paquete para el manejo de excepciones.
Vamos a crear una clase decepciones llamado acceso datos exception la cual extiende la clase exception
y vamos a crear dos clases hijas escritura datos X y lectura datos X y vamos a simular excepciones al
momento de escribir o leer datos cuando estamos realizando las operaciones de listar o insertar información
en una base de datos.
Pero todo esto va a ser simulado el tema real de manejo de base datos lo vamos a ver en el nivel de
Java con JDBC en este caso vamos a trabajar con el concepto de manejo de excepciones pero vamos a simular
estos ejemplos de escribir o leer información de una base de datos y posteriormente vamos a crear una
clase de prueba manejo de excepciones 2 así que vamos a realizar el siguiente código
vamos a ver nuestro proyecto que ya hemos venido trabajando de manejo de interfaces
cerramos el otro proyecto de manejo de excepciones cerramos todas estas clases y vamos a crear una copia
de este proyecto Manejo de interfaces damos clic derecho copy
y el proyecto se va a llamar manejo excepciones.
2
y lo depositamos en la misma carpeta cursos diagonal Java damos siguen copy y vamos a cambiar el nombre
del proyecto de manejo de acepciones 2 damos el derecho reanime y cambiamos el display NAICM y el artefacto
manejo excepciones 2
y damos siguen Okkhoy y cerramos el nombre del proyecto Manejo interfaces damos clic derecho Clowes
bien y ahora vamos a empezar a crear nuestra clase de decepción sobre son los packages damos el derecho
no ya va a clase y creamos la clase acceso datos X decepción y el nombre del paquete va a hacer excepciones.
Damos clic en Finalizar
posteriormente vamos a crear otra clase dentro de este mismo paquete damos un derecho Nioh a la clase
el nombre de la clase es escritura datos X decepción y la depositamos en el paquete decepciones y damos
fuguen finalizar quitamos estos comentarios y finalmente agregamos la clase de lectura
datos X la depositamos en el mismo paquete y damos en finalizar
y vamos a empezar a modificar estas clases para que esa clase la podamos utilizar dentro del manejo
de excepciones debe descender de la clase exception recordemos que si utilizamos la clase exception
como la clase padre entonces estas clases se conocen como de tipo check exception.
Por lo tanto se debe reportar o agregar un bloque y cache para manejar esas excepciones.
Si no quisiéramos reportar estas decepciones o agregar un bloque Reixach entonces tendríamos que extender
la clase runtime exception ya que la subclases de esta clase se conocen como de tipo un check exception
es decir que no las tenemos que reportar y así nuestro código quedaría más limpio.
Pero en este caso para poner en práctica la sintaxis del manejo de excepciones vamos a dejarla como
de tipo check exception y posteriormente creamos un constructor de esta clase de acceso datos X recibimos
un mensaje y mandamos a llamar al constructor de la clase padre para pasarle este mensaje y con eso
ya construimos correctamente esta clase de excepción.
Posteriormente modificamos esta clase de escritura de datos X que tiene de su clase padre acceso datos
X la cual por extender de la clase acceso a datos X y a su vez esta clase extender decepción entonces
en automático esta clase va a ser de tipo CHEC exception agregamos un constructor de esta clase
recibimos el mensaje y mandamos a llamar el constructor de la clase padre le pasamos el valor de mensaje
y hacemos lo mismo en la clase de lectura datos es Epsom extiende la clase.
Acceso datos X.
Agregamos un constructor de esta clase
y mandamos a llamar el constructor de la clase padre le pasamos el mensaje y con eso ya hemos construido
todas las excepciones que vamos a utilizar en nuestro programa para simular las posibles excepciones
al momento de trabajar con una base de datos.
Pero recordemos que todo esto es simulado.
Ahora vamos a modificar nuestra interfase acceso datos vamos a agregar un método llamado simular error
agregamos el método Public abstract va a ser el tipo bait se llama simular error y recibe un Juliano
para saber si vamos a simular el error o no..
Posteriormente en las clases que implementan esta interface vamos a sobreescribir este método
así que damos clic sobre hacer lo que nos muestran y damos clic para que implemente todos los métodos
abstractos en este caso el método que nos falta de simular error quitamos esta línea de código y agregamos
un atributo privado de tipo volia no llamado simular error
y dentro de este método vamos a inicializar esta variable simular error y agregamos el método G.T.
Recordemos que debido a que es Juliano entonces en lugar de G.T utilizamos is así que agregamos el método
públic bullían es
simular error
y retornamos el atributo simular error y ahora lo que vamos a hacer es que dentro de los métodos insertar
o listar vamos a preguntar en primer lugar si vamos a simular un error así que si se va a simular un
error entonces vamos a reportar la excepción al momento de intentar ejecutar el método de insertar.
Entonces si vamos a simular el error arrojamos un error de escritura de datos para arrojar un error
utilizamos la palabra reservada throw y creamos un nuevo objeto de tipo escritura de datos X y mandamos
el mensaje
Error de escritura de datos
de lo contrario si no vamos a simular este error
entonces simplemente mandamos el mensaje insertar desde Maisí cual importamos esta clase de escritura
de datos exception pero ahora debido a que estamos arrojando una excepción entonces tenemos que reportar
también esta excepción o agregarla en un bloque y cache.
En este momento conviene reportarla para que sepamos dentro de la clase de prueba que vamos a crear
que vamos a arrojar una excepción así que vamos a indicar throws pero tenemos varias opciones podemos
reportar desde la clase padre hasta clases hijas.
Recordemos que la clase padre es exception.
Posteriormente tenemos acceso a datos exception y posteriormente tenemos escritura de datos exception.
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
la clase padre acceso datos exception
importamos esta clase
importamos todas las clases para que podamos acceder pero debido a que estamos ya reportando una decepción
entonces con esto ya estamos rompiendo con la firma del método de la interfase.
Por lo tanto la interface también debe de reportar una posible excepción así que dentro de la interfase
acceso datos en el método insertar vamos a reportar también esta excepción.
Tanto para el método insertar como para el método de listar por ello es que estamos utilizando la clase
padre acceso datos.
También podríamos indicar la clase exception para hacer más genérico nuestro código pero en este momento
es suficiente con la clase padre y posteriormente internamente estamos decidiendo qué tipo de decepción
vamos a arrojar en este caso la acepción escritura datos es Epsom y hacemos lo mismo con el método de
listar vamos a reportar esta excepción de listar
agregamos el código para simular un error
si vamos a simular un error.
Entonces vamos a arrojar una excepción de tipo lectura datos exception y mandamos el mensaje Error de
lectura de datos
de lo contrario si no reportamos esta excepción entonces simplemente mandamos el mensaje listar desde
Maisí cual
aquí me faltó ya que estamos creando un nuevo objeto de tipo exception throw Nioh lectura de datos exception
aquí estamos creando el nuevo objeto y lo estamos lanzando
así que de esta manera ya tenemos completo la implementación de Maisí.
Tenemos que ser estos mismos cambios en la clase de implementación de Oracle.
Así que abrimos esta clase y hacemos los cambios respectivos
vamos a arrojar una excepción de tipo padre
importábamos esta clase agregamos la propiedad de simular error
agregamos también este código para recuperar el atributo de simular error y también para establecer
el valor de simular error y además modificamos los métodos para saber si estamos simulando el error
si arroja la excepción de lo contrario simplemente mandamos el mensaje así que podemos apoyarnos de
este código
pero el mensaje es insertar desde Oracle
para el método de insertar y para el método de listar hacemos lo mismo.
Va a ser listar desde Oracle
importamos estas clases e importamos todo el paquete para que tengamos acceso a todas las clases de
decepciones.
Y con eso ya tenemos toda la modificación a nuestro proyecto y solamente resta crear la clase de prueba
para revisar que funciona correctamente toda la configuración decepciones que hemos agregado a nuestro
proyecto.
La clase de prueba de manejo de interfaces de momento ya no lo vamos a utilizar vamos a dar clic derecho
y borramos todo este paquete bien vamos a dejar hasta aquí este video y en el siguiente video vamos
a crear la prueba para probar cada una de las clases que hemos modificado para el manejo de excepciones.
Nos vemos en el siguiente video.
Saludos.