Excepciones personalizadas

Parte de la sección Programación Orientada a Objetos del Journey de Java de Coddy. Lección 60 de 87.

Las excepciones integradas de Java cubren muchos escenarios de error comunes, pero a veces necesitas excepciones específicas del dominio de tu aplicación. Las excepciones personalizadas te permiten crear tipos de error significativos que comunican claramente qué salió mal.

Para crear una excepción personalizada, simplemente extiende una clase de excepción existente. Para una excepción comprobada, extiende Exception:

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

Para una excepción no comprobada, extiende RuntimeException:

public class InvalidAgeException extends RuntimeException {
    public InvalidAgeException(String message) {
        super(message);
    }
}

La llamada super(message) pasa el mensaje de error a la clase principal, lo que permite acceder a él mediante getMessage(). Después, puedes lanzar y capturar tu excepción personalizada como cualquier otra:

public void withdraw(double amount) throws InsufficientFundsException {
    if (amount > balance) {
        throw new InsufficientFundsException("Balance too low: " + balance);
    }
    balance -= amount;
}

// Usándolo
try {
    account.withdraw(1000);
} catch (InsufficientFundsException e) {
    System.out.println(e.getMessage());
}

Las excepciones personalizadas hacen que tu código sea más legible y permiten que quienes realizan las llamadas gestionen de forma diferente condiciones de error específicas. Son especialmente valiosas al crear API o bibliotecas en las que es importante comunicar claramente los errores.

Desafío

Fácil

¡Construyamos un sistema de reserva de entradas que utilice excepciones personalizadas para gestionar distintos escenarios de error! Crearás tipos de excepción significativos que comunicarán claramente qué salió mal al reservar entradas.

Organizarás tu código en cuatro archivos:

TicketSoldOutException.java: Crea una excepción comprobada personalizada (extiende Exception) para cuando ya no haya entradas disponibles. Tu excepción debe aceptar un mensaje en su constructor y pasarlo a la clase principal mediante super(message).
InvalidSeatException.java: Crea una excepción no comprobada personalizada (extiende RuntimeException) para cuando alguien intente reservar un número de asiento no válido. Esta excepción también debe aceptar y pasar un mensaje a su clase principal.
TicketBooth.java: Crea una clase que gestione la venta de entradas. Tu taquilla debe llevar el control del número total de asientos disponibles y del número de asiento válido más alto. Incluye:
Un constructor que reciba el número total de asientos disponibles.

Un método bookTicket(int seatNumber) que valide la reserva. Si no quedan entradas (los asientos disponibles son 0 o menos), lanza una TicketSoldOutException con el mensaje "No tickets remaining". Si el número de asiento es menor que 1 o mayor que el total de asientos, lanza una InvalidSeatException con el mensaje "Seat [seatNumber] does not exist". De lo contrario, disminuye en 1 los asientos disponibles e imprime Booked seat [seatNumber] successfully.

Un método getAvailableSeats() que devuelva el número actual de asientos disponibles.
Main.java: ¡Reúne tu sistema de reserva de entradas! Recibirás dos entradas: el número total de asientos y un número de asiento que reservar.
Crea un TicketBooth con el total de asientos indicado. Después, intenta reservar el número de asiento especificado dentro de un bloque try-catch. Como TicketSoldOutException es comprobada, debes gestionarla. Captura primero TicketSoldOutException e imprime Booking failed: [exception message]. Después, captura InvalidSeatException e imprime el mismo formato: Booking failed: [exception message].

Después del bloque try-catch, imprime Remaining seats: [count] usando el método getter.

Recibirás dos entradas en este orden: total de asientos (entero) y número de asiento que reservar (entero).

Observa cómo las excepciones comprobadas obligan a quienes las llaman a gestionarlas (con try-catch o throws), mientras que las excepciones no comprobadas no requieren una gestión explícita. ¡Elige el tipo de excepción según si es un error que quienes llaman deberían prever y del que deberían recuperarse!

Pruébalo tú mismo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int totalSeats = scanner.nextInt();
        int seatNumber = scanner.nextInt();
        
        // TODO: Crea un TicketBooth con el total de asientos dado
        
        // TODO: Usa un bloque try-catch para intentar reservar el asiento
        // - Captura TicketSoldOutException primero e imprime "Booking failed: [exception message]"
        // - Captura InvalidSeatException e imprime "Booking failed: [exception message]"
        
        // TODO: After the try-catch, print "Remaining seats: [count]"
    }
}