What does polymorphism mean in php

Polymorphism in php literally means "multiple shapes", which can be understood as multiple forms of expression, that is, "one external interface, multiple internal implementation methods"; in object-oriented theory , Polymorphism means that the same operation will produce different execution results when applied to instances of different classes.

The operating environment of this article: windows7 system, PHP7.1 version, DELL G3 computer

PHP polymorphism

Polymorphism means that the same operation, function, or process can act on 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 common messages in a way that suits itself. 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 purpose of 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.

Recommended study: "PHP Video Tutorial"

2. Polymorphic application design

in actual application development In order to enable the project to easily expand and upgrade in the future, it is usually necessary to implement 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] illustrates the common use of flow control statements to implement different types of processing. The code is shown below.

class painter{ //定义油漆工类
public function paintbrush(){ //定义油漆工动作
echo "油漆工正在刷漆！\n";
}
}
class typist{ //定义打字员类
public function typed(){ //定义打字员工作
echo "打字员正在打字！\n";
}
}
function printworking($obj){ //定义处理类
if(objinstanceofpainter)//若对象是油漆工类，则显示油漆工动作$obj−>paintbrush();elseif(obj instanceof typist){ //若对象是打字员类，则显示打字员动作
$obj->typed();
}else{ //若非以上类，则显示出错信息
echo "Error: 对象错误！";
}
}
printworking(new painter()); //显示员工工作
printworking(new typist()); //显示员工工作

Analysis: In the above program, two employee classes are first defined: 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.

油漆工正在刷漆  
打字员正在打字

It can be easily seen from the above program that if you want to display the working status of several employees, you need to first define the employee class, define the employee's work in the employee class, and then use the printworking() function Add an elseif statement to check which employee class the object is an instance of. 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.

class employee{//定义员工父类
protected function working(){//定义员工工作，需要在子类的实现
echo "本方法需要在子类中重载!";
}
}
class painter extends employee{//定义油漆工类
public function working(){//实现继承的工作方法
echo "油漆工正在刷漆！\n";
}
}
class typist extends employee{//定义打字员类
public function working(){
echo "打字员正在打字！\n";
}
}
class manager extends employee{//定义经理类
public function working(){
echo "经理正在开会！";
}
}
function printworking($obj){//定义处理方法
if($obj instanceof employee){//若是员工对象，则显示其工作状态
$obj->working();
}else{//否则显示错误信息
echo "Error: 对象错误！";
}
}
printworking(new painter());//显示油漆工的工作
printworking(new typist());//显示打字员的工作
printworking(new manager());//显示经理的工作

Analysis: In the above program, first define an employee base class , and define a method of employee working 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.

油漆工正在刷漆! 
打字员正在打字! 
经理正在开会!

It can be found from the above example that no matter how many employee classes are added, you only need to implement 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.

The above is the detailed content of What does polymorphism mean in php. For more information, please follow other related articles on the PHP Chinese website!