Why custom exceptions are needed in Java - See It in Action

Why Custom Exceptions Are Needed

📖 Scenario: Imagine you are building a simple banking application. You want to handle errors like when someone tries to withdraw more money than they have. Java has built-in exceptions, but sometimes you need your own special error messages to make your program clearer and easier to fix.

🎯 Goal: You will create a custom exception called InsufficientFundsException to show how custom exceptions help make your program clearer and handle specific problems better.

📋 What You'll Learn

Create a custom exception class called InsufficientFundsException that extends Exception

Create a class called BankAccount with a balance variable

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

Write code to catch the InsufficientFundsException and print a clear message

💡 Why This Matters

🌍 Real World

Custom exceptions are used in real banking software to handle errors like insufficient funds clearly and safely.

💼 Career

Understanding custom exceptions is important for writing clean, maintainable Java code and is a common skill required in software development jobs.

1

Create the InsufficientFundsException class

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

Java

// Your code here

Hint

Remember, to create a custom exception, extend the Exception class and call super(message) in the constructor.

2

Create the BankAccount class with a balance

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

Java

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

// Your code here

Hint

Define the balance variable and set it in the constructor using this.balance = initialBalance.

3

Add the withdraw method that throws InsufficientFundsException

In the BankAccount class, add a public method called withdraw that takes a double parameter amount and throws InsufficientFundsException. Inside the method, check if amount is greater than balance. If yes, throw a new InsufficientFundsException with the message "Not enough balance". Otherwise, subtract amount from 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 the withdraw method below
    // Your code here
}

Hint

Use throws InsufficientFundsException in the method signature and throw the exception when amount is too big.

4

Test the withdraw method and catch the exception

Create a public class called Main with a main method. Inside main, create a BankAccount object with a balance of 100. Use a try-catch block to call withdraw(150) on the account. Catch InsufficientFundsException and print the exception message.

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;
    }
}

// Your code here

Hint

Use a try-catch block to call withdraw and catch InsufficientFundsException. Print the exception message with e.getMessage().

Practice

1. Why do we need custom exceptions in Java?
public class MyException extends Exception {}

easy

A. To avoid using try-catch blocks

B. To replace all built-in exceptions with new ones

C. To make the program run faster

D. To create specific error types that describe unique problems

Solution

1. Step 1: Understand the purpose of custom exceptions

   Custom exceptions allow programmers to define errors that are specific to their application's needs, making error handling clearer.

2. Step 2: Compare with other options

   Replacing all built-in exceptions or avoiding try-catch blocks is not the goal. Custom exceptions do not improve speed directly.

3. Final Answer:

   To create specific error types that describe unique problems -> Option D

4. Quick Check:

   Custom exceptions = Specific error types [OK]

Hint: Custom exceptions describe unique problems clearly [OK]

Common Mistakes:

• Thinking custom exceptions speed up the program
• Believing they replace all built-in exceptions
• Assuming they remove the need for try-catch

2. Which of the following is the correct way to declare a custom checked exception in Java?

easy

A. class MyException extends RuntimeException {}

B. class MyException extends Error {}

C. class MyException extends Exception {}

D. class MyException extends Throwable {}

Solution

1. Step 1: Identify checked exceptions

   Checked exceptions in Java must extend Exception but not RuntimeException.

2. Step 2: Analyze each option

   Extending RuntimeException creates an unchecked exception. Extending Error is for system errors. Extending Exception creates a checked exception. Extending Throwable is too general.

3. Final Answer:

   class MyException extends Exception {} -> Option C

4. Quick Check:

   Checked exceptions extend Exception [OK]

Hint: Checked exceptions extend Exception class [OK]

Common Mistakes:

• Confusing checked and unchecked exceptions
• Extending Error instead of Exception
• Extending Throwable directly

3. What will be the output of this code?

class MyException extends Exception {}

public class Test {
  public static void check(int num) throws MyException {
    if (num < 0) throw new MyException();
    else System.out.println("Number is " + num);
  }

  public static void main(String[] args) {
    try {
      check(-5);
    } catch (MyException e) {
      System.out.println("Caught MyException");
    }
  }
}

medium

A. Caught MyException

B. Number is -5

C. Compilation error

D. No output

Solution

1. Step 1: Understand the check method behavior

   If the number is less than 0, it throws MyException. Since -5 < 0, exception is thrown.

2. Step 2: Analyze main method's try-catch

   The exception is caught in the catch block, which prints "Caught MyException".

3. Final Answer:

   Caught MyException -> Option A

4. Quick Check:

   Exception thrown and caught = "Caught MyException" [OK]

Hint: Exception thrown for negative, caught prints message [OK]

Common Mistakes:

• Expecting negative number print instead of exception
• Thinking code won't compile due to throws
• Missing catch block effect

4. Identify the error in this custom exception class:

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

medium

A. Class should extend RuntimeException instead

B. Missing call to super(message) in constructor

C. Constructor should not have parameters

D. No error, code is correct

Solution

1. Step 1: Check constructor call to superclass

   The constructor takes a message but calls super() without passing it, so the message is lost.

2. Step 2: Correct usage of super constructor

   It should call super(message) to pass the error message to the Exception class.

3. Final Answer:

   Missing call to super(message) in constructor -> Option B

4. Quick Check:

   Pass message to super constructor [OK]

Hint: Pass message to super() in constructor [OK]

Common Mistakes:

• Calling super() without message
• Changing exception type unnecessarily
• Removing constructor parameters

5. You want to create a custom exception that handles invalid user input differently from other errors. Which approach best supports this goal?

hard

A. Create a custom exception class extending Exception and catch it separately

B. Use only built-in exceptions and catch all in one block

C. Throw RuntimeException with a custom message

D. Avoid exceptions and use error codes instead

Solution

1. Step 1: Understand the need for specific error handling

   To handle invalid input differently, a distinct exception type is needed.

2. Step 2: Choose the best design

   Creating a custom exception extending Exception allows catching it separately and handling it clearly.

3. Final Answer:

   Create a custom exception class extending Exception and catch it separately -> Option A

4. Quick Check:

   Custom exception + separate catch = clear handling [OK]

Hint: Custom exception + separate catch block for clarity [OK]

Common Mistakes:

• Using only built-in exceptions for all errors
• Throwing RuntimeException without clarity
• Avoiding exceptions and complicating code