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.”
ADVERTISEMENT Popular Course in this category PHP DEVELOPER - Specialization | 8 Course Series | 3 Mock TestsStart Your Free Software Development Course
Web development, programming languages, Software testing & others
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
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 class="brush:php;toolbar:false">"; 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.
There are two types of overloading in PHP, and let us learn each type in detail.
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
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:
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.
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 –
The above is the detailed content of Overloading in PHP. For more information, please follow other related articles on the PHP Chinese website!