Crear excepciones personalizadas en Java

Introducción

En Java, se lanzan excepciones para indicar eventos excepcionales que ocurren durante la ejecución de un programa. Si bien Java proporciona una variedad de excepciones incorporadas, a veces es posible que necesitemos definir nuestras propias excepciones personalizadas para situaciones específicas. Hay dos tipos de excepciones personalizadas: excepciones verificadas y excepciones no verificadas. Las excepciones verificadas son aquellas que deben ser manejadas durante la compilación, mientras que las excepciones no verificadas solo se detectan durante la ejecución. En este laboratorio, crearemos ambos tipos de excepciones personalizadas y aprenderemos cómo utilizarlas.

Skills Graph

Crea una clase Java llamada MyArray

Primero, crearemos una clase Java llamada MyArray para implementar una matriz con el método get(), que puede lanzar una excepción si el índice es inválido.

public class MyArray {
    int[] array;

    public MyArray(int size) {
        array = new int[size];
        for (int i = 0; i < size; i++) {
            array[i] = i * 5;
        }
    }

    // Método Get que puede lanzar una excepción
    public int get(int index) {
        if (index >= array.length) {
            throw new IndexOutOfBoundsException("Index " + index + " is invalid.");
        } else {
            return array[index];
        }
    }
}

Crea una excepción verificada personalizada

Podemos crear una excepción verificada personalizada extendiendo la clase Exception. En este ejemplo, crearemos una IndexNotValidException cuando el índice sea inválido. Esta excepción será lanzada por el método get() en la clase MyArray.

public class IndexNotValidException extends Exception {
    public IndexNotValidException(String message) {
        super(message);
    }
}

Ahora podemos actualizar el método get() en la clase MyArray para lanzar esta excepción personalizada.

public int get(int index) throws IndexNotValidException {
    if (index >= array.length) {
        throw new IndexNotValidException("Index " + index + " is invalid.");
    } else {
        return array[index];
    }
}

Maneja la excepción verificada personalizada

Para manejar la excepción verificada personalizada, debemos capturarla o declararla utilizando la palabra clave throws cuando se llame al método get() en la clase Demo.

public class Demo {
    public static void main(String[] args) {
        MyArray arr = new MyArray(5);
        try {
            System.out.println(arr.get(10)); // Lanza IndexNotValidException
        } catch (IndexNotValidException e) {
            System.err.println(e.getMessage());
        }
    }
}

Crea una excepción no verificada personalizada

Podemos crear una excepción no verificada personalizada extendiendo la clase RuntimeException en lugar de la clase Exception. En el siguiente ejemplo, crearemos una IndexNotValidRuntimeException cuando el índice sea inválido, la cual será lanzada por el método get() en la clase MyArray.

public class IndexNotValidRuntimeException extends RuntimeException {
    public IndexNotValidRuntimeException(String message, Throwable cause) {
        super(message, cause);
    }
}

Además, definimos una excepción arrojable que define la excepción subyacente o la causa de nuestra excepción. En nuestro caso, la excepción subyacente es ArrayIndexOutOfBounds. Podemos actualizar el método get() en la clase MyArray para lanzar la excepción no verificada personalizada.

public int get(int index) {
    if (index >= array.length) {
        Throwable cause = new ArrayIndexOutOfBoundsException();
        throw new IndexNotValidRuntimeException("Index " + index + " is invalid.", cause);
    } else {
        return array[index];
    }
}

Maneja la excepción no verificada personalizada

No es necesario capturar o declarar la excepción no verificada personalizada. En el siguiente ejemplo, cuando se llama al método get() con un índice inválido en la clase Demo, se lanzará una IndexNotValidRuntimeException.

public class Demo {
    public static void main(String[] args) {
        MyArray arr = new MyArray(5);
        System.out.println(arr.get(10)); // Lanza IndexNotValidRuntimeException
    }
}

Resumen

Las excepciones personalizadas en Java pueden ayudarnos a manejar errores o excepciones específicas en nuestra aplicación de manera efectiva al crear excepciones adaptadas a nuestras necesidades. En este laboratorio, hemos aprendido cómo crear nuestras propias excepciones personalizadas para manejar errores en nuestra lógica de negocios o flujo de trabajo. También hemos discutido cómo crear tanto excepciones verificadas como no verificadas, con ejemplos de cada una.