PHP OOP Constructor: How It Works in a Class

A PHP OOP constructor initializes an object when it is created. In this article, we will cover the following topics:

• PHP constructor definition.
• How it works.
• Passing parameters to a constructor.
• Default values in a constructor.
• Constructors and inheritance.
• Examples.

Let’s start with the definition.

Understand What a Constructor Is in PHP

A constructor in PHP is a special method inside a class that runs automatically when an object is created. It has the name __construct(). You use it for the following reasons:

• Set default values.
• Establish database connections
• Prepare other resources when an object is initialized.

This helps reduce code repetition and improves your program’s performance. It also automates setup tasks when it creates multiple objects.

Here is the basic syntax of a constructor:

class TheClassName {
    public function __construct() {
        // Here the initialization code
    }
}

Let’s move on to the following section to take a look at how it works.

How a Constructor Works

It executes on its own when an object is instantiated. Here is how it works:

• Defines initialization code – The constructor method (__construct) is inside a class. It contains code that runs when an object is created.
• Accepts parameters – You can pass values to the constructor, which it assigns to properties.
• Runs automatically – PHP calls the constructor without needing extra steps when you create an object.

Here is an example:

class Animal {
    public $name;
    public $species;

    public function __construct($name, $species) {
        $this->name = $name;
        $this->species = $species;
    }

    public function getDetails() {
        return "Name: $this->name, Species: $this->species";
    }
}

$animal1 = new Animal("Leo", "Lion");
echo $animal1->getDetails(); 

Here is the output:

Name: Leo, Species: Lion

How it works:

1. The Animal class has two properties: $name and $species.
2. The __construct() method takes two arguments and assigns them to the object’s properties.
3. getDetails() method returns a formatted string with the animal’s details.
4. When $animal1 = new Animal("Leo", "Lion"); runs, the constructor sets $name to "Leo" and $species to "Lion".
5. The echo $animal1->getDetails(); statement prints "Name: Leo, Species: Lion".

Let’s move on to the following section to understand how to use default values in the PHP constructor.

How to Pass Default Values in Constructors

You can set default values in a PHP constructor and assign values to parameters. This lets you create objects, and you don’t need to set arguments with it.

Here is an example:

class Food {
    public $name;
    public $category;

    public function __construct($name = "Unknown", $category = "Unknown") {
        $this->name = $name;
        $this->category = $category;
    }

    public function getDetails() {
        return "Name: $this->name, Category: $this->category";
    }
}

$food1 = new Food("Pizza", "Fast Food");
$food2 = new Food();

echo $food1->getDetails();
echo $food2->getDetails();

The output:

Name: Pizza, Category: Fast FoodName: Unknown, Category: Unknown

Here is how it works:

1. Properties:
   • $name stores the name of the food.
   • $category stores the category of the food.
2. Constructor (__construct method):
   • This method runs when a new Food object is created.
   • It assigns values to $name and $category.
   • It uses "Unknown" as the default if no values are provided.
3. Method (getDetails):
   • Returns a string with the food name and category.
4. Creating objects ($food1 and $food2):
   • $food1 = new Food("Pizza", "Fast Food"); → Assigns “Pizza” and “Fast Food” to $name and $category.
   • $food2 = new Food(); → Uses the default values "Unknown" for both properties.
5. Output:
   • echo $food1->getDetails(); → Displays: Name: Pizza, Category: Fast Food
   • echo $food2->getDetails(); → Displays: Name: Unknown, Category: Unknown.

Let’s move on to the following section to see how overloading works with PHP constructors.

Constructor Overloading in PHP OOP

Constructor overloading refers to multiple constructors with different argument lists. PHP does not support multiple constructors directly. You can achieve similar functionality with argument-handling methods such as:

• Default Values.
• func_get_args().
• Named Parameters (PHP 8.0+).
• Factory methods.

Here is an example of factory methods.

class Machine {
    private $type;
    private $power;
    private $manufacturer;
 
    private function __construct() {
        // Shared initialization logic (if needed)
    }
 
    public static function createWithType($type) {
        $machine = new self();
        $machine->type = $type;
        return $machine;
    }
 
    public static function createWithTypeAndPower($type, $power) {
        $machine = new self();
        $machine->type = $type;
        $machine->power = $power;
        return $machine;
    }
   
    public static function createFullMachine($type, $power, $manufacturer) {
        $machine = new self();
        $machine->type = $type;
        $machine->power = $power;
        $machine->manufacturer = $manufacturer;
        return $machine;
    }

    public function display() {
        echo "Type: {$this->type}, Power: {$this->power}, Manufacturer: {$this->manufacturer}\n";
    }
}

$basicMachine = Machine::createWithType("Drill");
$basicMachine->display();  

$advancedMachine = Machine::createWithTypeAndPower("Lathe", 1500);
$advancedMachine->display();  

$fullMachine = Machine::createFullMachine("Press", 3000, "MegaCorp");
$fullMachine->display(); 

Output:

Type: Drill, Power: , Manufacturer: 
Type: Lathe, Power: 1500, Manufacturer: 
Type: Press, Power: 3000, Manufacturer: MegaCorp

Here is how it works:

The code uses the Factory Pattern to simulate constructor overloading in PHP. The private constructor prevents direct object creation. ensures all instances are made through three static factory methods:

1. createWithType() – Initializes a machine with only a type.
2. createWithTypeAndPower() – Adds both type and power.
3. createFullMachine() – Includes type, power, and manufacturer.

Each method calls the private constructor. It sets the properties and returns the object. The display() method outputs the object’s details.

In the following section, you will understand how to call parent constructors within inheritance.

How to Call Parent Constructors in Inheritance

You call a parent class constructor with the parent::__construct() method. This is useful when a child class needs to initialize properties or behaviors defined in the parent class.

Here is an example:

class Machine {
    protected $type;

    public function __construct($type) {
        $this->type = $type;
    }
}

class Car extends Machine {
    private $brand;

    public function __construct($type, $brand) {
        parent::__construct($type);  
        $this->brand = $brand;
    }

    public function display() {
        echo "Type: {$this->type}, Brand: {$this->brand}\n";
    }
}

$car = new Car("Vehicle", "Toyota");
$car->display(); 

Here is the output:

Type: Vehicle, Brand: Toyota

Here is how it works:

1. parent::__construct() calls the parent class constructor.
2. The child class adds its own initialization after calling the parent.

Wrapping Up

You learned how the PHP OOP constructor works in PHP and how to use it in object-oriented programming. Here’s a quick recap:

A constructor in PHP is a special method called __construct() that runs automatically when an object is created. It is used to do the following:

• Initialize object properties.
• Set default values.
• Establish database connections.
• Prepare other resources.

Here are the key takeaways:

• Automatic execution: The __construct() method is executed automatically when you create an object.
• Pass parameters: You can pass arguments to the constructor to initialize object properties.
• Default values: Constructors can have default parameter values.
• Constructor overloading: PHP does not support multiple constructors, but you can simulate it with factory methods or default parameters.
• Inheritance: Use parent::__construct() to call a parent class’s constructor within a child class.

FAQ’s

class Machine {
    public function __construct($type) {
        $this->type = $type;
    }
}

class Car extends Machine {
    public function __construct($type, $brand) {
        parent::__construct($type);
        $this->brand = $brand;
    }
}