Custom exception classes in PHP - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a custom exception class in PHP?

A custom exception class in PHP is a user-defined class that extends the built-in Exception class. It allows you to create specific error types for your application, making error handling clearer and more organized.

beginner

How do you define a custom exception class in PHP?

You define a custom exception class by creating a new class that extends the Exception class. For example:<br><pre>class MyException extends Exception {}</pre>

intermediate

Why use custom exception classes instead of the base Exception class?

Custom exception classes help you identify and handle specific error types separately. This makes your code easier to read and maintain, and allows different actions for different error conditions.

beginner

How can you catch a custom exception in PHP?

You catch a custom exception by using a try-catch block and specifying the custom exception class in the catch statement. For example:<br><pre>try {<br>  // code<br>} catch (MyException $e) {<br>  // handle MyException<br>}</pre>

intermediate

Can custom exception classes have their own methods and properties?

Yes, custom exception classes can have additional methods and properties to provide more information or functionality related to the specific error they represent.

How do you create a custom exception class in PHP?

A By importing a special library

B By extending the Exception class

C By using the throw keyword alone

D By creating a function named Exception

Custom exception classes are created by extending the built-in Exception class.

Which keyword is used to handle exceptions in PHP?

A catch

B handle

C try

D throw

The catch keyword is used to handle exceptions after a try block.

What is the benefit of using custom exception classes?

A They make code run faster

B They automatically fix errors

C They replace the need for try-catch

D They allow specific error handling

Custom exceptions allow you to handle different errors specifically and clearly.

Which of these is a valid way to catch a custom exception named MyException?

A catch (Error $e) {}

B catch (Exception $e) {}

C catch (MyException $e) {}

D catch (Throwable $e) {}

To catch a custom exception, you specify its class name in the catch block.

Can custom exception classes have extra methods?

A Yes, to add more info or behavior

B No, they must only inherit Exception

C Only if they are abstract

D Only if they don't extend Exception

Custom exception classes can have their own methods and properties.

Explain how to create and use a custom exception class in PHP.

Think about how you make a new class and how you handle errors.

Why might you want to create your own exception classes instead of using the default Exception?

Consider how different problems might need different solutions.

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