TECH4GEEKS-LOGO-HEADER
Oxary Magazine
$10 – $15 / Week

Manejo de excepciones en Java: explicación

¡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 correctamente el manejo de excepciones.

Cada programa de computadora tiene un flujo específico en el que se ejecuta. Si sucede algo inesperado, interrumpe el flujo normal del programa.

Por ejemplo, dividir cualquier valor numérico por cero o acceder a un índice que no existe en una matriz. Este fenómeno se describe como excepcional en la programación.

En pocas palabras, una excepción es algo que no esperaba, pero puede suceder y luego debe manejarlo.

¿Por qué ocurre una excepción?

El punto clave aquí es la 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 las excepciones que cree que sucederán de una forma u otra.

Manejo de excepciones por JVM

Cuando ocurre una excepción en un programa Java, se crea un objeto que describe la excepción, incluido su tipo y el estado del programa cuando ocurrió. Luego, este objeto se pasa a la 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.

método de manejo de excepciones.Credito de imagen: Oráculo

Una vez que encuentra el método apropiado para manejar la excepción, pasa la excepción al método, pero si no encuentra un método apropiado, finaliza el programa llamando al método de manejo de excepciones predeterminado.

  Presentamos NestJS [+6 Learning Resources]

Tipos de excepciones en Java

Tipos de excepciones en 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 desconoce estas excepciones en tiempo de compilación porque se vuelven obvias en tiempo de ejecución. Se comprueban cuando se ejecuta el código. Las excepciones no verificadas incluyen ArrayIndexOutOfBoundsException e IllegalStateException.

Maneras de manejar una excepción

Aquí hay algunas formas de manejar o lanzar una excepción:

  • intenta… agarrar el bloque
  • lanzar/lanzar la palabra clave

#1. intenta… agarrar el bloque

El bloque try-catch se usa para ejecutar un fragmento de código donde puede ocurrir 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 {
  // normal code
} catch(Exception e) {
  // code which handles an exception
}

También hay un bloque finalmente que puede usar para ejecutar código, ya sea que ocurra una excepción o no. El código en este bloque se ejecutará de todos modos.

try {
  // normal code
} catch(Exception e) {
  // code which handles an exception
} finally {
  // some code
}

#2. tirar y tirar la palabra clave

La palabra clave throw se usa para crear explícitamente una sola excepción. Puede usar la palabra clave throw si sabe que definitivamente puede ocurrir una excepción para una condición en particular.

public static void occur() {
  // condition
  throw new ArithmeticException();
}

public static void main(String[] args) {
  try {
    occur();
  } catch(Exception e) {
    // handle
  }
}

Puede utilizar la palabra clave throws para indicar varias excepciones que sabe que se producirán en un método determinado.

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) {
    //...
  }
}

Algunas excepciones comunes en Java

Algunas excepciones comunes en Java

#1. IOException

Una IOException puede ocurrir en Java si hay un problema con el proceso de entrada/salida. Esto suele suceder 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 llama 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 convertir el objeto de una clase principal al tipo de una de sus subclases. También puede obtener esta excepción si intenta convertir 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 convertir un objeto de la clase principal al tipo de su subclase.

  Bitbucket vs GitHub: puntos de referencia para usar en el 2022

#4. Argumento de excepción ilegal

Cuando un método o función recibe un argumento que no es válido, puede generar una IllegalArgumentException. Por ejemplo, suponga que crea un método para calcular el perímetro de un cuadrado.

Al preguntarle al usuario la longitud de un lado del cuadrado, 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 función cuando no debería llamarse, obtiene una IllegalStateException. Por ejemplo, si llama al método de inicio en un subproceso que ya se inició, Java lanzará esa 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

Esto sucede al intentar 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

Esto sucede cuando intenta convertir una cadena mal formateada 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 realizando estos cursos de Java en línea.

  Salas de datos virtuales: beneficios, usos y herramientas

Fuente

Etiquetas

Comparte en:

Ultimos Post

Categorias

Lorem ipsum dolor sit amet, consectetur adipiscing elit eiusmod tempor ncididunt ut labore et dolore magna
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore