En la vida cotidiana a veces surgen situaciones que no habíamos previsto. Por ejemplo, te levantas por la mañana para ir a trabajar, buscas un cargador para tu teléfono, pero no lo hay. Vas al baño a lavarte la cara; han cerrado el agua. Me subí al auto y no arranca. Pero una persona puede afrontar situaciones tan imprevistas con bastante facilidad. Intentaremos descubrir cómo los tratan los programas Java en este artículo.
¿Cuáles son las excepciones de Java?
En el mundo de la programación, la aparición de errores y situaciones inesperadas durante la ejecución de un programa se denomina excepción. En un programa, pueden ocurrir excepciones como resultado de acciones incorrectas del usuario, falta de un recurso necesario en el disco o pérdida de conexión con el servidor a través de la red. Las excepciones durante la ejecución del programa también pueden deberse a errores de programación o al uso incorrecto de la API. A diferencia de nuestro mundo, el programa debe saber claramente qué hacer en tal situación. Java proporciona un mecanismo de excepción para este propósito.
Brevemente sobre las palabras clave intentar, atrapar, finalmente, lanzar
El manejo de excepciones en Java se basa en el uso de las siguientes palabras clave en el programa:
- try: define un bloque de código en el que puede ocurrir una excepción;
- catch: define el bloque de código en el que se maneja la excepción;
- finalmente: define un bloque de código que es opcional, pero si está presente, se ejecuta de todos modos, independientemente de los resultados del bloque try.
Estas palabras clave se utilizan para crear construcciones de procesamiento especiales en el código del programa: try{}catch, try{}catch{}finally, try{}finally{}.
- throw – usado para generar una excepción;
- throws: se utiliza en firmas de métodos para advertir que el método puede generar una excepción.
Un ejemplo de uso de palabras clave en un programa Java:
public String input() throws MyException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String s = null;
try {
s = reader.readLine();
} catch (IOException e) {
System.out.println(e.getMessage());
} finally {
try {
reader.close();
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
if (s.equals("")) {
throw new MyException("String can not be empty!");
}
return s;
}
¿Por qué necesitamos un mecanismo de excepción?
Veamos un ejemplo del mundo real. Imaginemos que hay un tramo de una carretera con un puente de emergencia con capacidad de carga limitada. Si un vehículo con una masa superior a la capacidad de carga del puente lo cruza, éste puede colapsar y la situación para el conductor puede llegar a ser, por decirlo suavemente, excepcional. Para evitar que esto suceda, el servicio de carreteras instala previamente señales de advertencia en la carretera. El conductor del coche, mirando la señal de advertencia, comparará el peso de su coche con el permitido para circular por el puente. Si lo supera, tomará un desvío. Gracias a las actuaciones del servicio de carreteras, los camioneros, en primer lugar, tuvieron la oportunidad de cambiar de ruta con antelación, en segundo lugar, se les advirtió sobre el peligro en la ruta principal y, finalmente, se les advirtió sobre la imposibilidad de utilizar el puente bajo ciertas condiciones.
La capacidad de prevenir y resolver una excepción en un programa para que pueda continuar es una de las razones para usar excepciones en Java. El mecanismo de excepción también le permite proteger el código que escribe (interfaz de programación) del mal uso por parte del usuario al validar (verificar) los datos entrantes. Ahora seamos policías de tránsito por un segundo. En primer lugar, conviene conocer los lugares donde los automovilistas pueden meterse en problemas. En segundo lugar, es necesario preparar e instalar señales de advertencia. Por último, es necesario prever rutas de desvío en caso de peligro en la ruta principal. En Java, el mecanismo de excepción funciona de forma similar. En la etapa de desarrollo del programa, "protegemos" secciones peligrosas de código de excepciones usando el bloque try{}, proporcionamos rutas de "respaldo" usando el bloque catch{} y en el bloque finalmente{} escribimos el código que se ejecuta en el programa para cualquier resultado. En los casos en los que no podamos proporcionar una “ruta de emergencia” o queramos deliberadamente dejar la elección al usuario, al menos debemos advertirle del peligro. ¿Por qué? ¡Imagínese la indignación de un conductor que llega a un puente de emergencia que no se puede cruzar sin encontrar una sola señal de advertencia en el camino! En programación, al escribir nuestras clases y métodos, no siempre podemos prever el contexto de su uso por parte de otros desarrolladores en sus programas, por lo que no podemos prever la ruta 100% correcta para resolver la situación de excepción. Al mismo tiempo, es una buena práctica advertir a los usuarios de nuestro código sobre la posibilidad de una excepción. El mecanismo de excepción de Java nos permite hacer esto mediante el uso de lanzamientos, esencialmente declarando el comportamiento general de nuestro método para lanzar una excepción, dejando así que el usuario del método escriba el código para manejar la excepción en Java.
Advertencia de "problemas"
Cuando no planee manejar una excepción en su método, pero quiera advertir a los usuarios del método sobre posibles situaciones de excepción, use la palabra clave throws. Esta palabra clave en la firma de un método significa que, bajo ciertas condiciones, el método puede generar una excepción. Esta advertencia es parte de la interfaz del método y le otorga al usuario el derecho de personalizar la implementación del controlador de excepciones. Después de los lanzamientos indicamos el tipo de excepción que se lanza. Suelen ser descendientes de la clase Java
Exception . Dado que Java es un lenguaje orientado a objetos, todas las excepciones en Java son objetos.
Jerarquía de excepciones de Java
Cuando ocurre un error durante la ejecución del programa, el tiempo de ejecución de JVM crea un objeto del tipo requerido a partir de la jerarquía de excepciones de Java: el conjunto de posibles excepciones heredadas de un "ancestro" común: la clase Throwable. Las situaciones excepcionales que se dan en un programa se pueden dividir en dos grupos:
- Situaciones en las que es imposible restablecer el funcionamiento normal del programa
- La recuperación es posible.
El primer grupo incluye situaciones en las que ocurren excepciones heredadas de la clase
Error . Estos son errores que ocurren durante la ejecución del programa como resultado de una falla de JVM, un desbordamiento de memoria o una falla del sistema. Por lo general, indican problemas graves que no se pueden solucionar mediante software. Este tipo de excepción en Java se clasifica como no verificada en la etapa de compilación. Este grupo también incluye RuntimeException: excepciones, herederas de la clase
Exception , generadas por la JVM durante la ejecución del programa. A menudo son causados por errores de programación. Estas excepciones tampoco están marcadas en el momento de la compilación, por lo que no es necesario escribir código para manejarlas. El segundo grupo incluye situaciones excepcionales que se prevén en la etapa de redacción del programa y para las cuales se debe escribir código de procesamiento. Se comprueban estas excepciones. La mayor parte del trabajo de un desarrollador de Java cuando se trata de excepciones es manejar este tipo de situaciones.
Creando una excepción
Durante la ejecución del programa, la JVM lanza una excepción o la utiliza manualmente la instrucción
throw . Esto crea un objeto de excepción en la memoria e interrumpe la ejecución del código del programa principal mientras el controlador de excepciones JVM intenta encontrar una manera de manejar la excepción.
Manejo de excepciones
La creación de bloques de código para los cuales proporcionamos manejo de excepciones en Java se realiza en el programa usando las construcciones try{}catch, try{}catch{}finally, try{}finally{}.
Cuando se genera una excepción en un bloque try, se busca el controlador de excepciones en el siguiente bloque catch. Si el catch contiene un controlador para este tipo de excepción, el control le pasa. De lo contrario, la JVM busca un controlador para ese tipo de excepción en la cadena de llamadas a métodos hasta que encuentra una captura adecuada. Después de ejecutar el bloque catch, el control se pasa a un bloque
finalmente opcional . Si no se encuentra un bloque catch adecuado, la JVM detiene la ejecución del programa y muestra una pila de llamadas a métodos:
seguimiento de pila , habiendo ejecutado previamente el código del bloque finalmente, si está presente. Ejemplo de manejo de excepciones:
public class Print {
void print(String s) {
if (s == null) {
throw new NullPointerException("Exception: s is null!");
}
System.out.println("Inside method print: " + s);
}
public static void main(String[] args) {
Print print = new Print();
List list= Arrays.asList("first step", null, "second step");
for (String s:list) {
try {
print.print(s);
}
catch (NullPointerException e) {
System.out.println(e.getMessage());
System.out.println("Exception was processed. Program continues");
}
finally {
System.out.println("Inside bloсk finally");
}
System.out.println("Go program....");
System.out.println("-----------------");
}
}
}
Los resultados del método
principal :
Inside method print: first step
Inside bloсk finally
Go program....
-----------------
Exception: s is null!
Exception was processed. Program continues
Inside bloсk finally
Go program....
-----------------
Inside method print: second step
Inside bloсk finally
Go program....
-----------------
El bloque
finallygeneralmente se usa para cerrar transmisiones abiertas en el bloque de prueba o para liberar recursos. Sin embargo, al escribir un programa, no siempre es posible realizar un seguimiento del cierre de todos los recursos. Para hacernos la vida más fácil, los desarrolladores de Java nos ofrecieron una construcción
try-with-resourcesque cierra automáticamente los recursos abiertos en un bloque de prueba. Nuestro primer ejemplo se puede reescribir así
try-with-resources:
public String input() throws MyException {
String s = null;
try(BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))){
s = reader.readLine();
} catch (IOException e) {
System.out.println(e.getMessage());
}
if (s.equals("")){
throw new MyException ("String can not be empty!");
}
return s;
}
Gracias a las capacidades de Java, a partir de la versión 7, también podemos combinar la captura de diferentes tipos de excepciones en un solo bloque, haciendo el código más compacto y legible. Por ejemplo:
public String input() {
String s = null;
try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
s = reader.readLine();
if (s.equals("")) {
throw new MyException("String can not be empty!");
}
} catch (IOException | MyException e) {
System.out.println(e.getMessage());
}
return s;
}
Resultados
El uso de excepciones en Java nos permite aumentar la tolerancia a fallas del programa mediante el uso de rutas de “respaldo”, separar la lógica del código principal del código de manejo de excepciones mediante el uso de bloques catch y también nos brinda la oportunidad de delegar. Manejo de excepciones para el usuario de nuestro código usando throws.
GO TO FULL VERSION