Constructor in PHP

A constructor is a special function in a PHP class that is automatically called when an object of that class is created. It allows you to initialize the object's properties or perform any setup tasks when an object is instantiated. Constructors are typically used to assign values to the object's properties or perform operations that need to be done when an object is first created.

In PHP, constructors are defined using the __construct() method.

1. Syntax of Constructor in PHP

class ClassName {    // Constructor definition    public function __construct() {        // Code to initialize the object    }}

• __construct(): This is the special method that is automatically called when a new object of the class is created.

• The constructor doesn't return any value (not even void), and its purpose is to initialize the object.

2. Creating a Constructor

Example 1: Basic Constructor

<?phpclass Car {    public $model;    public $color;    // Constructor method to initialize properties    public function __construct($model, $color) {        $this->model = $model;        $this->color = $color;    }    // Display car information    public function display() {        echo "Car model: " . $this->model . "<br>";        echo "Car color: " . $this->color . "<br>";    }}// Creating an object of the Car class$car1 = new Car("Toyota", "Red");$car1->display();?>

Explanation:

• The constructor takes two arguments: $model and $color.

• These arguments are used to set the properties of the object.

• The display() method shows the values of the object's properties.

Output:

Car model: ToyotaCar color: Red

3. Constructor with Default Values

You can set default values for constructor parameters, making them optional when creating an object.

Example 2: Constructor with Default Parameters

<?phpclass Car {    public $model;    public $color;    // Constructor with default values    public function __construct($model = "Default Model", $color = "Black") {        $this->model = $model;        $this->color = $color;    }    public function display() {        echo "Car model: " . $this->model . "<br>";        echo "Car color: " . $this->color . "<br>";    }}// Creating objects with and without parameters$car1 = new Car("Toyota", "Red");$car1->display();$car2 = new Car(); // Using default values$car2->display();?>

Output:

Car model: ToyotaCar color: RedCar model: Default ModelCar color: Black

Explanation:

• In the second case, no arguments are passed to the constructor, so the default values ("Default Model" and "Black") are used.

4. Constructor with parent::__construct()

If you're using inheritance, you may need to call a constructor of the parent class using parent::__construct().

Example 3: Constructor in Inherited Class

<?phpclass Vehicle {    public $type;    public function __construct($type) {        $this->type = $type;    }    public function display() {        echo "Vehicle type: " . $this->type . "<br>";    }}class Car extends Vehicle {    public $model;    // Child class constructor    public function __construct($type, $model) {        parent::__construct($type);  // Call the parent class constructor        $this->model = $model;    }    public function display() {        parent::display();  // Call parent class display method        echo "Car model: " . $this->model . "<br>";    }}$car = new Car("Sedan", "Toyota");$car->display();?>

Output:

Vehicle type: SedanCar model: Toyota

Explanation:

• The child class (Car) calls the parent class constructor using parent::__construct($type) to initialize the type property.

• The child class also defines its own constructor to initialize its own property (model).

5. Constructor Visibility

The visibility of the constructor can be controlled like any other method in PHP. It can be public, private, or protected:

• public: The constructor can be called from anywhere (this is the default visibility).

• private: The constructor can only be called within the class. This is typically used in the Singleton design pattern.

• protected: The constructor can be called within the class or by subclasses.

Example 4: Private Constructor

<?phpclass Singleton {    private static $instance;    // Private constructor to prevent direct instantiation    private function __construct() {        echo "Singleton instance created.<br>";    }    // Static method to get the single instance of the class    public static function getInstance() {        if (self::$instance === null) {            self::$instance = new Singleton();        }        return self::$instance;    }}// $singleton = new Singleton(); // This will cause an error$singleton1 = Singleton::getInstance();  // Correct way to get the instance$singleton2 = Singleton::getInstance();  // This will return the same instance?>

Output:

Singleton instance created.

Explanation:

• The constructor is private, so you cannot directly instantiate the class.

• The getInstance() method ensures that only one instance of the class is created, following the Singleton design pattern.

6. Destructors in PHP

In addition to constructors, PHP also provides a destructor, which is called when an object is destroyed. The destructor is defined using the __destruct() method.

Example of Destructor:

<?phpclass Car {    public $model;    public function __construct($model) {        $this->model = $model;    }    public function __destruct() {        echo "The car {$this->model} is being destroyed.<br>";    }}$car = new Car("Toyota");// Destructor will be automatically called when the object is destroyed (end of script)?>

Output (upon script end):

The car Toyota is being destroyed.

Summary

• The constructor (__construct()) is used to initialize an object when it is created.

• Parameters can be passed to the constructor to initialize properties.

• The parent constructor can be called using parent::__construct() in a subclass.

• Constructors can be public, private, or protected to control visibility.

• Destructors (__destruct()) allow cleanup when an object is destroyed.