This article mainly introduces the understanding of PHP polymorphism, which has certain reference value. Now I share it with everyone. Friends in need can refer to it

PHP polymorphism

more Morphism 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.

2. Polymorphic application design

In actual application development, usually in order to enable the project to easily expand and upgrade in the future, it is necessary to Implement reusable modules through inheritance for easy upgrades. 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]Examples are usually used to implement different types of processing using flow control statements. The code is shown below.

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

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
The typist is typing

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. 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.

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 for 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.

The painter is painting!
The typist is typing!
The manager is having a meeting!

It can be found from the above example 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.

The above is the entire content of this article. I hope it will be helpful to everyone's study. For more related content, please pay attention to the PHP Chinese website!

Related recommendations:

Introduction to PHP file programming

Introduction to basic PHP syntax

The above is the detailed content of Understanding PHP polymorphism. For more information, please follow other related articles on the PHP Chinese website!