PHP Constructor and Destructor Tutorial with Examples

In PHP, constructors and destructors are special functions that allow you to manage the lifecycle of an object.

The constructor is automatically called when an object is created, and the destructor is called when an object is destroyed.

Constructors are commonly used to initialize object properties, while destructors can be used for cleanup tasks.

This tutorial will cover:

Let’s explore each concept with examples and explanations.

1. What is a Constructor?

A constructor in PHP is a special method that is automatically invoked when an object is instantiated. It is typically used to set up initial values or perform tasks that should be executed at the time the object is created, such as initializing object properties.

• Constructors in PHP are defined using the __construct() method.
• Constructors can accept parameters, allowing you to pass values during object creation.

2. Defining a Constructor

To define a constructor, you use the __construct() method inside a class. When you instantiate the class (i.e., create an object), the constructor is automatically called.

Syntax:

class ClassName {
    public function __construct() {
        // Constructor code
    }
}

Example (Basic Constructor):

<?php
class Car {
    public function __construct() {
        echo "A new car has been created.\n";
    }
}

// Instantiate a Car object (the constructor will be called)
$car = new Car();
?>

Output:

A new car has been created.

• In this example, the constructor is called automatically when the Car object is instantiated, and it outputs a message.

3. Using Parameters in Constructors

Constructors can accept parameters, which allows you to pass values when creating an object. These values can be used to initialize object properties.

Example (Constructor with Parameters):

<?php
class Car {
    public $make;
    public $model;

    // Constructor with parameters
    public function __construct($make, $model) {
        $this->make = $make;
        $this->model = $model;
    }

    // Method to display car information
    public function displayInfo() {
        echo "Car make: " . $this->make . "\n";
        echo "Car model: " . $this->model . "\n";
    }
}

// Instantiate a Car object with parameters
$car = new Car("Toyota", "Corolla");
$car->displayInfo();
?>

Output:

Car make: Toyota
Car model: Corolla

• In this example, the constructor accepts two parameters ($make and $model) to initialize the properties of the Car class.

4. Constructor Inheritance with parent::__construct()

When a child class inherits from a parent class, the constructor of the parent class is not automatically called. You can use parent::__construct() to explicitly call the parent class constructor from within the child class constructor.

Example (Constructor Inheritance):

<?php
// Define a parent class
class Vehicle {
    public $make;

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

// Define a child class that extends the parent class
class Car extends Vehicle {
    public $model;

    public function __construct($make, $model) {
        // Call the parent constructor
        parent::__construct($make);
        $this->model = $model;
    }

    public function displayInfo() {
        echo "Car make: " . $this->make . "\n";
        echo "Car model: " . $this->model . "\n";
    }
}

// Instantiate a Car object
$car = new Car("Honda", "Civic");
$car->displayInfo();
?>

Output:

Car make: Honda
Car model: Civic

• The Car class extends the Vehicle class, and in the Car constructor, we call the parent constructor using parent::__construct($make) to initialize the inherited $make property.

5. What is a Destructor?

A destructor is a special method that is automatically called when an object is destroyed or when the script ends. Destructors are often used for cleanup tasks, such as closing database connections or releasing resources.

• Destructors are defined using the __destruct() method.
• There can only be one destructor in a class, and it does not accept any parameters.

6. Defining a Destructor

To define a destructor, you use the __destruct() method inside a class. The destructor is automatically called when the object is no longer needed.

Example (Basic Destructor):

<?php
class Car {
    public function __construct() {
        echo "A new car has been created.\n";
    }

    // Destructor method
    public function __destruct() {
        echo "The car has been destroyed.\n";
    }
}

// Instantiate a Car object
$car = new Car();  // Constructor is called

// Destructor is automatically called when the script ends or object is destroyed
?>

Output:

A new car has been created.
The car has been destroyed.

• The destructor is called automatically when the object is destroyed or when the script finishes execution.

Example (Destructor with Cleanup Task):

<?php
class FileHandler {
    private $file;

    public function __construct($filePath) {
        $this->file = fopen($filePath, 'w');
        echo "File opened: " . $filePath . "\n";
    }

    public function writeToFile($content) {
        fwrite($this->file, $content);
    }

    // Destructor closes the file
    public function __destruct() {
        fclose($this->file);
        echo "File closed.\n";
    }
}

// Create a FileHandler object
$fileHandler = new FileHandler("example.txt");
$fileHandler->writeToFile("Hello, World!");

// File will be closed when the object is destroyed
?>

Output:

File opened: example.txt
File closed.

• In this example, the destructor is used to automatically close the file when the FileHandler object is no longer needed.

7. Example Use Case: Database Connection

Constructors and destructors are commonly used in database connection classes. The constructor can establish a connection, and the destructor can close the connection when the object is destroyed.

Example (Database Connection):

<?php
class Database {
    private $connection;

    // Constructor establishes a connection
    public function __construct($host, $user, $password, $dbname) {
        $this->connection = new mysqli($host, $user, $password, $dbname);
        if ($this->connection->connect_error) {
            die("Connection failed: " . $this->connection->connect_error);
        }
        echo "Connected to the database.\n";
    }

    // Destructor closes the connection
    public function __destruct() {
        $this->connection->close();
        echo "Database connection closed.\n";
    }

    // Method to run a query
    public function query($sql) {
        return $this->connection->query($sql);
    }
}

// Create a Database object (the constructor will establish a connection)
$db = new Database("localhost", "root", "password", "test_db");

// Run a query (for example purposes)
$result = $db->query("SELECT * FROM users");

// Destructor will automatically close the connection
?>

Output:

Connected to the database.
Database connection closed.

• In this example, the Database class constructor establishes a connection, and the destructor automatically closes it when the object is no longer in use.

Summary of PHP Constructors and Destructors:

Conclusion

In PHP, constructors and destructors are essential for managing object initialization and cleanup.

They provide a way to control the lifecycle of an object and perform tasks like setting initial values and releasing resources. In this tutorial, we covered:

• Defining constructors and using them to initialize properties.
• Passing parameters to constructors to customize object creation.
• Calling parent constructors in child classes using parent::__construct().
• Defining destructors to perform cleanup tasks when an object is destroyed.
• A practical use case involving a database connection class.