User Defined Exception in Java

In Java, exceptions are used to handle errors that occur during the execution of a program. There are many built-in exceptions in Java, but sometimes we need to create our own exceptions to handle specific errors. These exceptions are called as user defined exception in Java. This is where custom exceptions come in.

What is user defined exception in Java?

A user-defined exception is a custom exception class that we as a programmer/developer create to handle specific errors in our program. User-defined exceptions are derived from the Exception class or one of its subclasses, which is the base class for all exceptions in Java.

Why to use user defined exceptions?

There are several reasons why we might want to use user-defined exceptions in our Java programs. Following are a few of the most common reasons:

• To provide more specific information about the error that occurred.
• To control the flow of our program differently depending on the type of error that occurred.
• To provide a consistent way of handling errors throughout our program.

Create user defined exception in Java

To create custom exceptions in Java, follow these steps:

1. Choose the Exception Type

• Checked Exception: Extend Exception (must be handled or declared).
• Unchecked Exception: Extend RuntimeException (optional handling).

2. Create a Custom Exception Class

• Naming Convention: End the class name with Exception.
• Constructors: Include constructors for messages and causes.

Example 1: Checked Exception

public class InsufficientFundsException extends Exception {
    // Default constructor
    public InsufficientFundsException() {
        super();
    }

    // Constructor with a message
    public InsufficientFundsException(String message) {
        super(message);
    }

    // Constructor with message and cause
    public InsufficientFundsException(String message, Throwable cause) {
        super(message, cause);
    }
}

Example 2: Unchecked Exception with Custom Field

public class InvalidAgeException extends RuntimeException {
    private final int invalidAge;

    public InvalidAgeException(int age) {
        super("Invalid age: " + age); // Message
        this.invalidAge = age;
    }

    public int getInvalidAge() {
        return invalidAge;
    }
}

3. Throw the Custom Exception

Use throw to trigger the exception in your code.

Using Checked Exception:

public class BankAccount {
    private double balance;

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

Using Unchecked Exception:

public class User {
    private int age;

    public void setAge(int age) {
        if (age < 0) {
            throw new InvalidAgeException(age); // Throws unchecked exception
        }
        this.age = age;
    }
}

4. Handle the Exception

Handling Checked Exception (Try-Catch):

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        try {
            account.withdraw(100);
        } catch (InsufficientFundsException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

Propagating Checked Exception (Declare throws):

public void processTransaction() throws InsufficientFundsException {
    BankAccount account = new BankAccount();
    account.withdraw(100);
}

Unchecked Exception Handling (Optional):

public class Main {
    public static void main(String[] args) {
        User user = new User();
        try {
            user.setAge(-5);
        } catch (InvalidAgeException e) {
            System.err.println(e.getMessage() + " | Invalid Value: " + e.getInvalidAge());
        }
    }
}

Best Practices

1. Meaningful Names: Use descriptive names ending with Exception.
2. Provide Context: Include messages and relevant data (e.g., invalidAge).
3. Override Wisely: Override getMessage() if additional details are needed.
4. Choose Checked/Unchecked:
   • Use checked if recovery is expected.
   • Use unchecked for programming errors (e.g., invalid arguments).

Key Takeaways

• Extend Exception or RuntimeException.
• Include constructors for flexibility.
• Throw with throw and handle with try-catch or throws.

FAQs