Comprendre le polymorphisme PHP

Cet article présente principalement la compréhension du polymorphisme PHP, qui a une certaine valeur de référence. Maintenant, je le partage avec tout le monde. Les amis dans le besoin peuvent s'y référer

Polymorphisme PHP

Plus de moyens de morphisme. 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 à sa manière à un message commun. 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 qui existent entre les différents objets de sous-classe peuvent être masquées. coder et élaborer une programmation commune pour s'adapter à l'évolution des besoins.

2. Conception d'applications polymorphes

Dans le développement d'applications réelles, généralement afin de permettre au projet de s'étendre et de se mettre à niveau facilement à l'avenir, il est nécessaire de mettre en œuvre des applications réutilisables. modules via héritage pour des mises à niveau faciles. 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 différents types de traitement qui sont généralement implémentés à l'aide d'instructions de contrôle de flux. Le code est affiché ci-dessous.

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

Analyse : Dans le programme ci-dessus, deux classes d'employés sont d'abord définies : 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.

Le peintre peint
La dactylo tape

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. Et définissez le travail de l'employé dans la classe d'employés, puis ajoutez 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é 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] illustre l'utilisation du polymorphisme pour réécrire l'exemple ci-dessus. 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.

Le peintre peint !
La dactylographe tape !
Le manager est en réunion !

D'après l'exemple ci-dessus, on constate que peu importe le nombre d'employés. les classes sont ajoutées, il vous suffit d'implémenter automatiquement la classe d'employé et les méthodes héritées de la classe parent d'employé. Il n'est pas nécessaire de modifier la méthode printing() qui affiche le statut de travail des employés.

Ce qui précède représente l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'étude de chacun. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois !

Recommandations associées :

Introduction à la programmation de fichiers PHP

Introduction à la syntaxe PHP de base

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!