• +91-9142290450

  • Hajipur, Bihar, 844101

☰
❮
❯

PHP Constructor

← Previous Next →

In PHP, constructors are special methods that automatically execute when an object is created. They are essential for initializing object properties, setting default values, or performing any setup tasks needed for the object. Understanding constructors is crucial for writing clean and efficient Object-Oriented PHP code.

What is a Constructor?

A constructor is a method inside a class that runs automatically when an object is instantiated. In PHP, constructors are defined using the __construct() method.

Key points about constructors:

  • They are automatically called when an object is created.

  • They are commonly used to initialize properties or execute startup tasks.

  • A class can have only one constructor in PHP.

  • Constructors can accept parameters to provide dynamic initialization.

Basic Example of a Constructor

class Car {
    public $brand;
    public $color;

    public function __construct($brand, $color) {
        $this->brand = $brand;
        $this->color = $color;
    }

    public function display() {
        echo "Car: " . $this->brand . " | Color: " . $this->color . "<br>";
    }
}

$car1 = new Car("Toyota", "Red");
$car2 = new Car("Honda", "Blue");

$car1->display(); // Outputs: Car: Toyota | Color: Red
$car2->display(); // Outputs: Car: Honda | Color: Blue

Here, the __construct() method initializes the properties brand and color when each object is created.

Constructors Without Parameters

You can also create constructors that don’t accept parameters. These are useful for setting default values:

class Student {
    public $name;
    public $grade;

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

    public function display() {
        echo "Name: " . $this->name . " | Grade: " . $this->grade . "<br>";
    }
}

$student = new Student();
$student->display(); // Outputs: Name: Unknown | Grade: 0

Constructors With Optional Parameters

You can also define optional parameters with default values in constructors.

Example:

class Book {
    public $title;
    public $author;

    public function __construct($title = "Untitled", $author = "Anonymous") {
        $this->title = $title;
        $this->author = $author;
    }

    public function display() {
        echo "Book: " . $this->title . " | Author: " . $this->author . "<br>";
    }
}

$book1 = new Book("1984", "George Orwell");
$book2 = new Book(); // Uses default values

$book1->display(); // Outputs: Book: 1984 | Author: George Orwell
$book2->display(); // Outputs: Book: Untitled | Author: Anonymous

Optional parameters make your constructor flexible and allow creating objects with or without specific data.

Constructor in Inheritance

When a child class extends a parent class, the parent constructor is not automatically called. You can explicitly call it using parent::__construct().

Example:

class Vehicle {
    public $brand;

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

class Bike extends Vehicle {
    public $type;

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

    public function display() {
        echo "Bike: " . $this->brand . " | Type: " . $this->type . "<br>";
    }
}

$bike = new Bike("Honda", "Sport");
$bike->display(); // Outputs: Bike: Honda | Type: Sport

This ensures that properties from the parent class are properly initialized.

Constructor in Interfaces and Abstract Classes

  • Interfaces cannot have constructors; implementing classes must define their own constructors.

  • Abstract classes can have constructors, which can be called by child classes using parent::__construct().

Using Constructors for Resource Initialization

Constructors are useful for initializing resources like database connections or file handlers:

class Database {
    private $connection;

    public function __construct($host, $user, $pass, $db) {
        $this->connection = new mysqli($host, $user, $pass, $db);
        if ($this->connection->connect_error) {
            die("Connection failed: " . $this->connection->connect_error);
        }
        echo "Connected successfully<br>";
    }

    public function getConnection() {
        return $this->connection;
    }
}

$db = new Database("localhost", "root", "", "test_db");

Here, the database connection is automatically established when the object is created.

Best Practices for Constructors

  1. Keep constructors simple – avoid complex logic; use them mainly for initialization.

  2. Use parameters wisely – pass only essential data needed for object setup.

  3. Call parent constructors when extending classes to ensure proper initialization.

  4. Avoid heavy operations like file uploads or API calls directly in constructors; use separate methods.

  5. Use optional parameters to make constructors flexible.

Common Mistakes

  • Forgetting to use $this when assigning property values.

  • Overloading constructors (PHP does not support multiple constructors natively; use optional parameters instead).

  • Ignoring parent constructors in inheritance, leading to uninitialized properties.

  • Performing heavy operations inside the constructor, which can slow down object creation.

Summary of the Tutorial

  • Constructors are special methods called automatically when an object is created.

  • Use __construct() to initialize properties and resources.

  • Constructors can have parameters, optional parameters, or default values.

  • Inheritance requires calling parent::__construct() to initialize parent properties.

  • Following best practices ensures clean, maintainable, and efficient code.

Constructors are foundational in OOP, preparing objects for use immediately after creation and ensuring predictable, consistent behavior.

Practice Questions

  1. Create a class Car with properties brand and color. Use a constructor to initialize these properties and display them.

  2. Write a PHP program to create a Student class with a constructor that accepts name and age. Instantiate two students with different values and display their details.

  3. Create a Book class with optional constructor parameters title and author. Instantiate one object with values and another without values, displaying both.

  4. Create a class BankAccount with properties accountNumber and balance. Initialize them through the constructor and display account details.

  5. Write a class Employee with a constructor that automatically sets a joiningDate property to the current date. Display the joining date for an employee object.

  6. Create a parent class Vehicle with a constructor for brand. Create a child class Bike that calls the parent constructor and adds a type property. Display all values.

  7. Write a PHP class Database with a constructor that establishes a connection to MySQL. Include a method getConnection() to return the connection object.

  8. Create a class Rectangle with constructor parameters length and width. Add a method area() to calculate the area. Instantiate objects with different dimensions and display their areas.

  9. Create a class Person with a constructor that accepts a name parameter. Create a method greet() that prints “Hello” with the person’s name. Instantiate the object and call greet().

  10. Write a class FileHandler with a constructor that opens a file for reading and a destructor that closes the file. Demonstrate the automatic execution of both constructor and destructor.

← Previous Next →

Try a Short Quiz.

coding learning websites codepractice

No quizzes available.

PHP

online coding class codepractice

PHP Basics

PHP Data

Control Flow

PHP Functions

PHP Arrays

PHP Forms

PHP Advanced

Cookies & Sessions

Filters & JSON

PHP Exceptions

PHP OOP

MySQL with PHP

PHP and XML

AJAX with PHP

codepractice logo
Login
Go Back Top