Excepciones: marcadas, no marcadas y propias

¡Hola! En la última conferencia, nos familiarizamos con aspectos del lenguaje Java como las excepciones y vimos ejemplos de cómo trabajar con ellas. Hoy veremos más profundamente su estructura y también aprenderemos a escribir nuestras propias excepciones :)

Tipos de excepciones

Como dijimos, hay muchas clases de excepción en Java, ¡casi 400! Pero todos están divididos en grupos, por lo que es bastante fácil recordarlos. Así es como se ve: Todas las excepciones tienen una clase ancestral común Throwable. De él surgen dos grandes grupos: excepciones (Excepción) y errores (Error). El error es un error crítico durante la ejecución del programa asociado con el funcionamiento de la máquina virtual Java. En la mayoría de los casos, no es necesario gestionar el error, ya que indica algunos defectos graves en el código. Los errores más famosos: StackOverflowError- ocurren, por ejemplo, cuando un método se llama a sí mismo sin cesar, y OutOfMemoryError- ocurre cuando no hay suficiente memoria para crear nuevos objetos. Como puede ver, en estas situaciones, la mayoría de las veces no hay nada especial que procesar: el código simplemente está escrito incorrectamente y es necesario rehacerlo. Las excepciones son, de hecho, excepciones: una situación excepcional y no planificada que ocurrió mientras el programa estaba en ejecución. Estos no son errores tan graves como Error, pero requieren nuestra atención. Todas las excepciones se dividen en 2 tipos: marcadas ( marcada ) y no marcadas ( sin marcar ). Todas las excepciones marcadas provienen de Exception. ¿Qué significa "verificable"? Mencionamos esto parcialmente en la última conferencia : "... el compilador de Java conoce las excepciones más comunes y sabe en qué situaciones pueden ocurrir". Por ejemplo, sabe que si un programador lee datos de un archivo en código, fácilmente podría surgir la situación de que el archivo no exista. Y hay muchas situaciones de este tipo que puede predecir de antemano. Por lo tanto, el compilador verifica nuestro código de antemano en busca de posibles excepciones. Si los encuentra, no compilará el código hasta que los procesemos o los enviemos a la parte superior. El segundo tipo de excepción está "sin marcar". Vienen de la clase RuntimeException. ¿En qué se diferencian de los que están siendo evaluados? Parecería que también hay un montón de clases diferentes que provienen RuntimeExceptiony describen excepciones de tiempo de ejecución específicas. La diferencia es que el compilador no espera estos errores. Parece estar diciendo: “Al momento de escribir el código, no encontré nada sospechoso, pero algo salió mal mientras estaba funcionando. ¡Aparentemente hay errores en el código! Y efectivamente lo es. Las excepciones no comprobadas suelen ser el resultado de errores del programador. Y el compilador claramente no puede prever todas las posibles situaciones incorrectas que las personas pueden crear con sus propias manos :) Por lo tanto, no verificará el manejo de tales excepciones en nuestro código. Ya has encontrado varias excepciones no marcadas:

• ArithmeticExceptionocurre cuando se divide por cero
• ArrayIndexOutOfBoundsExceptionOcurre al intentar acceder a una celda fuera del conjunto.

En teoría, por supuesto, los creadores de Java podrían haber introducido el manejo obligatorio de tales excepciones, pero ¿en qué se convertiría entonces el código? Con cualquier operación de división de números, ¿tendrías que escribir un try-catch para comprobar si estás dividiendo accidentalmente por cero? Siempre que acceda a una matriz, deberá escribir un try-catch para comprobar si ha superado estos límites. Cualquier código escrito sería espagueti y completamente ilegible. Es lógico que esta idea fuera abandonada. Por lo tanto, las excepciones no comprobadas no necesitan ser manejadas en bloques try-catch ni lanzadas a la parte superior, aunque esto es técnicamente posible, como ocurre con Error.

Cómo lanzar tu excepción

Por supuesto, los creadores de Java no son capaces de prever todas las situaciones excepcionales que pueden surgir en los programas. Hay demasiados programas en el mundo y son demasiado diferentes. Pero está bien, porque puedes crear tus propias excepciones si es necesario. Esto se hace muy fácilmente. Todo lo que tienes que hacer es crear tu propia clase. Su nombre debe terminar en “Excepción”. El compilador no necesita esto, pero los programadores que lean su código comprenderán inmediatamente que se trata de una clase de excepción. Además, es necesario indicar que la clase proviene de la clase Exception. Esto ya es necesario para el compilador y su correcto funcionamiento. Por ejemplo, tenemos una clase Perro - Dog. Podemos pasear al perro usando el walk(). Pero antes debemos comprobar si nuestra mascota lleva collar, correa y bozal. Si falta alguno de estos, lanzaremos nuestra propia excepción DogIsNotReadyException. Su código se verá así:

public class DogIsNotReadyException extends Exception {

   public DogIsNotReadyException(String message) {
       super(message);
   }
}

Para indicar que una clase es una excepción, es necesario escribir extends Exception después del nombre de la clase: esto significa que "la clase deriva de la clase Exception". En el constructor, simplemente llamaremos al constructor de la clase Exceptioncon una línea message; le mostrará al usuario un mensaje del sistema que describe el error que se ha producido. Así es como se verá en nuestro código de clase:

public class Dog {

   String name;
   boolean isCollarPutOn;
   boolean isLeashPutOn;
   boolean isMuzzlePutOn;

   public Dog(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

   }

   public void putCollar() {

       System.out.println("¡El collar está puesto!");
       this.isCollarPutOn = true;
   }

   public void putLeash() {

       System.out.println("¡La correa está puesta!");
       this.isLeashPutOn = true;
   }

   public void putMuzzle() {
       System.out.println("¡El bozal está encendido!");
       this.isMuzzlePutOn = true;
   }

   public void walk() throws DogIsNotReadyException {

   System.out.println("¡Vamos a caminar!");
   if (isCollarPutOn && isLeashPutOn && isMuzzlePutOn) {
       System.out.println("¡Hurra, vamos a dar un paseo!" + name + " ¡Me alegro!");
   } else {
       throw new DogIsNotReadyException("Perro " + name + "¡No estás listo para dar un paseo! ¡Revisa tu equipo!");
   }
 }

}

Ahora nuestro método walk()arroja una excepción DogIsNotReadyException. Esto se hace usando la palabra clave throw. Como dijimos anteriormente, una excepción es un objeto. Por lo tanto, en nuestro método, cuando ocurre una situación excepcional (al perro le falta algo), creamos un nuevo objeto de clase DogIsNotReadyExceptiony lo lanzamos al programa usando la palabra throw. walk()Agregamos throws a la firma del método DogIsNotReadyException. En otras palabras, el compilador ahora sabe que una llamada a un método walk()puede provocar una excepción. Entonces, cuando llamemos a esto en algún lugar del programa, será necesario manejar la excepción. Intentemos hacer esto en el método main():

public static void main(String[] args) {

   Dog dog = new Dog("Mukhtar");
   dog.putCollar();
   dog.putMuzzle();
   dog.walk();//Unhandled exception: DogIsNotReadyException
}

¡No se compila, excepción no manejada! Envuelva nuestro código en un bloque try-catchpara manejar la excepción:

public static void main(String[] args) {

   Dog dog = new Dog("Mukhtar");
   dog.putCollar();
   dog.putMuzzle();
   try {
       dog.walk();
   } catch (DogIsNotReadyException e) {
       System.out.println(e.getMessage());
       System.out.println("¡Comprobando el equipo! ¿Está puesto el collar?" + dog.isCollarPutOn + "\r\n ¿Está puesta la correa?"
       + dog.isLeashPutOn + "\r\n ¿Llevas puesto un bozal?" + dog.isMuzzlePutOn);
   }
}

Ahora veamos la salida de la consola:

Ошейник надет! 
Намордник надет! 
Собираемся на прогулку! 
Собака Мухтар не готова к прогулке! Проверьте экипировку! 
Проверяем снаряжение! Ошейник надет? true
Поводок надет? false 
Намордник надет? true

¡Mira cuánto más informativo se ha vuelto la salida de la consola! Vemos cada paso que sucedió en el programa; Vemos dónde ocurrió el error e inmediatamente notamos qué es exactamente lo que le falta a nuestro perro :) Así es como creamos nuestras propias excepciones. Como puedes ver, nada complicado. Y aunque los desarrolladores de Java no se molestaron en agregar una excepción especial a su lenguaje para perros mal equipados, corregimos su descuido :)