Home > Article > Backend Development > Detailed explanation of the implementation of PHP polymorphism_PHP tutorial
Detailed explanation of the implementation of PHP polymorphism_PHP tutorial
- WBOYOriginal
- 2016-07-21 15:07:48707browse
Polymorphism means that the same operation, function, or procedure can be applied to multiple types of objects and obtain different results. Different objects can produce different results when receiving the same message. This phenomenon is called polymorphism.
Polymorphism allows each object to respond to a common message in its own way. Polymorphism enhances software flexibility and reusability.
In object-oriented software development, polymorphism is one of the most important parts. Object-oriented programming is not just about simply combining related methods and data, but using various elements in object-oriented programming to clearly describe various situations in real life. This section will provide a detailed explanation of polymorphism in object-oriented programming.
1. What is polymorphism?
Polymorphism literally means "multiple shapes". It can be understood as multiple forms of expression, that is, "one external interface and multiple internal implementation methods." In object-oriented theory, the general definition of polymorphism is: the same operation will produce different execution results when applied to instances of different classes. That is, when objects of different types receive the same message, they will get different results.
In actual application development, the main reason for using object-oriented polymorphism is that different subclass objects can be treated as one parent class, and the differences that exist between different subclass objects can be shielded. Differences, write common code, and make common programming to adapt to changing needs.
2. Polymorphic application design
In actual application development, it is usually in order to make the project easier in the future. To achieve expansion and upgrade, it is necessary to realize reusable modules through inheritance for easy upgrade. When designing reusable modules, it is necessary to reduce the use of flow control statements as much as possible. At this point, you can use polymorphism to implement this type of design.
【Example】exemplifies different types of processing that are usually implemented using flow control statements. The code is shown below.
class painter{ echo "The painter is painting!/n ";
}
}
class typist{ //Define the typist's job
echo "The typist is typing!/n" ;
}
}
function printworking($obj){ //Define processing class
if($obj instanceof painter){ //If the object is a painter class, the painter action will be displayed
$obj->paintbrush();
}elseif($obj instanceof typist){ //If the object is a typist class, display the typist action
$obj->typed(); printworking(new typist()); //Display employee work
?>
Analysis:
In the above program , first define two employee classes: painter class and typist class. Then define a processing function. In this function, it is judged whether the employee is a defined employee and the employee's work status is printed out. The results are shown below.
The painter is painting
From the above program, it can be easily seen that if you want to display the working status of several employees, you need to first define the employee class. And define the employee's work in the employee class, and then add an elseif statement in the printworking() function to check which employee class the object is. This is very undesirable in practical applications. If polymorphism is used at this time, this problem can be easily solved. You can first create an employee parent class. All employee classes will inherit from the employee parent class and inherit all methods and attributes of the parent class. Then create a "is a" relationship in the employee class to determine whether it is a legal employee.
【Example】The above example
is rewritten using polymorphism. The code is shown below.
Copy code
The code is as follows:
class employee{//Define employee parent class
protected function working(){//Define employee work, which needs to be implemented in the subclass
echo "This method Need to be overloaded in subclasses!";
}
}
class painter extends employee{//Define the painter class
public function working(){//Implement the inherited working method
echo "The painter is painting!/n";
}
}
class typist extends employee{//Define the typist class
public function working(){
echo "Typing The employee is typing! /n";
}
}
class manager extends employee{//Define the manager class
public function working(){
echo "The manager is in a meeting";
}
}
function printworking($obj){//Define processing method
if($obj instanceof employee){//If it is an employee object, display its working status
$obj- >working();
}else{//Otherwise, the error message is displayed
echo "Error: Object error!";
}
}
printworking(new painter());/ /Display the painter’s work
printworking(new typist());//Display the typist’s work
printworking(new manager());//Display the manager’s work
?>
Analysis: In the above program, first define an employee base class and define a method for employee work status. Then define three employee classes that will inherit from the employee base class: Painter, Typist, and Manager. Then define a method to display the employee's work status. And create a "is-one" relationship in this method to determine whether it is a legal employee. The results are shown below.
The painter is painting!
The typist is typing!
The manager is having a meeting!
From the above example, it can be found that no matter how many employee classes are added, you only need to implement automatic The employee class and methods inherited from the employee parent class. There is no need to modify the printing() method that displays employee work status.