A User defined Exception class can be defined by extending the built-in Exception class. The members and properties below, show what is accessible within the child class that derives from the built-in Exception class. ]]> If a class extends the built-in Exception class and re-defines the constructor, it is highly recommended that it also call parent::__construct() to ensure all available data has been properly assigned. The __toString() method can be overridden to provide a custom output when the object is presented as a string. Exceptions cannot be cloned. Attempting to clone an Exception will result in a fatal E_ERROR error. code}]: {$this->message}\n"; } public function customFunction() { echo "A custom function for this type of exception\n"; } } /** * Create a class to test the exception */ class TestException { public $var; const THROW_NONE = 0; const THROW_CUSTOM = 1; const THROW_DEFAULT = 2; function __construct($avalue = self::THROW_NONE) { switch ($avalue) { case self::THROW_CUSTOM: // throw custom exception throw new MyException('1 is an invalid parameter', 5); break; case self::THROW_DEFAULT: // throw default one. throw new Exception('2 is not allowed as a parameter', 6); break; default: // No exception, object will be created. $this->var = $avalue; break; } } } // Example 1 try { $o = new TestException(TestException::THROW_CUSTOM); } catch (MyException $e) { // Will be caught echo "Caught my exception\n", $e; $e->customFunction(); } catch (Exception $e) { // Skipped echo "Caught Default Exception\n", $e; } // Continue execution var_dump($o); // Null echo "\n\n"; // Example 2 try { $o = new TestException(TestException::THROW_DEFAULT); } catch (MyException $e) { // Doesn't match this type echo "Caught my exception\n", $e; $e->customFunction(); } catch (Exception $e) { // Will be caught echo "Caught Default Exception\n", $e; } // Continue execution var_dump($o); // Null echo "\n\n"; // Example 3 try { $o = new TestException(TestException::THROW_CUSTOM); } catch (Exception $e) { // Will be caught echo "Default Exception caught\n", $e; } // Continue execution var_dump($o); // Null echo "\n\n"; // Example 4 try { $o = new TestException(); } catch (Exception $e) { // Skipped, no exception echo "Default Exception caught\n", $e; } // Continue execution var_dump($o); // TestException echo "\n\n"; ?> ]]> Versions of PHP 5, prior to PHP 5.3.0 do not support nesting of exceptions. The following code fragment can be used as a replacement MyException class if you wish to run this example. code}]: {$this->message}\n"; } public function customFunction() { echo "A custom function for this type of exception\n"; } } ?> ]]> PHP has an exception model similar to that of other programming languages. An exception can be &throw;n, and caught ("&catch;ed") within PHP. Code may be surrounded in a &try; block, to facilitate the catching of potential exceptions. Each &try; must have at least one corresponding &catch; or &finally; block. The thrown object must be an instance of the Exception class or a subclass of Exception. Trying to throw an object that is not will result in a PHP Fatal Error. Multiple &catch; blocks can be used to catch different classes of exceptions. Normal execution (when no exception is thrown within the &try; block) will continue after that last &catch; block defined in sequence. Exceptions can be &throw;n (or re-thrown) within a &catch; block. When an exception is thrown, code following the statement will not be executed, and PHP will attempt to find the first matching &catch; block. If an exception is not caught, a PHP Fatal Error will be issued with an "Uncaught Exception ..." message, unless a handler has been defined with set_exception_handler. In PHP 7.1 and later, a &catch; block may specify multiple exceptions using the pipe (|) character. This is useful for when different exceptions from different class hierarchies are handled the same. In PHP 5.5 and later, a &finally; block may also be specified after or instead of &catch; blocks. Code within the &finally; block will always be executed after the &try; and &catch; blocks, regardless of whether an exception has been thrown, and before normal execution resumes. One notable interaction is between the &finally; block and a &return; statement. If a &return; statement is encountered inside either the &try; or the &catch; blocks, the &finally; block will still be executed. Moreover, the &return; statement is evaluated when encountered, but the result will be returned after the &finally; block is executed. Additionaly, if the &finally; block also contains a &return; statement, the value from the &finally; block is returned. &reftitle.notes; Internal PHP functions mainly use Error reporting, only modern Object oriented extensions use exceptions. However, errors can be simply translated to exceptions with ErrorException. The Standard PHP Library (SPL) provides a good number of built-in exceptions. &reftitle.examples; getMessage(), "\n"; } // Continue execution echo "Hello World\n"; ?> ]]> &example.outputs; getMessage(), "\n"; } finally { echo "First finally.\n"; } try { echo inverse(0) . "\n"; } catch (Exception $e) { echo 'Caught exception: ', $e->getMessage(), "\n"; } finally { echo "Second finally.\n"; } // Continue execution echo "Hello World\n"; ?> ]]> &example.outputs; ]]> &example.outputs; getMessage()); } } } $foo = new Test; $foo->testing(); ?> ]]> &example.outputs; testing(); ?> ]]> &example.outputs;