The release of version 7.0 is an important milestone in the evolution of PHP language, when a lot of new features were introduced. The feature of Anonymous class was also made available in PHP version 7.0.
As the term “anonymous” suggests, it is a class without a (programmer declared) name. The usual practice is to define a class with a certain identifier, so that it can be used repeatedly. The anonymous class, on the other hand is for one-time use only.
Here are the covered topics in this chapter −
- Creating an Anonymous Class in PHP
- Using Methods in an Anonymous Class
- Anonymous Class as a Child Class
- Dependencies to an Anonymous Class
Creating an Anonymous Class in PHP
Here is how you can create a basic anonymous class in PHP −
$obj=newclass(){/* class body */};
Apart from this class not having a name, it is similar to a normal named class, in the sense it can contain properties and methods. Its functionality is no different from that of an object of a named class.
An anonymous class might be used over a named class especially when the class does not need to be documented, and when the class is used only once during execution. Anonymous classes are useful when simple, one-off objects need to be created.
Using Methods in an Anonymous Class
In the following code, an anonymous class is instantiated and stored in $obj object. The class includes definitions of addition() and division() methods, which are called with the $obj object.
<?php
$obj = new class(10) {
private int $x;
function __construct($x) {
$this->x = $x;
}
public function addition($x) {
return $this->x+$x;
}
public function division($x) {
return $this->x/$x;
}
};
echo "Addition: " . $obj->addition(20) . PHP_EOL;
echo "Division: " . $obj->division(20) . PHP_EOL;
?>
Output
It will produce the following output −
Addition: 30 Division: 0.5
Anonymous Class as a Child Class
An anonymous class can do everything that a normal class can. It can extends another class, implement an interface or even use a trait.
Example
In the example below, the anonymous class is a child class, extending a parent already available.
<?php
class myclass {
public function hello() {
echo "Hello World!" . PHP_EOL;
}
}
$obj = new class("Neena") extends myclass {
private string $nm;
function __construct($x) {
$this->nm = $x;
}
public function greeting() {
parent::hello();
echo "Welcome " . $this->nm . PHP_EOL;
}
};
$obj->greeting();
?>
Output
It will produce the following output −
Hello World! Welcome Neena
Example: Internal Name of an Anonymous Class
Although the anonymous class doesn’t have any user defined name, PHP does assign it an internal name, which can be obtained with the built-in get_class() function as follows −
<?php
$obj = new class() {
function greeting() {
echo "Hello World" . PHP_EOL;
}
};
$obj->greeting();
echo "Name of class: " . get_class($obj);
?>
Output
It will produce the following output −
Hello World Name of class: class@anonymousC:\xampp\htdocs\hello.php:2$0
PHP parser assigns the internal name randomly.
Dependencies to an Anonymous Class
Dependencies can be sent to an anonymous class via its constructor, making it suitable for dynamic, one-time use cases. This shows how to inject a logger or another service directly into an anonymous class, which is useful for small, temporary tasks.
<?php
class Logger {
public function log($message) {
echo "Log: " . $message . PHP_EOL;
}
}
$logger = new Logger();
$obj = new class($logger) {
private $logger;
public function __construct($logger) {
$this->logger = $logger;
}
public function doSomething() {
$this->logger->log("Doing something important!");
}
};
$obj->doSomething();
?>
Output
Here is the outcome of the following code −
Log: Doing something important!
