What is Overloading in PHP?
We have different Object-Oriented Programming concepts like Class, Object, Encapsulation, Polymorphism etc., in PHP. Overloading is also such a concept of OOPs in PHP. Function overloading or method overloading is a feature that allows creating several methods with the same name, which differ from each other in the type of input parameters. It is simply defined as the ability of one function to perform different tasks.
Definition of overloading in one line: “same name but different implementations.”
How does Overloading work in PHP?
As we know, method overloading is performed on functions. Thus functions can be overloaded with different implementations based on the arguments passed to each function. For example, to find the area of a circle, which is pi *r *r provided radius is given, to find the area of square which is side * side, provided length of a side is given, area of a triangle is (base * height) / 2 provided the base length and the height is given and so on.
Overloading Concept requires Magic methods.
Magic Methods begins with __(double underscore) and gets called automatically by PHP. Also, these are always defined inside the class and not outside the class. Different magic methods are __get(), __set,__construct(), __destruct(), __call(), __callStatic(), __isset(), __unset(),
Overloading, when performed, creates properties and methods dynamically, which is together called the entities.
The entities are also called as
- properties: data members
- methods: data functions
Let us look at how the magic method works using the __call() method
<?php
class Test{
private $a = array('one','two','three');
public function__call($method, $args) {
print "Method $method called:\n";
echo "<pre>";
print_r($args);
return $this->a;
}
}
$obj = new Test();
$a = obj->anyMethod(1, 2, 3);
var_dump($a);
?>
In the above example, we have declared a class called Test, which has private property and a __call method. Two arguments are passed to the __call method. Inside the __call method, we have used statement print(), a var_dump the arguments, and a return value x are returned.
Then the object of the class with the name obj is created, and using this object, an undefined method is called since this method doesn’t exist __call() is called instead.
Types of Overloading in PHP
There are two types of overloading in PHP, and let us learn each type in detail.
- Property Overloading
- Method Overloading
1) Property Overloading
Property overloading creates dynamic properties when the object is set. This property is associated with the class instance, and if this property is not declared within the extent of the class, it is considered as overloaded property. For this, you need not write any extra code. The following magic methods tell us more about the same.
Below mentioned are operations performed with overloaded properties
Setter and Getter overloaded properties (using __set() and __get())
Evaluating overloaded properties setting (using __isset())
Undo such properties setting (using __unset())
Let us understand the use of each of these methods
__set() => is used to initialize overloaded properties.
__get() => is used to fetch the already initialized properties
__isset() => is used to check if the property is set or not
__unset() => is used to unset the property.
__call() => is used to initialize overloaded methods
__callStatic() => is used to initialize static methods
All the above methods together are used in the following example.
Code:
class PropertyOverloading {
public $details = array();
//declaring private property
private $j=20;
// setter operation
public function __set($name, $value) {
echo "<br />". " In the Setting operation. Set '$name = $value'";
$this->details[$name] = $value;
}
// getter operation
public function __get($name) {
echo "<br />". " In the Getting Operation. Get '$name = '";
return $this->details[$name] . ' <br /> ';
}
// isset operation
public function __isset($name) {
echo "<br />". " In the isset Operation. isset '$name' ?";
return isset($this->details[$name]);
}
// unset operation
public function __unset($name) {
echo "<br />". " In the unset Operation. unset '$name' ";
unset($this->details[$name]);
}
// returning private property value
public function getPrivateProperty() {
return "<br />". " j = ".$this->j;
}
}
// creating object of class PropertyOverloading
// setter and getter methods are called
$obj = new PropertyOverloading();
$obj->x = 10;
echo $obj->x;
//call isset method
var_dump(isset($obj->x));
//call unset method
unset($obj->x);
//check whether object x is unset or not
var_dump(isset($obj->x));
//getting method to access the private property
echo "<br />". $obj-> getPrivateProperty();
//calling directly the private property
// throws error
echo "<br />accessing the private property, throws error";
echo "<br />".$obj->j;Code:
Output
2) Method Overloading
Like Property overloading, Method overloading creates a dynamic method that is declared outside the extent of the class. And this is possible with __call() and __callStatic() magic methods. These are used based on the object reference and the static reference, respectively.
__call() -> is used for calling overloaded methods in the object reference
__callStatic() -> is used for calling overloaded methods in static reference
The following example will help you to learn more.
<?php
class MethodOverloading
{
public function __call($name,$param){
echo "--With object reference <br/>";
}
public static function __callStatic($name,$param){
echo "-----With static reference <br/>";
}
}
// creating object of class MethodOverloading
$obj = new MethodOverloading;
echo "Method Overloading <br/>";
// using the object reference
$obj->DemoTest();
// using the static reference
MethodOverloading::DemoTest();
?>Code:
Output:
Rules
1) The public access specifier is used for the overloading methods.
2) The overloading process is used wherein the properties or methods not defined within the extent of the class can be accessed on the creation of the object of the class.
3) Magic methods are used for overloading properties or methods. Out of the two magic methods used for overloading methods, the most used method is the __call() method in object context, and the less used is the __callStatic() method, which is used in the static context.
Recommended Article
This is a guide to Overloading in PHP. Here we discuss the types and the concept of overloading in PHP with examples. You may also look at the following article to learn more –
