El manejo de excepciones en Java es uno de los conceptos más importantes que aprenderá como desarrollador Java Este tutorial le ayudará a entender e implementar correctamente el manejo de excepciones.
Todo programa informático tiene un flujo específico en el que se ejecuta. Si ocurre algo inesperado, se produce una perturbación en el flujo normal del programa.
Por ejemplo, la división de cualquier valor numérico por cero o el acceso a un índice que no existe en una matriz. Este fenómeno se denomina excepción en programación.
En palabras sencillas, una excepción es algo que no se esperaba que ocurriera pero que puede suceder y entonces hay que manejarlo.
¿Por qué se produce una excepción?
El punto clave aquí es la posibilidad. Hay múltiples cosas que pueden salir mal. El estado de la red, la interacción del usuario, entradas no válidas, etc., son algunas de las cosas que podrían provocar una excepción. Lo importante es cómo maneja esas excepciones que cree que ocurrirán alguna vez de una forma u otra.
Manejo de excepciones por la JVM
Cuando se produce una excepción dentro de un programa java, se crea un objeto que describe la excepción, incluyendo su tipo y el estado del programa cuando se produjo. A continuación, este objeto se pasa a la máquina virtual Java (JVM). La JVM intenta encontrar un método o función para manejar la excepción. Recorre una lista de métodos que potencialmente pueden manejar la excepción.
Una vez que encuentra el método apropiado para manejar la excepción, se la pasa al método, pero si no puede encontrar un método apropiado, termina el programa llamando al método de manejo de excepciones por defecto.
Tipos de excepciones en Java
Las excepciones en java son de dos tipos:
Comprobadas: Este tipo de excepciones son capturadas por el compilador en tiempo de compilación. Algunas de las excepciones comprobadas en java incluyen IOException y SQLException.
No comprobadas: El compilador no es consciente de estas excepciones en tiempo de compilación porque se hacen evidentes en tiempo de ejecución. Se verifican cuando se ejecuta el código. Las excepciones no verificadas incluyen la ArrayIndexOutOfBoundsException y la IllegalStateException.
Formas de manejar una excepción
He aquí algunas formas de manejar o lanzar una excepción:
- bloque try… catch
- palabra clave throw/throws
#1. Bloque try… catch
El bloque try-catch se utiliza para ejecutar un fragmento de código en el que existe la posibilidad de que se produzca una excepción. Los bloques try y catch son dos bloques de código separados – el bloque catch se ejecuta cuando el bloque try no se ejecuta normalmente.
try {
// código normal
} catch(Excepción e) {
// código que gestiona una excepción
}También hay un bloque finally que puede utilizar para ejecutar algún código independientemente de que se produzca o no una excepción. El código de este bloque se ejecutará en todos los casos.
try {
// código normal
} catch(Excepción e) {
// código que gestiona una excepción
} finally {
// código normal
}#2. palabra clave throw & throws
La palabra clave throw se utiliza para crear explícitamente una excepción única. Puede utilizar la palabra clave throw si sabe que una excepción puede ocurrir definitivamente para una condición particular.
public static void ocurrir() {
// condición
throw new ArithmeticException();
}
public static void main(String[] args) {
try {
occur();
} catch(Excepción e) {
// handle
}
}Puede utilizar la palabra clave throws para declarar varias excepciones que sabe que se producirán en un método determinado.
public static void occur() throws Exception1, Exception2, Exception3 {
// condiciones que lanzan diferentes excepciones
}
public static void main(String[] args) {
try {
occur();
} catch(Exception1 e) {
//...
} catch(Exception2 e) {
//...
} catch(Exception3 e) {
//...
}
}Algunas excepciones comunes en Java
#1. IOException
Una IOException puede ocurrir en java si hay un problema con el proceso de entrada/salida. Suele producirse cuando se intenta acceder a un archivo y a su contenido, pero el archivo no existe o hay un problema con la lectura de su contenido.
import java.io.FileNotFoundException;
import java.io.FileReader;
public class Main {
public static void main(String[] args) {
try {
FileReader archivo = new FileReader("hola.txt");
} catch (FileNotFoundException e) {
System.out.println(e.getMessage());
}
}
}#2. ArrayIndexOutOfBoundsException
Un array es una estructura de datos que almacena valores del mismo tipo de datos y cada valor tiene un índice que empieza en 0 y llega hasta (n-1) donde n es el número total de valores presentes en el array. Puede acceder a un elemento especificando el índice con el nombre de la variable que hace referencia al array:
array[índice]Ahora bien, si intenta acceder a un elemento con un índice menor que 0 o mayor que (n-1), se producirá una excepción porque no hay ningún elemento en ese índice concreto. Este tipo de excepción se conoce como ArrayIndexOutOfBoundsException y se produce en tiempo de ejecución.
public class Main {
public static void main(String[] args) {
try {
int[] arr = {34, 1, 78, 3, 5};
int elemento = arr[7];
} catch (Exception e) {
System.out.println(e);
}
}
}#3. ClassCastException
Este tipo de excepción se produce cuando intenta realizar un typecast del objeto de una clase padre con el tipo de una de sus subclases. También puede obtener esta excepción si intenta realizar un typecast de un objeto con una clase con la que no es compatible.
clase A {
public void display() {
System.out.println("Esta es la clase A");
}
}
class B extends A {
public void display() {
System.out.println("Esta es la clase B que es una subclase de A");
}
}
class C extends B {
public void display() {
System.out.println("Esta es la clase C que es una subclase de B");
}
}
public class Principal {
public static void main(String[] args) {
try {
A objA = nuevo A();
B objB = (B) new A();
} catch (Exception e) {
System.out.println(e);
}
}
}El código anterior lanzará una ClassCastException porque estamos intentando encastrar un objeto de la clase padre con el tipo de su subclase.
#4. IllegalArgumentException
Cuando un método o una función recibe un argumento que no es válido, puede lanzar una IllegalArgumentException. Por ejemplo, supongamos que está creando un método para calcular el perímetro de un cuadrado.
Mientras solicita al usuario la longitud de un lado del cuadrado, si obtiene un valor negativo, entonces puede lanzar esta excepción porque el lado de un cuadrado no puede ser negativo.
public class Principal {
public static int perímetro(int longitud) {
if(longitud < 0) {
throw new IllegalArgumentException("¡No se permiten valores negativos!");
}
return 4 * longitud;
}
public static void main(String[] args) {
try {
System.out.println(perímetro(-5));
} catch (Exception e) {
System.out.println(e);
}
}
}#5. IllegalStateException
Cuando se llama a un método o una función en un momento en el que no debería ser llamado, se obtiene una IllegalStateException. Por ejemplo, si llama al método start en un hilo que ya ha sido iniciado, entonces java lanzará esta excepción en tiempo de ejecución.
class AThread extends Thread {
public void run() {
System.out.println("¡Esto es un hilo!");
}
}
public class Principal {
public static void main(String[] args) {
try {
AThread t = nuevo AThread();
t.start();
t.start();
} catch (Exception e) {
System.out.println(e);
}
}
}#6. NullPointerException
Se produce cuando se intenta acceder a las propiedades de un objeto nulo o a una variable que apunta a un valor nulo. Null es un valor especial en java que indica que no hay ningún valor asignado a una variable de referencia.
public class Main {
public static void main(String[] args) {
try {
String num = null;
System.out.println(num.length());
} catch (Exception e) {
System.out.println(e);
}
}
}#7. NumberFormatException
Se produce cuando intenta convertir una cadena con formato incorrecto en un número. Por ejemplo, si intenta convertir «null» o «twenty» en un número, entonces java lanzará esta excepción.
public class Principal {
public static void main(String[] args) {
try {
int num = Integer.parseInt("12.389");
System.out.println(num);
} catch (Exception e) {
System.out.println(e);
}
}
}Conclusión
Manejar las excepciones es importante porque pueden crear interrupciones innecesarias en el flujo del programa. Tenga en cuenta que las excepciones son diferentes de los errores porque las excepciones deben ser manejadas, mientras que los errores no pueden ser manejados. En su lugar, deben ser resueltos o arreglados. Puede aprender más sobre java siguiendo estos cursos de java en línea.