Creating custom exception class in Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a custom exception class named MyException.

Java

public class MyException extends [1] {
}

Drag options to blanks, or click blank then click option'

AException

BString

CError

DObject

Attempts:

3 left

💡 Hint

Common Mistakes

Extending String or Object instead of Exception.

Extending Error which is for serious JVM errors.

The custom exception class should extend the built-in Exception class to be a checked exception.

2fill in blank

medium

Complete the constructor to pass the error message to the superclass.

Java

public class MyException extends Exception {
    public MyException([1] message) {
        super(message);
    }
}

Drag options to blanks, or click blank then click option'

AString

Bint

Cboolean

Ddouble

Attempts:

3 left

💡 Hint

Common Mistakes

Using int or boolean instead of String for the message parameter.

The constructor takes a String message and passes it to the superclass constructor.

3fill in blank

hard

Fix the error in the constructor to correctly call the superclass constructor.

Java

public class MyException extends Exception {
    public MyException(String message) {
        [1](message);
    }
}

Drag options to blanks, or click blank then click option'

Athis

BMyException

Csuper

DException

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'this' instead of 'super' to call the parent constructor.

Calling the class name as a method.

The constructor must call super(message) to pass the message to the parent Exception class.

4fill in blank

hard

Fill both blanks to add a no-argument constructor that calls the superclass constructor with a default message.

Java

public class MyException extends Exception {
    public MyException() {
        [1]("[2] error occurred");
    }
}

Drag options to blanks, or click blank then click option'

Asuper

Bthis

CCustom

DDefault

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'this' instead of 'super' in the constructor.

Using an unclear or incorrect default message.

The no-argument constructor calls super with a default message string.

5fill in blank

hard

Fill all three blanks to add a constructor that accepts a message and a cause, passing both to the superclass.

Java

public class MyException extends Exception {
    public MyException([1] message, [2] cause) {
        [3](message, cause);
    }
}

Drag options to blanks, or click blank then click option'

AString

BThrowable

Csuper

DException

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong types for message or cause.

Not calling the superclass constructor properly.

The constructor takes a String message and a Throwable cause, then calls super(message, cause).

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