Why custom exceptions are needed in Java - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of Custom Exceptions in Java

Why do developers create custom exceptions instead of using only built-in exceptions?

A To provide more specific error information related to the application domain

B Because Java does not have any built-in exceptions

C To make the program run faster by avoiding built-in exceptions

D To reduce the size of the compiled Java program

💡 Hint

Think about how custom exceptions help in understanding errors better.

Custom exceptions allow programmers to signal specific problems related to their application's logic, making error handling clearer and more meaningful.

❓ Predict Output

intermediate

Output of Custom Exception Handling

What will be the output of this Java code?

Java

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

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

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

A Runtime error: NullPointerException

B Number is -5

C Negative number not allowed

D Compilation error due to missing exception handling

💡 Hint

Look at what happens when num is less than zero.

The method throws a custom exception when the number is negative, which is caught and its message printed.

🔧 Debug

advanced

Identify the Error in Custom Exception Usage

What error will this Java code produce when compiled?

Java

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

public class Test {
    public static void check(int num) {
        if (num < 0) {
            throw new MyException("Negative number");
        }
    }
}

A Runtime error: MyException thrown but not caught

B Compilation error: unhandled exception MyException

C No error, code compiles and runs fine

D Compilation error: MyException class not found

💡 Hint

Check if the method declares the exception it throws.

Since MyException extends Exception (checked exception), the method must declare it with 'throws' or handle it.

📝 Syntax

advanced

Correct Syntax to Define a Custom Exception

Which option shows the correct way to define a custom checked exception in Java?

A

class MyException extends RuntimeException {
    public MyException(String msg) {
        super(msg);
    }
}

B

class MyException {
    public MyException(String msg) {
        super(msg);
    }
}

C

class MyException extends Throwable {
    public MyException(String msg) {
        super(msg);
    }
}

D

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

💡 Hint

Checked exceptions must extend Exception but not RuntimeException.

Option D correctly extends Exception and calls the superclass constructor with a message.

🚀 Application

expert

Custom Exception Usage in Application Logic

Given this scenario: You want to signal a specific error when a user tries to withdraw more money than their account balance. Which custom exception usage is best to handle this?

A Create a custom checked exception 'InsufficientFundsException' and throw it when withdrawal amount exceeds balance

B Throw a generic Exception with a message 'Insufficient funds' without creating a custom exception

C Use built-in NullPointerException to indicate insufficient funds

D Use RuntimeException without a custom class to signal insufficient funds

💡 Hint

Think about clarity and forcing the caller to handle the error.

A custom checked exception clearly signals the specific problem and forces handling, improving code safety and readability.