PHP设计模式——适配器模式_PHP教程
PHP设计模式——适配器模式
适配器模式(有时候也称包装样式或者包装)将一个类的接口适配成用户所期待的(适配器模式要解决的核心问题)。一个适配允许通常因为接口不兼容而不能在一起工作的类工作在一起,做法是将类自己的接口包裹在一个已存在的类中。
类图:
待适配(ForeignPlayer)角色:此角色的接口规则内部的接口规则不一致,但内部需要调用该角色的方法功能。
内部接口(IPlayer)角色:这是一个抽象角色,此角色给出内部期待的接口规则。
适配器(Adapter)角色:通过在内部包装一个Adapter对象,把待适配接口转换成目标接口,此角色为适配器模式的核心角色,也是适配器模式所解决问题的关键。
代码:
<!--?php /** * Created by PhpStorm. * User: Jiang * Date: 2015/4/26 * Time: 12:23 */ //-------------抽象接口--------------- /**抽象运动员 * Interface IPlayer */ interface IPlayer { function Attack(); function Defense(); } /**前锋 * Class Forward */ class Forward implements IPlayer { function Attack() { echo 前锋攻击<br/-->; } function Defense() { echo 前锋防御 ; } } /**中锋 * Class Center */ class Center implements IPlayer { function Attack() { echo 中锋攻击 ; } function Defense() { echo 中锋防御 ; } } //--------------待适配对象----------- /**姚明 外籍运动员 * Class Yaoming */ class Yaoming { function 进攻() { echo 姚明进攻 ; } function 防御() { echo 姚明防御 ; } } //------------适配器-------------- /**适配器 * Class Adapter */ class Adapter implements IPlayer { private $_player; function __construct() { $this->_player=new Yaoming(); } function Attack() { $this->_player->进攻(); } function Defense() { $this->_player->防御(); } }
客户端测试代码:
header(Content-Type:text/html;charset=utf-8); //------------------------原型模式测试代码------------------ require_once ./Adapter/Adapter.php; $player1=new Forward(); echo 前锋上场: ; $player1->Attack(); $player1->Defense(); echo
; echo 姚明上场:
; $yaoming=new Adapter(); $yaoming->Attack(); $yaoming->Defense();
适用场景
1.接口中规定了所有要实现的方法
2.但要有一个实现此接口的具体类,只用到了其中的几个方法,而其它的方法都是没有用的。
注意事项
1.充当适配器角色的类就是实现已有接口的抽象类
2.为什么要用抽象类:
此类是不要被实例化的。而只充当适配器的角色,也就为其子类提供了一个共同的接口,但其子类又可以将精力只集中在其感兴趣的地方。

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)

Sujets chauds



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

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.

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.

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.

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

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.
