What does polymorphism mean in PHP

In PHP, polymorphism means that 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; when different objects receive the same message, they will get different results. This phenomenon is called polymorphism. Polymorphism allows each object to respond to common messages in a way that suits itself; polymorphism enhances the flexibility and reusability of software.

The operating environment of this tutorial: windows7 system, PHP8 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.

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

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

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

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

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.

Two methods to implement PHP polymorphism

In PHP5, the type of variables is undefined, and a variable can point to any type Numeric values, strings, objects, resources, etc. We cannot say that polymorphism in PHP5 is a variable.

We can only say that in PHP5, polymorphism is applied in the type hint position of method parameters.

Any subclass object of a class can satisfy the type requirement of using the current type as a type hint.

All classes that implement this interface can meet the method parameter requirements with the interface type as a type hint.

Simply put, a class has the identity of its parent class and implemented interface.

Achieve polymorphism by implementing interfaces

<?php
interface User{ // User接口
    public function  getName();
    public function setName($_name);
}
class NormalUser implements User { // 实现接口的类.
    private $name;
    public function getName(){
        return $this->name;
    }
    public function setName($_name){
        $this->name = $_name;
    }
}
class UserAdmin{ //操作.
    public 
static
 function  ChangeUserName(User $_user,$_userName){
        $_user->setName($_userName);
    }
}
$normalUser = new NormalUser();
UserAdmin::ChangeUserName($normalUser,"Tom");//这里传入的是 NormalUser的实例.
echo $normalUser->getName();
?>

Use interfaces and composition to simulate multiple inheritance

Simulate multiple inheritance through composition.

Multiple inheritance is not supported in PHP. If we want to use the methods of multiple classes to achieve code reuse, is there any way?

那就是组合。在一个类中去将另外一个类设置成属性。

下面的例子，模拟了多重继承。

接口实例

写一个概念性的例子。 我们设计一个在线销售系统，用户部分设计如下： 将用户分为，NormalUser, VipUser, InnerUser 三种。要求根据用户的不同折扣计算用户购买产品的价格。并要求为以后扩展和维护预留空间。

<?php
interface User
{
    public function getName();
    public function setName($_name);
    public function getDiscount();
}
abstract class AbstractUser implements User
{
    private $name = "";
    protected  $discount = 0;
    protected  $grade = "";
    function construct($_name) {
        $this->setName($_name); 
    }
    function getName() {
        return $this->name;
    }
    function setName($_name) {
    $this->name = $_name;
    }
    function getDiscount() {
        return $this->discount;
    }
    function getGrade() {
        return $this->grade;
    }
}
class NormalUser 
extends
 AbstractUser
{
    protected $discount = 1.0;
    protected $grade = "Normal";
}
class VipUser extends AbstractUser
{
    protected $discount = 0.8;
    protected $grade = "VipUser";
}
class InnerUser extends AbstractUser
{
    protected $discount = 0.7;
    protected $grade = "InnerUser";
}
interface Product
{
    function getProductName();
    function getProductPrice();
}
interface Book extends Product
{
    function getAuthor();
}
class BookOnline implements Book
{
    private $productName;
    protected $productPrice;
    protected $Author;
    function construct($_bookName) {
        $this->productName = $_bookName;
    }
    function getProductName() {
        return $this->productName;
    }
    function getProductPrice() {
        $this->productPrice = 100;
        return $this->productPrice;
    }
    public function getAuthor() {
        $this->Author = "chenfei";
        return $this->Author;
    }
}
class Productsettle
{
    public static function finalPrice(User $_user, Product $_product, $number) {
        $price = $_user->getDiscount() * $_product->getProductPrice() * $number;
        return $price;
    }
}
$number = 10;
$book = new BookOnline("
设计模式
");
$user = new NormalUser("tom");
$price = Productsettle::finalPrice($user, $book, $number);
$str = "您好，尊敬的" . $user->getName() . "<br />";
$str .= "您的级别是" . $user->getGrade() . "<br />";
$str .= "您的折扣是" . $user->getDiscount() . "<br />";
$str .= "您的价格是" . $price;
echo $str;
?>

推荐学习：《PHP视频教程》

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!