Java

Excepciones Propias

Excepciones propias

En Java, puedes crear tus propias excepciones personalizadas para representar errores específicos de tu aplicación. Esto te permite manejar de manera más efectiva las situaciones que no están cubiertas por las excepciones estándar de Java, haciendo que el código sea más expresivo y fácil de entender.

Pasos para crear una excepción personalizada:

  1. Extender una clase de excepción existente: La mayoría de las excepciones personalizadas en Java extienden una de las clases de excepción preexistentes, como Exception o RuntimeException.
    • Si deseas que tu excepción sea verificada (checked exception), extiende de Exception.
    • Si deseas que sea no verificada (unchecked exception), extiende de RuntimeException.
  2. Definir un constructor: Puedes crear constructores que acepten un mensaje de error y/o una causa (otra excepción que causó esta).
  3. Proporcionar un mensaje de error útil: Es útil incluir un mensaje descriptivo en el constructor de la excepción para facilitar la depuración.

Ejemplo 1: Creación de una excepción verificada personalizada

En este ejemplo, crearemos una excepción personalizada llamada InvalidAgeException que extiende de Exception, indicando que es una excepción verificada.

// Definir la clase de excepción personalizada
public class InvalidAgeException extends Exception {

    // Constructor sin mensaje
    public InvalidAgeException() {
        super();
    }

    // Constructor con mensaje
    public InvalidAgeException(String message) {
        super(message);
    }

    // Constructor con mensaje y causa
    public InvalidAgeException(String message, Throwable cause) {
        super(message, cause);
    }

    // Constructor con causa
    public InvalidAgeException(Throwable cause) {
        super(cause);
    }
}

En este caso, InvalidAgeException extiende de Exception y proporciona varios constructores que permiten proporcionar un mensaje de error, una causa o ambos.

Uso de la excepción personalizada (InvalidAgeException)

public class TestInvalidAgeException {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (InvalidAgeException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

    public static void validateAge(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("Edad no válida. Debes ser mayor de 18 años.");
        }
        System.out.println("Edad válida: " + age);
    }
}

En este ejemplo:

  • El método validateAge(int age) lanza la excepción personalizada InvalidAgeException si la edad es menor a 18.
  • La excepción es capturada en el bloque catch en el método main, y se muestra un mensaje personalizado.

Ejemplo 2: Creación de una excepción no verificada personalizada

Si prefieres crear una excepción no verificada (unchecked exception), puedes extender de RuntimeException. Estas excepciones no requieren que sean declaradas con throws en la firma del método y son más fáciles de usar cuando no es necesario manejar todos los casos posibles de error.

// Definir una excepción no verificada personalizada
public class InsufficientFundsException extends RuntimeException {

    // Constructor sin mensaje
    public InsufficientFundsException() {
        super();
    }

    // Constructor con mensaje
    public InsufficientFundsException(String message) {
        super(message);
    }

    // Constructor con mensaje y causa
    public InsufficientFundsException(String message, Throwable cause) {
        super(message, cause);
    }

    // Constructor con causa
    public InsufficientFundsException(Throwable cause) {
        super(cause);
    }
}

En este caso, InsufficientFundsException extiende de RuntimeException, lo que significa que es una excepción no verificada. No necesitas declarar throws en los métodos que puedan lanzar esta excepción.

Uso de la excepción no verificada (InsufficientFundsException)

public class TestInsufficientFundsException {
    public static void main(String[] args) {
        try {
            withdraw(5000, 3000);
        } catch (InsufficientFundsException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

    public static void withdraw(double balance, double amount) {
        if (amount > balance) {
            throw new InsufficientFundsException("Saldo insuficiente. El saldo disponible es: " + balance);
        }
        System.out.println("Retiro exitoso. Nuevo saldo: " + (balance - amount));
    }
}

En este ejemplo:

  • El método withdraw(double balance, double amount) lanza la excepción personalizada InsufficientFundsException si el monto a retirar es mayor que el saldo disponible.
  • Esta excepción no es verificada, por lo que no es necesario declararla con throws.

Beneficios de crear excepciones personalizadas

  1. Desempeño específico: Las excepciones personalizadas permiten que tu código sea más claro y fácil de mantener, ya que puedes definir excepciones que tengan un propósito bien definido y específico.
  2. Mayor control: Puedes manejar los errores de manera más detallada y específica para tu aplicación, proporcionando mensajes de error claros y contextuales.
  3. Abstracción del problema: En lugar de usar excepciones generales como IOException o RuntimeException, puedes crear excepciones que representen exactamente el tipo de error que ocurre en tu aplicación, lo que mejora la claridad del código.
  4. Reusabilidad: Las excepciones personalizadas pueden ser reutilizadas a través de diferentes clases y métodos de tu aplicación.

Consideraciones al crear excepciones personalizadas

  • Usar excepciones verificadas cuando sea necesario: Si el cliente del método debe estar obligado a manejar la excepción (por ejemplo, un error en la entrada de datos del usuario), usa excepciones verificadas (extiende de Exception).
  • Usar excepciones no verificadas para errores no esperados: Si la excepción representa un error que generalmente no se espera (por ejemplo, un error de lógica o de programación), entonces usa excepciones no verificadas (extiende de RuntimeException).
  • Evitar crear demasiadas excepciones: No crees excepciones personalizadas para situaciones triviales. La jerarquía de excepciones de Java ya cubre una gran cantidad de casos comunes. Solo crea excepciones personalizadas cuando tenga sentido para tu aplicación.