¡El manejo de excepciones en Java es uno de los conceptos más importantes que aprenderá como desarrollador de Java! Este tutorial lo ayuda a comprender e implementar el manejo de excepciones correctamente.
Cada programa de computadora tiene un flujo específico en el que se ejecuta. Si algo inesperado sucede, conduce a 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 como un excepción en programación.
En palabras simples, una excepción es algo que no esperaba que sucediera, pero puede suceder y luego debe manejarlo.
¿Por qué ocurre una excepción?
El punto clave aquí es posibilidad. Hay varias cosas que podrían salir mal. El estado de la red, la interacción del usuario, las entradas no válidas, etc., son algunas de las cosas que podrían dar lugar a una excepción. Lo importante es cómo maneja esas excepciones que cree que ocurrirán en algún momento de una forma u otra.
Exception Handling by JVM
Cuando ocurre una excepción dentro de un programa Java, se crea un objeto que describe la excepción, incluido su tipo y el estado del programa cuando ocurrió. A continuación, este objeto se pasa al máquina virtual de Java (JVM). La JVM intenta encontrar un método o función para manejar la excepción. Pasa por 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, pasa la excepción al método, pero si no puede encontrar un método apropiado, finaliza el programa llamando al método predeterminado de manejo de excepciones.
Types of Exceptions in Java
Las excepciones en java son de dos tipos:
comprobado: el compilador detecta estos tipos de excepciones en el momento de la compilación. Algunas de las excepciones verificadas en Java incluyen IOException y SQLException.
Desenfrenado: el compilador no tiene conocimiento de estas excepciones en tiempo de compilación porque se vuelven evidentes en tiempo de ejecución. Se verifican cuando se ejecuta el código. Las excepciones no verificadas incluyen ArrayIndexOutOfBoundsException e IllegalStateException.
Ways to Handle an Exception
Aquí hay algunas formas en las que puede manejar o lanzar una excepción:
- intentar… atrapar bloque
- lanzar/lanzar palabra clave
#1. intentar… atrapar bloque
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. Él tratan y coger los bloques son dos bloques separados de código – coger bloque se ejecuta cuando el tratan el bloque no se ejecuta normalmente.
try {
// normal code
} catch(Exception e) {
// code which handles an exception
}También hay un finalmente bloque que puede usar para ejecutar algún código independientemente de que ocurra una excepción o no. El código de este bloque se ejecutará en todos los casos.
try {
// normal code
} catch(Exception e) {
// code which handles an exception
} finally {
// some code
}#2. lanzar y lanzar palabra clave
EL lanzar La palabra clave se utiliza para crear explícitamente una sola excepción. Puedes usar lanzar palabra clave si sabe que definitivamente puede ocurrir una excepción para una condición particular.
public static void occur() {
// condition
throw new ArithmeticException();
}
public static void main(String[] args) {
try {
occur();
} catch(Exception e) {
// handle
}
}Puede utilizar el tiros palabra clave para indicar múltiples excepciones que sabe que ocurrirán en un método dado.
public static void occur() throws Exception1, Exception2, Exception3 {
// conditions which throw different exceptions
}
public static void main(String[] args) {
try {
occur();
} catch(Exception1 e) {
//...
} catch(Exception2 e) {
//...
} catch(Exception3 e) {
//...
}
}Some Common Exceptions in Java
#1. IOException
Una IOException puede ocurrir en java si hay un problema con el proceso de entrada/salida. Por lo general, ocurre cuando intenta acceder a un archivo y su contenido, pero el archivo no existe o hay un problema al leer el contenido que contiene.
import java.io.FileNotFoundException;
import java.io.FileReader;
public class Main {
public static void main(String[] args) {
try {
FileReader file = new FileReader("hello.txt");
} catch (FileNotFoundException e) {
System.out.println(e.getMessage());
}
}
}#2. ArrayIndexOutOfBoundsExceptionArrayIndexOutOfBoundsException
Una matriz es una estructura de datos que almacena valores del mismo tipo de datos y cada valor tiene un índice que comienza desde 0 y va hasta (n-1), donde n es el número total de valores presentes en la matriz. Puede acceder a un elemento especificando el índice con el nombre de la variable que hace referencia a la matriz:
array[index]Ahora, si intenta acceder a un elemento con un índice menor que 0 o mayor que (n-1), ocurrirá una excepción porque no hay ningún elemento en ese índice en particular. Este tipo de excepción se conoce como ArrayIndexOutOfBoundsException y ocurre en tiempo de ejecución.
public class Main {
public static void main(String[] args) {
try {
int[] arr = {34, 1, 78, 3, 5};
int element = arr[7];
} catch (Exception e) {
System.out.println(e);
}
}
}#3. ClassCastException
Este tipo de excepción ocurre cuando intenta encasillar el objeto de una clase principal con el tipo de una de sus subclases. También puede obtener esta excepción si intenta encasillar un objeto con una clase con la que no es compatible.
class A {
public void display() {
System.out.println("This is class A");
}
}
class B extends A {
public void display() {
System.out.println("This is class B which is a subclass of A");
}
}
class C extends B {
public void display() {
System.out.println("This is class C which is a subclass of B");
}
}
public class Main {
public static void main(String[] args) {
try {
A objA = new A();
B objB = (B) new A();
} catch (Exception e) {
System.out.println(e);
}
}
}El código anterior arrojará una ClassCastException porque estamos tratando de encasillar un objeto de la clase principal con el tipo de su subclase.
#4. Argumento de excepción ilegal
Cuando un método o una función recibe un argumento que no es válido, puede generar una IllegalArgumentException. Por ejemplo, supongamos que está creando un método para calcular el perímetro de un cuadrado.
Al solicitar la longitud de un lado de la cuadrado del usuario, si obtiene un valor negativo, puede lanzar esta excepción porque el lado de un cuadrado no puede ser negativo.
public class Main {
public static int perimeter(int length) {
if(length < 0) {
throw new IllegalArgumentException("No negative values are allowed!");
}
return 4 * length;
}
public static void main(String[] args) {
try {
System.out.println(perimeter(-5));
} catch (Exception e) {
System.out.println(e);
}
}
}#5. IllegalStateExceptionIlegalStateException
Cuando llama a un método o una función en un momento en el que no debería llamarse, obtiene una IllegalStateException. Por ejemplo, si llama al método de inicio en un subproceso que ya se ha iniciado, Java lanzará esta excepción en tiempo de ejecución.
class AThread extends Thread {
public void run() {
System.out.println("This is a thread!");
}
}
public class Main {
public static void main(String[] args) {
try {
AThread t = new AThread();
t.start();
t.start();
} catch (Exception e) {
System.out.println(e);
}
}
}#6. Excepción de puntero nulo
Ocurre cuando intenta acceder a las propiedades de un objeto nulo o una variable que apunta a un valor nulo. Nulo es un valor especial en Java que indica que no se asigna ningún valor 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
Ocurre cuando intenta convertir una cadena con formato incorrecto en un número. Por ejemplo, si intenta convertir "nulo" o "veinte" en un número, Java lanzará esta excepción.
public class Main {
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
El manejo de 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 manejarse, mientras que los errores no pueden manejarse. En su lugar, deben ser resueltos o reparados. Puede obtener más información sobre Java consultando estos cursos de Java en línea.
