Anonymous Classes

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-&gt;x = $x;
  }
  public function addition($x) {
     return $this-&gt;x+$x;
  }
  public function division($x) {
     return $this-&gt;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-&gt;nm = $x;
  }
  public function greeting() {
     parent::hello();
     echo "Welcome " . $this-&gt;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-&gt;logger = $logger;
  }
  public function doSomething() {
     $this-&gt;logger-&gt;log("Doing something important!");
  }
   };

   $obj->doSomething();
?>

Output

Here is the outcome of the following code −

Log: Doing something important!