php中的设计模式之--中介模式_PHP教程
php中的设计模式之--中介模式
<?php /* 中介者模式是一种行为型模式,它包装了一系列对象相互作用的方式, 使得这些对象不必相互明显作用,从而使它们可以松散偶合。当某些对象之间的作用发生改变时, 不会立即影响其他的一些对象之间的作用,保证这些作用可以彼此独立的变化。 定义一个中介对象来封装系列对象之间的交互。中介者使各个对象不需要显示地相互引用,从而使其耦合性松散,而且可以独立地改变他们之间的交互。 主要角色 ? 中介者(Mediator)角色:定义了对象间相互作用的接口(房产中介) ? 具体中介者(ConcreteMediator)角色:实现了中介者定义的接口。 . 如果一个对象会影响其他的对象,同时也会被其他对象影响,那么这两个对象称为同事类 ? 具体对象(ConcreteColleague)角色:通过中介者和别的对象进行交互(房东) 中介者模式的优点 适当地使用中介者模式可以避免同事类之间的过度耦合,使得各同事类之间可以相对独立地使用。 使用中介者模式可以将对象间一对多的关联转变为一对一的关联,使对象间的关系易于理解和维护。 使用中介者模式可以将对象的行为和协作进行抽象,能够比较灵活的处理对象间的相互作用。 用一个中介对象来封装一系列的对象交互,使各对象不需要显式地相互引用从而使其耦合松散,而且可以 独立地改变它们之间的交互 QQ聊天系统就是一个中介模式 , <---->朋友1 我<-->QQ <---->朋友2 <---->朋友13 */ // 抽象中介,QQ聊天 interface ChatMediator { // 中介者角色 public function sendMessage($msg,$user); public function addQQUser($user); } // 抽象用户 abstract class User { protected $mediator; protected $name; public function __construct($med, $name){ $this->mediator = $med; $this->name = $name; } public abstract function send($msg); public abstract function receive($msg); } class QQchat implements ChatMediator { // 用户列表 private $users; public function __construct(){ $this->users = null ; } // 添加用户 public function addQQUser($user){ $this->users[] = $user; } // 发送具体的QQ信息通过QQ发送 public function sendMessage($msg, $user) { foreach($this->users as $k =>$v){ // 自己发送的自己不能接受 if($v != $user){ // 调用好友的接口 $v->receive($msg); } } } } // 具体对象角色 class QQUser extends User { public function send($msg){ $this->mediator->sendMessage($msg, $this); } // 接受 public function receive($msg) { echo $this->name.' receive '.$msg.'<br>' ; } } // client // 中介为QQ $QQchat = new QQchat(); $oMe = new QQUser($QQchat, "张三"); $oFriend1 = new QQUser($QQchat, "李四"); $oFriend2 = new QQUser($QQchat, "王伟"); $oFriend3 = new QQUser($QQchat, "大哥"); // 添加好友 $QQchat->addQQUser($oMe); $QQchat->addQQUser($oFriend1); $QQchat->addQQUser($oFriend2); $QQchat->addQQUser($oFriend3); $oMe->send("Hi All");

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Dans le framework Java, la différence entre les modèles de conception et les modèles architecturaux réside dans le fait que les modèles de conception définissent des solutions abstraites aux problèmes courants de conception de logiciels, en se concentrant sur l'interaction entre les classes et les objets, tels que les modèles d'usine. Les modèles architecturaux définissent la relation entre les structures et les modules du système, en se concentrant sur l'organisation et l'interaction des composants du système, tels que l'architecture en couches.

Le modèle décorateur est un modèle de conception structurelle qui permet l’ajout dynamique de fonctionnalités d’objet sans modifier la classe d’origine. Il est mis en œuvre grâce à la collaboration de composants abstraits, de composants concrets, de décorateurs abstraits et de décorateurs concrets, et peut étendre de manière flexible les fonctions de classe pour répondre aux besoins changeants. Dans cet exemple, des décorateurs de lait et de moka sont ajoutés à Espresso pour un prix total de 2,29 $, démontrant la puissance du modèle de décorateur pour modifier dynamiquement le comportement des objets.

Le modèle Adaptateur est un modèle de conception structurelle qui permet à des objets incompatibles de fonctionner ensemble. Il convertit une interface en une autre afin que les objets puissent interagir de manière fluide. L'adaptateur d'objet implémente le modèle d'adaptateur en créant un objet adaptateur contenant l'objet adapté et en implémentant l'interface cible. Dans un cas pratique, grâce au mode adaptateur, le client (tel que MediaPlayer) peut lire des médias au format avancé (tels que VLC), bien qu'il ne prenne lui-même en charge que les formats multimédias ordinaires (tels que MP3).

1. Modèle d'usine : séparez la création d'objets et la logique métier, et créez des objets des types spécifiés via des classes d'usine. 2. Modèle d'observateur : permet aux objets sujets d'informer les objets observateurs de leurs changements d'état, obtenant ainsi un couplage lâche et un modèle d'observateur.

TDD est utilisé pour écrire du code PHP de haute qualité. Les étapes comprennent : l'écriture de cas de test, la description des fonctionnalités attendues et leur échec. Écrivez du code de manière à ce que seuls les cas de test réussissent sans optimisation excessive ni conception détaillée. Une fois les cas de test réussis, optimisez et refactorisez le code pour améliorer la lisibilité, la maintenabilité et l’évolutivité.

Les modèles de conception résolvent les problèmes de maintenance du code en fournissant des solutions réutilisables et extensibles : Modèle d'observateur : permet aux objets de s'abonner aux événements et de recevoir des notifications lorsqu'ils se produisent. Factory Pattern : fournit un moyen centralisé de créer des objets sans recourir à des classes concrètes. Modèle Singleton : garantit qu'une classe n'a qu'une seule instance, qui est utilisée pour créer des objets accessibles globalement.

Les avantages de l'utilisation de modèles de conception dans les frameworks Java incluent : une lisibilité, une maintenabilité et une évolutivité améliorées du code. Les inconvénients incluent la complexité, la surcharge de performances et la courbe d'apprentissage abrupte due à une utilisation excessive. Cas pratique : Le mode proxy permet de charger des objets paresseusement. Utilisez les modèles de conception à bon escient pour tirer parti de leurs avantages et minimiser leurs inconvénients.

Le framework Guice applique un certain nombre de modèles de conception, notamment : Modèle Singleton : garantir qu'une classe n'a qu'une seule instance via l'annotation @Singleton. Modèle de méthode d'usine : créez une méthode d'usine via l'annotation @Provides et obtenez l'instance d'objet lors de l'injection de dépendances. Mode stratégie : encapsulez l'algorithme dans différentes classes de stratégie et spécifiez la stratégie spécifique via l'annotation @Named.
