Custom exception classes in PHP - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

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

PHP

<?php
class MyException extends [1] {
}
?>

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

ARuntimeException

BError

CThrowable

DException

Attempts:

3 left

💡 Hint

Common Mistakes

Extending a class that is not an exception base class.

Forgetting to extend any class.

The custom exception class must extend the built-in Exception class to behave like an exception.

2fill in blank

medium

Complete the code to throw a custom exception named MyException with the message 'Error occurred'.

PHP

<?php
throw new [1]('Error occurred');
?>

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

AMyException

BError

CException

DRuntimeException

Attempts:

3 left

💡 Hint

Common Mistakes

Throwing the base Exception instead of the custom one.

Using a class name that does not exist.

To throw the custom exception, use its class name MyException.

3fill in blank

hard

Fix the error in the code to catch the custom exception MyException.

PHP

<?php
try {
    // some code
} catch ([1] $e) {
    echo $e->getMessage();
}
?>

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

AMyException

BError

CException

DThrowable

Attempts:

3 left

💡 Hint

Common Mistakes

Catching the base Exception instead of the custom one.

Using a wrong class name in catch.

To catch the custom exception, the catch block must specify MyException.

4fill in blank

hard

Fill both blanks to define a custom exception class with a constructor that sets a default message.

PHP

<?php
class MyException extends [1] {
    public function __construct() {
        parent::[2]('Default error message');
    }
}
?>

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

AException

BError

C__construct

Dthrow

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong parent class.

Calling a method other than __construct.

The class extends Exception and calls the parent constructor __construct with a message.

5fill in blank

hard

Fill all three blanks to throw and catch a custom exception, then print its message.

PHP

<?php
class MyException extends Exception {}

try {
    throw new [1]('Custom error');
} catch ([2] $e) {
    echo [3];
}
?>

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

AException

BMyException

C$e->getMessage()

DError

Attempts:

3 left

💡 Hint

Common Mistakes

Throwing and catching different exception classes.

Printing the exception variable directly instead of calling getMessage().

The code throws and catches MyException and prints the exception message using $e->getMessage().

Practice

1.

What is the main purpose of creating a custom exception class in PHP?

easy

A. To define specific error types for clearer error handling

B. To replace the built-in Exception class completely

C. To speed up the execution of the program

D. To automatically fix errors in the code

Solution

1. Step 1: Understand the role of custom exceptions

   Custom exceptions allow programmers to create specific error types that represent particular problems in the code.

2. Step 2: Compare with other options

   Custom exceptions do not replace the built-in Exception class, nor do they speed up execution or fix errors automatically.

3. Final Answer:

   To define specific error types for clearer error handling -> Option A

4. Quick Check:

   Custom exceptions = Specific error types [OK]

Hint: Custom exceptions clarify errors by type, not fix or speed [OK]

Common Mistakes:

• Thinking custom exceptions replace built-in Exception
• Believing custom exceptions fix errors automatically
• Assuming custom exceptions improve performance

2.

Which of the following is the correct way to declare a custom exception class named MyError in PHP?

?

easy

A. class MyError extends Error {}

B. class MyError implements Exception {}

C. class MyError extends Exception {}

D. class MyError inherits Exception {}

Solution

1. Step 1: Recall PHP syntax for custom exceptions

   Custom exceptions extend the built-in Exception class using the keyword extends.

2. Step 2: Check each option

   class MyError extends Exception {} correctly uses extends Exception. class MyError implements Exception {} wrongly uses implements, which is for interfaces. class MyError extends Error {} extends Error, which is a different base class. class MyError inherits Exception {} uses invalid syntax inherits.

3. Final Answer:

   class MyError extends Exception {} -> Option C

4. Quick Check:

   Custom exception syntax = extends Exception [OK]

Hint: Use 'extends Exception' to create custom exceptions [OK]

Common Mistakes:

• Using 'implements' instead of 'extends'
• Using 'inherits' keyword which is invalid
• Extending Error instead of Exception

3.

What will be the output of the following PHP code?

class MyException extends Exception {}

try {
    throw new MyException("Custom error happened");
} catch (MyException $e) {
    echo $e->getMessage();
} catch (Exception $e) {
    echo "General error";
}

medium

A. Custom error happened

B. General error

C. Fatal error: Uncaught exception

D. No output

Solution

1. Step 1: Understand the thrown exception type

   The code throws an exception of type MyException.

2. Step 2: Check catch blocks order and matching

   The first catch block matches MyException, so it catches the exception and echoes the message.

3. Final Answer:

   Custom error happened -> Option A

4. Quick Check:

   Matching catch block runs = Custom message [OK]

Hint: Catch specific exceptions before general ones [OK]

Common Mistakes:

• Expecting general catch to run first
• Thinking exception is uncaught
• Ignoring exception message

4.

Identify the error in this PHP code that defines and uses a custom exception:

class MyException extends Exception {}

try {
    throw new MyException("Error!");
} catch (Exception $e) {
    echo $e->getMessage();
} catch (MyException $e) {
    echo "Caught MyException";
}

medium

A. No error; code runs fine

B. The catch blocks are in wrong order; specific should come before general

C. The throw statement syntax is incorrect

D. The class should implement Exception interface

Solution

1. Step 1: Analyze catch block order

   The first catch block catches all Exception types, including MyException, so the second catch block is unreachable.

2. Step 2: Correct catch order

   Specific exceptions like MyException must be caught before the general Exception to avoid unreachable code.

3. Final Answer:

   The catch blocks are in wrong order; specific should come before general -> Option B

4. Quick Check:

   Specific catch before general catch [OK]

Hint: Catch specific exceptions before general ones to avoid unreachable code [OK]

Common Mistakes:

• Placing general catch before specific catch
• Thinking implements is needed for exceptions
• Misunderstanding throw syntax

5.

Given this custom exception class and code, what will be the output?

class ValidationException extends Exception {
    public function getCustomMessage() {
        return "Validation failed: " . $this->getMessage();
    }
}

try {
    throw new ValidationException("Invalid input");
} catch (ValidationException $e) {
    echo $e->getCustomMessage();
} catch (Exception $e) {
    echo "General error";
}

hard

A. Fatal error: Call to undefined method

B. Invalid input

C. General error

D. Validation failed: Invalid input

Solution

1. Step 1: Understand the custom method in exception

   The class ValidationException adds a method getCustomMessage() that returns a formatted message.

2. Step 2: Check which catch block runs and output

   The thrown exception is ValidationException, so the first catch block runs and echoes the custom message.

3. Final Answer:

   Validation failed: Invalid input -> Option D

4. Quick Check:

   Custom method called on caught exception [OK]

Hint: Call custom methods on caught custom exceptions [OK]

Common Mistakes:

• Expecting default getMessage() output only
• Thinking general catch block runs first
• Assuming method does not exist