{"id":2304,"date":"2021-07-15T03:23:41","date_gmt":"2021-07-15T03:23:41","guid":{"rendered":"https:\/\/phptutorial.net\/?page_id=2304"},"modified":"2021-07-15T03:23:43","modified_gmt":"2021-07-15T03:23:43","slug":"php-anonymous-class","status":"publish","type":"page","link":"https:\/\/www.phptutorial.net\/php-oop\/php-anonymous-class\/","title":{"rendered":"PHP Anonymous Class"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn how about the PHP anonymous class and how to define anonymous classes.<\/p>\n\n\n\n

Introduction to the PHP anonymous classes #<\/a><\/h2>\n\n\n\n

So far, you have learned how to define a new class<\/a> with a name. For example:<\/p>\n\n\n

<?php<\/span>\n\nclass<\/span> MyClass<\/span> \n<\/span>{\n    \/\/ ...<\/span>\n}<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
The MyClass<\/code> is called a named class.<\/p>\n\n\n\n
An anonymous class is a class without a declared name. The following creates an object of anonymous class:<\/p>\n\n\n
<?php<\/span>\n\n$myObject = new<\/span> class<\/span> <\/span>{\n    \/\/ ...<\/span>\n};<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
In this syntax, you place the class<\/code> keyword after the new<\/code> keyword. The $myObject<\/code> is the instance of the anonymous class.<\/p>\n\n\n\n
<?php<\/span>\n\n$logger = new<\/span> class<\/span> <\/span>{\n    public<\/span> function<\/span> log<\/span>(string $message)<\/span>: void<\/span>\n    <\/span>{\n        echo<\/span> $message . '<br>'<\/span>;\n    }\n};\n\n$logger->log('Hello'<\/span>);<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, create the $logger<\/code> object of the anonymous class that has one method log()<\/code> that displays a message with a 
<\/code> tag. <\/p>\n\n\n\n
Second, call the log()<\/code> method via the $logger<\/code> object.<\/p>\n\n\n\n
Internally, PHP generates a name for the anonymous class. To get the generated name, you can use the get_class()<\/code> function. For example:<\/p>\n\n\n
echo<\/span> get_class($logger);<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
index.php0000025F568665BE<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
PHP manages this class name internally. Therefore, you should not rely on it.<\/p>\n\n\n\n
Implementing an interface #<\/a><\/h2>\n\n\n\n
An anonymous can implement one or multiple interfaces<\/a>. For example:<\/p>\n\n\n
<?php<\/span>\n\ninterface<\/span> Logger<\/span>\n<\/span>{\n    public<\/span> function<\/span> log<\/span>(string $message)<\/span>: void<\/span><\/span>;\n}\n\n$logger = new<\/span> class<\/span> implements<\/span> Logger<\/span> <\/span>{\n    public<\/span> function<\/span> log<\/span>(string $message)<\/span>: void<\/span>\n    <\/span>{\n        echo<\/span> $message . '<br>'<\/span>;\n    }\n};\n\n$logger->log('Hello'<\/span>);<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we define the Logger<\/code> interface that has the log()<\/code> method. And then, we define an anonymous class that implements the Logger<\/code> interface.<\/p>\n\n\n\n
The $logger<\/code> is the instance of the Logger<\/code> interface:<\/p>\n\n\n
echo<\/span> $logger instanceof<\/span> Logger; \/\/ true<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Because an anonymous doesn’t have a declared name, you cannot use the type hint for its instance. <\/p>\n\n\n\n
However, when an anonymous class implements an interface, you can use the type hint via the interface. For example:<\/p>\n\n\n
<?php<\/span>\n\ninterface<\/span> Logger<\/span>\n<\/span>{\n    public<\/span> function<\/span> log<\/span>(string $message)<\/span>: void<\/span><\/span>;\n}\n\n$logger = new<\/span> class<\/span> implements<\/span> Logger<\/span> <\/span>{\n    public<\/span> function<\/span> log<\/span>(string $message)<\/span>: void<\/span>\n    <\/span>{\n        echo<\/span> $message . '<br>'<\/span>;\n    }\n};\n\n\/\/ type hint<\/span>\nfunction<\/span> save<\/span>(Logger $logger)<\/span>\n<\/span>{\n    $logger->log('The file was updated successfully.'<\/span>);\n}\n\nsave($logger);<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Inheriting a class #<\/a><\/h2>\n\n\n\n
Like a regular class, a class can inherit from one named class<\/a>. For example:<\/p>\n\n\n
<?php<\/span>\n\ninterface<\/span> Logger<\/span>\n<\/span>{\n    public<\/span> function<\/span> log<\/span>(string $message)<\/span>: void<\/span><\/span>;\n}\n\nabstract<\/span> class<\/span> SimpleLogger<\/span> implements<\/span> Logger<\/span>\n<\/span>{\n    protected<\/span> $newLine;\n\n    public<\/span> function<\/span> __construct<\/span>(bool $newLine)<\/span>\n    <\/span>{\n        $this<\/span>->newLine = $newLine;\n    }\n\n    abstract<\/span> public<\/span> function<\/span> log<\/span>(string $message)<\/span>: void<\/span><\/span>;\n}\n\n$logger = new<\/span> class<\/span>(true<\/span>) extends<\/span> SimpleLogger<\/span> <\/span>{\n    public<\/span> function<\/span> __construct<\/span>(bool $newLine)<\/span>\n    <\/span>{\n        parent<\/span>::__construct($newLine);\n    }\n\n    public<\/span> function<\/span> log<\/span>(string $message)<\/span>: void<\/span>\n    <\/span>{\n        echo<\/span> $this<\/span>->newLine ? $message . PHP_EOL : $message;\n    }\n};\n\n$logger->log('Hello'<\/span>);\n$logger->log('Bye'<\/span>);<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, define an interface called Logger that has one method log()<\/code>.<\/p>\n\n\n\n
Second, define an abstract class called SimpleLogger<\/code> that implements the Logger<\/code> interface.<\/p>\n\n\n\n
Third, define an anonymous class that extends the SimpleLogger<\/code> class. We call the constructor of the SimpleLogger<\/code> class in the constructor of the anonymous class.<\/p>\n\n\n\n
To pass an argument to the constructor, we place it in parentheses that follow the class<\/code> keyword.<\/p>\n\n\n\n
Finally, call the log()<\/code> method of the $logger<\/code> object.<\/p>\n\n\n\n
When to use anonymous classes #<\/a><\/h2>\n\n\n\n
Anonymous classes are helpful in some cases:<\/p>\n\n\n\n
First, anonymous classes make it easy to mock tests. Note that you’ll learn about unit testing with PHPUnit later.<\/p>\n\n\n\n
Second, anonymous classes keep their usage outside the scope where they are defined. For example, instead of doing this:<\/p>\n\n\n
<?php<\/span>\n\nclass<\/span> ConsoleLogger<\/span> \n<\/span>{\n    public<\/span> function<\/span> log<\/span>($message)<\/span> \n    <\/span>{\n        echo<\/span> $message . PHP_EOL;\n    }\n}\n\n$obj->setLogger(new<\/span> ConsoleLogger());<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Now, you can make use the an anonymous class like this:<\/p>\n\n\n
$obj->setLogger(new<\/span> class<\/span> <\/span>{\n    public<\/span> function<\/span> log<\/span>($msg)<\/span> <\/span>{\n       echo<\/span> $message . PHP_EOL;\n    }\n});<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Summary #<\/a><\/h2>\n\n\n\n
  • An anonymous class is a class without a declared name.<\/li><\/ul>\n
    \n\t
    \n\t\t
    Did you find this tutorial useful?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t\n\t\t\t
Third, make a small optimization by avoid hitting the autoloader<\/a> for trivial classes.<\/p>\n\n\n\n
Inside the parentheses, you can define constructor<\/a>, destructor<\/a>, properties, and methods for the anonymous class like a regular class. For example:<\/p>\n\n\n