Polymorphism and method overloading
Class polymorphism and class method overloading are fundamental programming concepts built into the object-oriented programming (OOP) concept in PHP programming, allowing PHP programmers to create more complex, small, flexible, and reusable class program source code.
So, let’s explore polymorphism and class method overloading in PHP programming.
Polymorphism Concept in PHP.
What is polymorphism in PHP?
Polymorphism is a popular class object creation programming concept in PHP programming. This allows class programmers to treat parameter objects from multiple classes as objects of the same parent class. The polymorphism concept in class programming allows programmers to infer different class behavior based on the class object that calls a single function or declared class method.
There are two types of polymorphism in object-oriented programming (OOP).
- Compile-time polymorphism (method overloading) – This is achieved through method overloading in a class program, but PHP programming does not directly support it.
- Run-time polymorphism (method overriding) – This is achieved through method overriding in a class program, and PHP programming supports this.
Polymorphism through method overriding in a class.
The polymorphism concept in PHP programming is generally achieved through class method overriding. Inheritance in a user-defined class program allows a subclass to override a class method, allowing it to inherit properties from the parent or root class. This class method is executed based on the real-time class object type, not the class reference type.
Example of class polymorphism in PHP programming.
<?php
// here declares computer as Parent class
class computer {
public function select_choice() {
echo “Select your desire computer choice\n”;
}
}
// here computer laptop Child class 1 created
class laptop extends computer {
public function select_choice() {
echo “Hp Laptop\n”;
}
}
// here computer desktop Child class 2 created
class desktop extends computer {
public function select_choice() {
echo “Dell Desktop\n”;
}
}
//here actual Polymorphism perform action
function selection(computer $computer) {
$computer->select_choice(); // here This will call the appropriate class method based on the declare class object’s type
}
$laptop = new laptop();
$desktop = new desktop();
selection($laptop); // Result – Hp Laptop
selection($desktop); // Result – Dell Desktop
?>
Explanation of polymorphism through method overriding.
- In this program, we have created a parent class, Computer, and two child classes, Laptop and Desktop.
- The select_choice() method in the class has been overridden to provide specific behavior for both the Laptop and Desktop classes.
- The selection() function accepts an object of type Computer and calls the select_choice() function in the program. Due to the polymorphism features, the correct select_choice() method is called based on the real-time class object type, Laptop or Desktop, rather than the reference type, Computer.
Key points about polymorphism in PHP classes.
- This allows multiple behaviors for the same class method in PHP programming, depending on the object calling it.
- In PHP programming, the polymorphism concept is commonly applied using class method overriding.
Method Overloading Concept in PHP Programming.
What is Method Overloading in a PHP Class?
The method overloading concept in PHP programming allows a user-defined class to contain a class method created with the same name but multiple different parameters. In some popular OOP programming languages, such as Java or C++, programmers can overload class methods by replacing the number or type of class parameters. Remember, PHP programming does not support real-time method overloading in the traditional order.
The class method overloading concept in PHP programming is controlled by the magic methods __call() and __callStatic() class functions. These methods are automatically invoked in the created user-defined class when a program attempts to call a class method that is not defined in the existing class.
Here’s how to overload class methods with the __call() function in a class program based on instance methods.
The __call() magic method in a class program allows you to manage method calls for undefined or non-existent methods. It creates the illusion of class overloading by allowing class methods with multiple class parameter signatures to be called dynamically.
Example of method overloading with the __call() function in PHP programming.
<?php
class calculation {
// Here we create a magic class method __call function to handle overloading
public function __call($method, $args) {
if ($method == ‘mul’ && count($args) == 2) {
return $args[0] * $args[1];
} elseif ($method == ‘mul’ && count($args) == 3) {
return $args[0] * $args[1] * $args[2];
} else {
return “unsupported class method or number of class arguments \n”;
}
}
}
$calculate = new calculation();
echo $calculate->mul(4, 3) . “\n”; // Result – 12
echo $calculate->mul(3, 3, 3) . “\n”; // Result – 27
echo $calculate->mul(3, 4, 7, 8) . “\n”; // Result – unsupported class method or number of class arguments
?>
Explanation of method overloading with the __call() function.
- The __call() method is invoked in a class program when an attempt is made to call an undefined class method. In this situation, programmers use the mul() method to create the illusion of overloading by checking the number of program arguments passed in.
- The mul() class method can take either four or three arguments, and the __call() function processes them in a dynamic order based on the number of class arguments.
Overloading static methods with __callStatic() in PHP programming.
The __callStatic() function magic method is invoked in PHP programming in a particular situation when programmers try to call a static method in a class program that does not exist in the class.
Example of static method overloading in a PHP program.
<?php
//calculation class created
class calculation {
// here Magic class method for static method overloading concept
public static function __callStatic($method, $args) {
if ($method == ‘subtract’ && count($args) == 2) {
return $args[0] – $args[1];
} elseif ($method == ‘subtract’ && count($args) == 3) {
return $args[0] – $args[1] – $args[2];
} else {
return “unsupported class method or number of class arguments \n”;
}
}
}
echo calculation::subtract(12, 4) . “\n”; // Result – 8
echo calculation::subtract(13, 4, 6) . “\n”; // Result – 3
echo calculation::subtract(17, 2, 6, 7) . “\n”; // Result – unsupported class method or number of class arguments
?>
Explanation of static method overloading.
- In this program, the __callStatic() function magic method handles calls to undefined static methods.
- Programmers use this function to overload the static subtract() method to handle multiple number arguments.
main Differences Between Polymorphism and Method Overloading in php class
| Feature | Php Polymorphism concept | Php Method Overloading concept |
| Definition or Behavior | Polymorphism have ability to call the same class method on different class objects, here with each class object having its own implementation of the class method. | Method Overloading have ability to define multiple class methods with the same name in active class but with multiple class parameters managed in PHP via magic methods like __call method. |
| How to Implementation | We can Achieved via method overriding in PHP through inheritance class features. | Method Overloading features Achieved via magic methods (__call() for instance methods, __callStatic() for static methods) in PHP language. |
| Multiple Use Case | Used to handle Polymorphism method class calls that behave differently depending on the class object type (e.g., laptop vs. desktop). | Method Overloading Used to simulate overloading by handling class calls to methods with different numbers of user declare class parameters. |
| Is PHP Support | Polymorphism Supported natively via method overriding in php programming language. | Method Overloading concept Not natively supported php but can be achieved using magic methods to support php. |
A summary of polymorphism and class method overloading in PHP programming.
- The concept of polymorphism in PHP programming allows multiple class objects to respond to the same method in multiple orders. In the PHP language, this is commonly implemented through method overriding.
- Method overloading in PHP programming is achieved through the magic method __call() and __callStatic() functions, as the PHP language does not support method overloading in the traditional order like some other programming languages.
- The polymorphism feature in PHP class concept is useful for programmers to create flexible and reusable program module source code, here method overloading is helpful in managing dynamic method calls. When programmers want to support methods with multiple argument calculations.
