Que signifie le polymorphisme en PHP

En PHP, le polymorphisme signifie que la même opération produira des résultats d'exécution différents lorsqu'elle sera appliquée à des instances de différentes classes. Autrement dit, lorsque des objets de types différents reçoivent le même message, ils obtiendront des résultats différents ; lorsque différents objets recevront le même message, ils obtiendront des résultats différents. Ce phénomène est appelé polymorphisme. Le polymorphisme permet à chaque objet de répondre aux messages communs d'une manière qui lui convient ; le polymorphisme améliore la flexibilité et la réutilisabilité des logiciels.

L'environnement d'exploitation de ce tutoriel : système Windows7, version PHP8, ordinateur DELL G3

Polymorphisme PHP

Le polymorphisme signifie qu'une même opération, fonction ou processus peut agir sur plusieurs types d'objets et obtenir des résultats différents. Différents objets peuvent produire des résultats différents lorsqu'ils reçoivent le même message. Ce phénomène est appelé polymorphisme.

Le polymorphisme permet à chaque objet de répondre à des messages communs d'une manière qui lui convient. Le polymorphisme améliore la flexibilité et la réutilisabilité des logiciels.

Dans le développement de logiciels orientés objet, le polymorphisme est l'un des éléments les plus importants. La programmation orientée objet ne consiste pas simplement à combiner des méthodes et des données associées, mais à utiliser divers éléments de la programmation orientée objet pour décrire clairement diverses situations de la vie réelle. Cette section fournira une explication détaillée du polymorphisme dans la programmation orientée objet.

1. Qu'est-ce que le polymorphisme

Le polymorphisme signifie littéralement « formes multiples ». Il peut être compris comme plusieurs formes d'expression, c'est-à-dire « une interface externe et plusieurs méthodes de mise en œuvre internes ». Dans la théorie orientée objet, la définition générale du polymorphisme est la suivante : la même opération produira des résultats d'exécution différents lorsqu'elle sera appliquée à des instances de classes différentes. Autrement dit, lorsque des objets de types différents reçoivent le même message, ils obtiendront des résultats différents.

Dans le développement d'applications réels, la principale raison de l'utilisation du polymorphisme orienté objet est que différents objets de sous-classe peuvent être traités comme une seule classe parent et que les différences entre les différents objets de sous-classe peuvent être masquées. Écrivez du code universel et une programmation universelle pour s'adapter aux changements. besoins.

2. Conception d'applications polymorphes

Dans le développement d'applications réel, généralement afin de permettre au projet d'être facilement étendu et mis à niveau à l'avenir, il est nécessaire d'implémenter des modules réutilisables pour une mise à niveau facile par héritage. Lors de la conception de modules réutilisables, il est nécessaire de réduire autant que possible l’utilisation d’instructions de contrôle de flux. À ce stade, vous pouvez utiliser le polymorphisme pour implémenter ce type de conception.

【Exemple】 illustre les instructions de contrôle de flux qui sont habituellement utilisées pour mettre en œuvre différents types de traitement. Le code est affiché ci-dessous.

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()); //显示员工工作

Analyse : Dans le programme ci-dessus, définissez d'abord deux classes d'employés : la classe peintre et la classe dactylographe. Définissez ensuite une fonction de traitement. Dans cette fonction, il est déterminé si l'employé est un employé défini et son statut de travail est imprimé. Les résultats sont présentés ci-dessous.

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

Il ressort facilement du programme ci-dessus que si vous souhaitez afficher le statut de travail de plusieurs employés, vous devez d'abord définir la classe d'employés, définir le travail de l'employé dans la classe d'employés, puis ajouter une instruction elseif dans la fonction printworking() pour vérifier de quelle classe d'employés l'objet est une instance. Ceci est très indésirable dans les applications pratiques. Si le polymorphisme est utilisé à ce stade, ce problème peut être facilement résolu.

Vous pouvez d'abord créer une classe parent d'employé. Toutes les classes d'employés hériteront de la classe parent d'employé et hériteront de toutes les méthodes et attributs de la classe parent. Créez ensuite une relation « est un » dans la classe d'employés pour déterminer s'il s'agit d'un employé légal.

【Exemple】 L'exemple ci-dessus est réécrit en utilisant le polymorphisme. Le code est affiché ci-dessous.

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());//显示经理的工作

Analyse : dans le programme ci-dessus, définissez d'abord une classe de base d'employés et définissez une méthode pour le statut de travail des employés. Définissez ensuite trois classes d'employés qui hériteront de la classe de base des employés : Peintre, Dactylo et Manager. Définissez ensuite une méthode pour afficher le statut de travail de l'employé. Et créez une relation « est-un » dans cette méthode pour déterminer s'il s'agit d'un employé légal. Les résultats sont présentés ci-dessous.

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

À partir de l'exemple ci-dessus, nous pouvons constater que quel que soit le nombre de classes d'employés ajoutées, il vous suffit d'implémenter la classe d'employés et les méthodes héritées de la classe parent d'employés. Il n'est pas nécessaire de modifier la méthode printing() qui affiche le statut de travail des employés.

Deux méthodes pour implémenter le polymorphisme PHP

En PHP5, le type de variables n'est pas défini. Une variable peut pointer vers n'importe quel type de valeur, chaîne, objet, ressource, etc. On ne peut pas dire que le polymorphisme en PHP5 est une variable.

Nous pouvons seulement dire qu'en PHP5, le polymorphisme est appliqué dans la position de l'indice de type des paramètres de la méthode.

Tout objet de sous-classe d'une classe peut satisfaire à l'exigence de type avec le type actuel comme indice de type.

Toutes les classes qui implémentent cette interface peuvent répondre aux exigences des paramètres de méthode en utilisant le type d'interface comme indice de type.

En termes simples, une classe a l'identité de sa classe parent et l'interface implémentée.

Réalisez le polymorphisme en implémentant des 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();
?>

Utilisez des interfaces et la composition pour simuler l'héritage multiple

Simulez l'héritage multiple grâce à la composition.

L'héritage multiple n'est pas pris en charge en PHP Si nous voulons utiliser les méthodes de plusieurs classes pour réaliser la réutilisation du code, existe-t-il un moyen ?

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

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

接口实例

写一个概念性的例子。 我们设计一个在线销售系统，用户部分设计如下： 将用户分为，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视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!