As in most of the object-oriented languages, you can define a constructor function in a class in PHP also. When you declare an object with the new operator, its member variables are not assigned any value. The constructor function is used to initialize every new object at the time of declaration. PHP also supports having a destructor function that destroys the object from the memory as it no longer has any reference.
The __construct() Function
PHP provides a __construct() function that initializes an object.
__construct(mixed ...$values = ""): void
The constructor method inside a class is called automatically on each newly created object. Note that defining a constructor is not mandatory. However, if present, it is suitable for any initialization that the object may need before it is used.
You can pass as many as arguments you like into the constructor function. The __construct() function doesnât have any return value.
Let us define a constructor in the Book class used in the previous chapter
<?php class Book { /* Member variables */ var $price; var $title; /*Constructor*/ function __construct(){ $this->title = "PHP Fundamentals"; $this->price = 275; } /* Member functions */ function getPrice() { echo "Price: $this->price n"; } function getTitle(){ echo "Title: $this->title n"; } } $b1 = new Book; $b1->getTitle(); $b1->getPrice(); ?>
It will produce the following output −
Title: PHP Fundamentals Price: 275
Parameterized Constructor
The member variables of $b1 have been initialized without having to call setTitle() and setPrice() methods, because the constructor was called as soon as the object was declared. However, this constructor will be called for each object, and hence each object has the same values of title and price properties.
To initialize each object with different values, define the __construct() function with parameters.
Change the definition of __construct() function to the following −
function __construct($param1, $param2) { $this->title = $param1; $this->price = $param2; }
To initialize the object, pass values to the parameters inside a parenthesis in the declaration.
$b1 = new Book("PHP Fundamentals", 375);
Example
Now, you can have each object with different values to the member variables.
<?php class Book { /* Member variables */ var $price; var $title; /*Constructor*/ function __construct($param1, $param2) { $this->title = $param1; $this->price = $param2; } /* Member functions */ function getPrice(){ echo "Price: $this->price n"; } function getTitle(){ echo "Title: $this->title n"; } } $b1 = new Book("PHP Fundamentals", 375); $b2 = new Book("PHP Programming", 450); $b1->getTitle(); $b1->getPrice(); $b2->getTitle(); $b2->getPrice(); ?>
It will produce the following output −
Title: PHP Fundamentals Price: 375 Title: PHP Programming Price: 450
Constructor Overloading
Method overloading is an important concept in object-oriented programming, where a class may have more than one definitions of constructor, each having different number of arguments. However, PHP doesnât support method overloading. This limitation may be overcome by using arguments with default values in the constructor function.
Change the __construct() function to the following −
function __construct($param1="PHP Basics", $param2=380) { $this->title = $param1; $this->price = $param2; }
Now, declare an object without passing parameters, and the other with parameters. One without parameters will be initialized with default arguments, the other with the values passed.
$b1 = new Book(); $b2 = new Book("PHP Programming", 450);
It will produce the following output −
Title: PHP Basics Price: 380 Title: PHP Programming Price: 450
Type Declaration in Constructor
Since PHP (version 7.0 onwards) allows scalar type declarations for function arguments, the __construct() function may be defined as −
function __construct(string $param1="PHP Basics", int $param2=380) { $this->title = $param1; $this->price = $param2; }
In the earlier versions of PHP, using the name of class to define a constructor function was allowed, but this feature has been deprecated since PHP version 8.0.
The __destruct() Function
PHP also has a __destructor() function. It implements a destructor concept similar to that of other object-oriented languages, as in C++. The destructor method will be called as soon as there are no other references to a particular object.
__destruct(): void
The __destruct() function doesnât have any parameters, neither does it have any return value. The fact that the __destruct() function is automatically called when any object goes out of scope, can be verified by putting var_dump($this) inside the function.
As mentioned above, $this carries the reference to the calling object, the dump shows that the member variables are set to NULL
Add destructor function in the Book class as follows −
function __destruct() { var_dump($this); echo "object destroyed"; }
As the program exits, the following output will be displayed −
object(Book)#1 (2) { ["price"]=> NULL ["title"]=> NULL } object destroyed