Creating custom exception class in Java - Try It Yourself

Creating custom exception class

📖 Scenario: Imagine you are building a simple banking application. You want to handle errors when someone tries to withdraw more money than their account balance.

🎯 Goal: You will create a custom exception class called InsufficientFundsException and use it to show a clear error message when a withdrawal is not possible.

📋 What You'll Learn

Create a custom exception class named InsufficientFundsException that extends Exception.

Add a constructor to InsufficientFundsException that accepts a String message and passes it to the superclass.

Create a class called BankAccount with a private double variable balance.

Add a constructor to BankAccount that sets the initial balance.

Add a method withdraw in BankAccount that throws InsufficientFundsException if withdrawal amount is greater than balance.

Add a method getBalance to return the current balance.

Write code to test withdrawing money and catching the custom exception.

💡 Why This Matters

🌍 Real World

Custom exceptions help make error messages clearer and more specific in real applications like banking, shopping carts, or user input validation.

💼 Career

Understanding how to create and use custom exceptions is important for writing robust Java programs and is a common skill required in software development jobs.

1

Create the custom exception class

Create a public class called InsufficientFundsException that extends Exception. Add a constructor that takes a String message and passes it to super(message).

Java

// Your code here

Hint

Remember to extend Exception and call super(message) inside the constructor.

2

Create the BankAccount class with balance

Create a public class called BankAccount. Add a private double variable named balance. Add a constructor that takes a double initialBalance and sets balance to it.

Java

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

// Your code here

Hint

Use private double balance; and set it in the constructor.

3

Add withdraw method with exception

In the BankAccount class, add a public method withdraw that takes a double amount and throws InsufficientFundsException. If amount is greater than balance, throw new InsufficientFundsException with message "Not enough balance". Otherwise, subtract amount from balance. Also add a public method getBalance that returns the current balance.

Java

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

public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    // Add withdraw and getBalance methods below
    // Your code here
}

Hint

Check if amount is more than balance. If yes, throw the exception. Otherwise, reduce the balance.

4

Test withdrawing and catching exception

Create a public class Main with a main method. Inside main, create a BankAccount object with initial balance 1000. Try to withdraw 1500 inside a try block. Catch InsufficientFundsException and print its message. Also print the remaining balance after the withdrawal attempt.

Java

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

public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException("Not enough balance");
        }
        balance -= amount;
    }

    public double getBalance() {
        return balance;
    }
}

public class Main {
    public static void main(String[] args) {
        // Your code here
    }
}

Hint

Use a try block to call withdraw and catch InsufficientFundsException. Print the exception message and then print the balance.

Practice

1. What is the correct way to start creating a custom exception class in Java?

easy

A. Extend the Exception or RuntimeException class

B. Implement the Exception interface

C. Create a class with the same name as Exception

D. Use the throw keyword in the class declaration

Solution

1. Step 1: Understand Java exception hierarchy

   Custom exceptions must extend either Exception or RuntimeException to behave like exceptions.

2. Step 2: Recognize correct inheritance

   Implementing an interface or naming a class Exception does not create a proper exception class.

3. Final Answer:

   Extend the Exception or RuntimeException class -> Option A

4. Quick Check:

   Custom exception = extends Exception [OK]

Hint: Always extend Exception or RuntimeException for custom exceptions [OK]

Common Mistakes:

• Trying to implement Exception as an interface
• Naming class Exception instead of extending it
• Using throw keyword in class declaration

2. Which of the following is the correct constructor for a custom exception class named MyException?

easy

A. public MyException() { this.message = message; }

B. public void MyException(String message) { super(message); }

C. public MyException(String message) { super(message); }

D. public MyException(String message) { print(message); }

Solution

1. Step 1: Identify correct constructor syntax

   Constructors have no return type and call super(message) to pass the message to the parent Exception class.

2. Step 2: Check each option

   public MyException(String message) { super(message); } correctly defines a constructor calling super(message). public MyException() { this.message = message; } incorrectly assigns message without declaration. public void MyException(String message) { super(message); } has a void return type, so it's not a constructor. public MyException(String message) { print(message); } calls a non-existent method print.

3. Final Answer:

   public MyException(String message) { super(message); } -> Option C

4. Quick Check:

   Constructor calls super(message) = public MyException(String message) { super(message); } [OK]

Hint: Constructor must call super(message) without return type [OK]

Common Mistakes:

• Adding void return type to constructor
• Not calling super(message) in constructor
• Trying to assign message directly without declaration

3. What will be the output of this code?

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

public class Test {
    public static void main(String[] args) {
        try {
            throw new MyException("Error occurred");
        } catch (MyException e) {
            System.out.println(e.getMessage());
        }
    }
}

medium

A. Error occurred

B. MyException

C. Compilation error

D. No output

Solution

1. Step 1: Understand exception throwing and catching

   The code throws a MyException with message "Error occurred" and catches it immediately.

2. Step 2: Check output from getMessage()

   The catch block prints e.getMessage(), which returns the message passed to the exception.

3. Final Answer:

   Error occurred -> Option A

4. Quick Check:

   Exception message printed = Error occurred [OK]

Hint: getMessage() prints the exception message passed in constructor [OK]

Common Mistakes:

• Expecting class name instead of message
• Thinking code won't compile due to custom exception
• Missing try-catch block causing runtime error

4. Identify the error in this custom exception class:

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

medium

A. super(message) cannot be called in this class

B. Missing import statement for Exception

C. Class must implement Serializable interface

D. Constructor has a void return type, so it's a method, not a constructor

Solution

1. Step 1: Check constructor syntax

   Constructors must not have a return type. Here, void makes it a method, not a constructor.

2. Step 2: Understand consequences

   Without a proper constructor, the class uses default constructor which does not call super(message), causing errors when throwing with message.

3. Final Answer:

   Constructor has a void return type, so it's a method, not a constructor -> Option D

4. Quick Check:

   Constructor no return type = Constructor has a void return type, so it's a method, not a constructor [OK]

Hint: Constructors never have a return type, not even void [OK]

Common Mistakes:

• Adding void return type to constructor
• Assuming import Exception is needed
• Thinking super() cannot be called in subclass

5. You want to create a custom unchecked exception named InvalidDataException. Which is the correct way to define it?

hard

A. public class InvalidDataException implements RuntimeException {
public InvalidDataException(String message) {
super(message);
}
}

B. public class InvalidDataException extends RuntimeException {
public InvalidDataException(String message) {
super(message);
}
}

C. public class InvalidDataException extends Exception {
public InvalidDataException(String message) {
super(message);
}
}

D. public class InvalidDataException extends Throwable {
public InvalidDataException(String message) {
super(message);
}
}

Solution

1. Step 1: Understand checked vs unchecked exceptions

   Unchecked exceptions extend RuntimeException, checked exceptions extend Exception.

2. Step 2: Analyze each option

   public class InvalidDataException extends RuntimeException { public InvalidDataException(String message) { super(message); } } correctly extends RuntimeException with proper constructor. public class InvalidDataException extends Exception { public InvalidDataException(String message) { super(message); } } creates a checked exception. public class InvalidDataException implements RuntimeException { public InvalidDataException(String message) { super(message); } } tries to implement an exception class, which is invalid. public class InvalidDataException extends Throwable { public InvalidDataException(String message) { super(message); } } extends Throwable directly, which is not recommended for custom exceptions.

3. Final Answer:

   public class InvalidDataException extends RuntimeException { public InvalidDataException(String message) { super(message); } } -> Option B

4. Quick Check:

   Unchecked exception = extends RuntimeException [OK]

Hint: Unchecked exceptions extend RuntimeException, not Exception [OK]

Common Mistakes:

• Extending Exception for unchecked exceptions
• Trying to implement exception classes
• Extending Throwable directly