Hola y bienvenidos a esta elección.
A continuación vamos a ver el primer ejercicio del manejo de excepciones en Java.
Están listos.
Vamos bien como primer paso vamos a hacer cualquier proyecto que tengamos abierto y vamos a crear uno
nuevo.
En fin ni proyecto seleccionamos llama Wild Maybe en Java Application damos sigue Next.
El nombre del proyecto se va a llamar manejo excepciones 1 y lo depositamos en la ruta de cursos Java.
El nombre del grupo hoy día es MX con GM globalmente.
La versión 1.0 y el nombre del paquete lo dejamos vacío.
Damos clic en Finalizar y en esta elección lo que vamos a hacer es crear una clase de división.
Posteriormente vamos a ejecutar una división errónea y lo que vamos a hacer es procesar esta excepción
de la división con valores erróneos así que vamos a hacer lo siguiente Vamos a crear una clase llamada
División damos clic derecho Nioh Java class la clave se llama división y la depositamos en el paquete
de Domain
quitamos los comentarios y de momento va a ser todo lo que vamos a hacer sobre esta clase.
Vamos a agregar una segunda clase que se va a llamar operación excepción
y la depositamos en el mismo paquete en el paquete de Domaine damos clic en Finalizar quitamos estos
comentarios y de momento vamos a dejar hasta aquí este código y para definir una clase que va a manejar
excepciones esta clase debe de extender de alguna de las clases decepción de la jerarquía de clases
de la de acepciones en Java.
La clase padre de todas las clases en Java es la clase voivoda y como subclase de la clase Truyol tenemos
la clase exception así que esta clase va a extender la clase exception.
Ahora vamos a crear un constructor para poder recibir el mensaje de la excepción creamos un constructor
de esta clase
este constructor va a recibir la variable de mensaje que es el mensaje de decepción que vamos a recibir
en esta clase y esta clase lo que va a hacer es mandar a llamar el constructor de la clase padre en
la clase exception y la pasamos el mensaje de la decepción que estamos recibiendo.
Y con eso podemos crear clases personalizadas de excepciones en Java así que ya tenemos nuestra clase
decepción operación decepción vamos ahora a nuestra clase de división y vamos a negar los atributos
el primer atributo va a ser el numerador de la división y el segundo atributo de tipo entero va a ser
el denominador ahora vamos a agregar un constructor de esta clase donde vamos a recibir los dos argumentos
de tipo entero llamado numerador y denominador y para indicar que este constructor puede arrojar una
excepción.
Entonces vamos a utilizar la palabra reservada throws y lo que vamos a hacer te vamos a indicar que
este constructor posiblemente dentro de su código puede arrojar la excepción de operación excepción
así que eso es parte de la firma de los métodos.
Podemos observar el modificador de acceso posteriormente el nombre de la clase ya que es un constructor.
Posteriormente entre paréntesis y separado por los argumentos y finalmente indicamos si este constructor
puede arrojar una excepción o no. Posteriormente agregamos el cuerpo de este constructor y es la firma
de este constructor ahora vamos a revisar si el denominador
es igual a cero entonces quiere decir que es una operación no válida.
Por lo tanto lo que vamos a hacer es arrojar una nueva excepción para arrojar una nueva acepción en
este momento vamos a crear un objeto de tipo exception vamos a utilizar la palabra reservada.
Y lo que vamos a hacer es crear un nuevo objeto de nuestra clase que hemos creado.
Operación excepción.
Así que creamos un nuevo objeto Niu operación excepción y pasamos el mensaje a nuestro constructor según
lo hemos definido vamos a recibir el mensaje de la excepción mandamos el mensaje del error denominador
igual a cero así que con eso estamos arrojando una nueva excepción del tipo de la clase que hemos creado
del tipo excepción para que podamos ejecutarlo según estamos observando en esta línea de código.
Esta clase de operación excepción debe descender de la clase exception.
Si esta clase no hubiera extendido la clase exception entonces el compilador nos marca que no podemos
utilizar esta clase ya que no se puede convertir a un tipo a otro.
Recordemos que la clase destructivos es la clase padre de todas las excepciones en Java y la clase excepción
es una clase hija de la clase Weibo así que no podríamos utilizar esta sintaxis para arrojar una excepción
de la clase operación excepción si esta clase no hubiera extendido de la clase exception.
Así que guardamos cambios para que esto pueda ser válido y con eso ya podemos crear un nuevo objeto
de tipo excepción de tipo Operación excepción y arrojar esta excepción y posteriormente en la firma
del método indicamos que posiblemente se arroje una excepción en dado caso de que el denominador sea
igual a cero.
Si el denominador es diferente de cero entonces esta acepción no se arrojaría bien y si no entramos
Essays entonces continuamos con el constructor inicializar los los atributos de nuestra clase
con los argumentos que estamos recibiendo en este constructor inicializar los el numerador y el denominador
para poder realizar la operación de división.
Y finalmente agregamos un método que no va a regresar nada llamado visualizar operación
y mandamos simplemente a consola el resultado de la división es y dividimos el numerador entre el denominador.
Por ello es que el denominador no puede ser 0 y si fuera 0 desde la construcción de este objeto división
entonces general haríamos esta excepción indicando al usuario que tenemos problemas para crear este
objeto de división.
Si el denominador es igual a cero.
Por lo tanto al momento de visualizar la operación esta operación ya debería de ser válida ya que el
denominador no puede ser igual a cero.
Eso es todo el código respecto a nuestra clase división.
Ahora vamos a crear una clase para poner a prueba esto sobre sus packages derecho new Java class el
nombre de la clase se llama manejo excepciones 1 y el nombre del paquete se va a llamar test y damos
clic en Finalizar quitamos estos comentarios agregamos un método main Public sati Main.
Ahora vamos a poner a prueba nuestra clase Division.
Vamos a crear un nuevo objeto de esta clase.
Y le pasamos los valores de 10 en el numerador y vamos a poner a prueba la excepción vamos a pasar el
denominador igual a cero.
Importamos esta clase de división y podemos observar que el compilador en este caso el IDE nos está
indicando que el constructor posiblemente pueda arrojar una excepción.
Por lo tanto tenemos dos opciones podemos propagar la excepción utilizando la palabra reservada throws.
Vamos a ver si damos clic sobre esto que sucede podemos observar que el método main además de la firma
del método que ya hemos venido trabajando se le ha agregado que este método posiblemente pueda arrojar
la acepción de operación excepción la misma que arroja este constructor de división.
Así que con esto lo que estamos haciendo es propagar esta excepción y en la consola en dado caso de
que suceda alguna excepción entonces se va a visualizar este error vamos a guardar cambios y vamos a
ejecutar
y podemos observar que se está lanzando una excepción debido a que el denominador es igual a cero así
que se manda el mensaje y posteriormente se arroja la excepción el compilador nos indica dónde está
el problema.
En este caso en la clase división punto Java en la línea 10 y también dentro de la clase manejo decepciones
1.La va en la línea 9 y si damos clic aquí nos lleva a la línea donde está el error.
Así que aquí es donde se lanzó la excepción denominador igual a cero
y en la parte inferior podemos observar lo que se conoce como la pila decepciones todas estas líneas
que nos arrojan se conoce como el log o bitácora de error o la pila de errores y podemos ver también
que la construcción del proyecto falló bien así que de esta manera estamos arrojando la excepción ya
que el denominador fue igual a cero sin embargo esta es una manera en la cual estamos propagando la
excepción vamos a manejar otra manera para que nuestro programa no termine de manera abrupta entonces
lo que vamos a hacer no es propagar la excepción sino que lo que vamos a hacer es envolver esa excepción
en un bloque Trui y Cacho así que la segunda opción válida que nos muestran nos indica que podemos envolver
esta línea de código en un bloque y cache vamos a dar click y Podemos se va la sintaxis no se agrega
el bloque try.
Posteriormente abre llaves para inicializar el bloque de código y posteriormente dentro de este bloque
de código tenemos la línea de código que posiblemente lanza esta excepción.
Posteriormente cerramos este bloque de código y agregamos la palabra reservada cache y dentro de los
paréntesis indicamos la posible excepción que pueda arrojar esta línea de código la cual estamos envolviendo
con el bloque cazzo definimos el tipo de la variable el nombre de la variable en este caso se llama
X decepción y aunque nos Sarea esta línea de código de momento no lo vamos a utilizar.
Vamos a quitar esta línea y también quitamos estos importes.
De momento esos import no los vamos a utilizar y con la variable x lo que podemos hacer es solicitar
el mensaje de la excepción así que en dado caso de que ocurra una excepción entonces esta línea ya no
va a terminar de manera abrupta ya no va a propagar la excepción sino que el bloque y cache.
Precisamente lo que va a hacer es interceptar el error que se lance debido a esta línea de código.
Aquí es donde se hace el caché de la excepción y posteriormente podemos ejecutar algún código para mostrar
por ejemplo en este caso cuál fue la excepción pero que ya no termina de manera abrupta este código
sino que pueda continuar con las siguientes líneas de código.
Guardamos cambios y ejecutamos
y podemos observar que nuestro código sea ejecutado de manera correcta se ha terminado de ejecutar vamos
a mandar a consola este mensaje para que podamos visualizarlo
guardamos cambios y ejecutamos
y podemos observar el error.
El error fue denominador igual a cero que fue precisamente el error que arrojamos en esa línea de código
debido a que el denominador fue igual a cero en la llamada.
A este constructor pero en este momento ya podríamos continuar con otras líneas de código
el programa continúa.
Guardamos cambios y ejecutamos y podemos observar que simplemente el programa continúa ya no termina
de manera anormal así que aunque Podemos propagar esta excepción indicando en el método main que vamos
a arrojar posiblemente esta excepción también podemos agregar un bloque Catch para no propagar esta
excepción y la decisión de agregar un bloque cache o propagar la acepción en algunos casos es recomendable
propagar la excepción a la clase que hizo la llamada a nuestros métodos que posiblemente arrojen excepciones
o en otras ocasiones podemos envolver la línea que arroja una excepción en un bloque cazzo.
Así que no es una regla.
Podemos propagar o podemos envolver la excepción y para imprimir toda la pila de excepción podemos utilizar
nuestro objeto de excepción y mandar a llamar el método Prin.
Esta actuáis guardamos cambios y ejecutamos
y podemos observar la pila decepciones en la clase división punto IAVA en la línea Díaz se lanzó la
excepción y también posteriormente se propagó a la clase Maneco decepciones 1.ª IAVA en la línea 10.
Sin embargo el programa continúa sin ningún problema esto solamente es informativo pero nuestro programa
continúa y se ejecuta hasta el final sin ningún problema.
Solamente tachamos esta excepción vamos a dejar hasta aquí este video y en el siguiente video vamos
a ver algunas otras cuestiones del manejo de excepciones.
Nos vemos en el siguiente video saludos.