Über PHP-Designmuster – detaillierte Erläuterung der Adaptermethode

Konvertieren Sie die Schnittstelle einer Klasse in eine andere vom Kunden gewünschte Schnittstelle. Der Adaptermodus ermöglicht die Zusammenarbeit von Klassen, die aufgrund inkompatibler Schnittstellen nicht zusammenarbeiten können. Dieser Artikel teilt Ihnen hauptsächlich die detaillierte Erklärung des Adapters mit und hofft, Ihnen weiterzuhelfen.

Hauptrolle

Zielrolle: Definiert die vom Client verwendete domänenspezifische Schnittstelle, das ist es, was wir erwarten

Quellrolle : Die Schnittstelle, die angepasst werden muss

Adapterrolle: Passen Sie die Adaptee-Schnittstelle und die Zielschnittstelle an. Der Adapter konvertiert die Quellschnittstelle in die Zielschnittstelle Klasse

Anwendbarkeit

Sie möchten eine vorhandene Klasse verwenden, deren Schnittstelle jedoch nicht Ihren Anforderungen entspricht.

2. Sie möchten eine Klasse erstellen, die kopiert werden kann Eine Klasse, die mit anderen nicht verwandten oder unvorhergesehenen Klassen zusammenarbeiten kann

3. Sie möchten eine Unterklasse einer vorhandenen Klasse erstellen, aber es ist unmöglich, jede Unterklasse mit ihren Schnittstellen abzugleichen. Der Objektadapter kann sich an die Schnittstelle seiner übergeordneten Klasse anpassen (nur Objektadapter)

//目标角色  
interface Target {  
    public function simpleMethod1();  
    public function simpleMethod2();  
}  
  
//源角色  
class Adaptee {  
      
    public function simpleMethod1(){  
        echo &#39;Adapter simpleMethod1&#39;."<br>";  
    }  
}  
  
//类适配器角色  
class Adapter implements Target {  
    private $adaptee;  
      
      
    function __construct(Adaptee $adaptee) {  
        $this->adaptee = $adaptee;   
    }  
      
    //委派调用Adaptee的sampleMethod1方法  
    public function simpleMethod1(){  
        echo $this->adaptee->simpleMethod1();  
    }  
      
    public function simpleMethod2(){  
        echo &#39;Adapter simpleMethod2&#39;."<br>";     
    }   
      
}  
  
//客户端  
class Client {  
      
    public static function main() {  
        $adaptee = new Adaptee();  
        $adapter = new Adapter($adaptee);  
        $adapter->simpleMethod1();  
        $adapter->simpleMethod2();   
    }  
}  
  
Client::main();

Vielleicht wissen Sie aufgrund der oben genannten Informationen nicht, was ein Adapter ist. Lassen Sie mich als nächstes im Detail erklären

Wann sollte der Adaptermodus verwendet werden?

Tatsächlich ist das einfachste Beispiel die Verwendung einer Bibliothek eines Drittanbieters. Diese Klassenbibliotheken werden mit der Aktualisierung der Version aktualisiert, und auch die entsprechenden APIs ändern sich. Wenn sich die Schnittstelle ändert, ist der Adapter praktisch

Lassen Sie mich Ihnen ein praktisches Beispiel geben

Harmonie am Anfang

Spezialisiert auf die Produktion durch Black Date Toy Company Spielzeug: Die produzierten Spielzeuge beschränken sich nicht nur auf Hunde, Katzen, Löwen, Fische und andere Tiere. Jedes Spielzeug kann die Operationen „Mund öffnen“ und „Mund schließen“ ausführen, und die Methoden openMouth und closeMouth werden jeweils aufgerufen. Zu diesem Zeitpunkt können wir leicht denken, dass wir zunächst eine abstrakte Klasse Toy oder sogar eine Schnittstelle Toy definieren können. Andere Klassen können die übergeordnete Klasse erben und die Methoden der übergeordneten Klasse implementieren. Es herrscht Harmonie und Vertrauen.

Reibungslose Zerstörung

Um das Geschäft auszubauen, kooperiert Black Date Toy Company jetzt mit Red Date Remote Control Company, die Fernbedienungsgeräte zur Steuerung des Mundes verwenden kann Tiere. Das Fernbedienungsgerät der Hongzao Remote Control Company ruft jedoch die Methoden doMouthOpen und doMouthClose von Tieren auf. Was die Programmierer der Heizao Toy Company jetzt tun müssen, ist, die Klassen der Toy-Serie zu aktualisieren, damit Toy die Methoden doMouthOpen und doMouthClose aufrufen kann.

Als wir über die Implementierungsmethode nachdachten, dachten wir direkt, dass ich diese beiden Methoden einfach für Sie in meine übergeordnete Klasse und Unterklasse hinzufügen werde, wenn Sie sie benötigen. Wenn Sie diese beiden Methoden immer wieder zur übergeordneten Klasse und Unterklasse hinzufügen, werden Sie immer über solche sich wiederholenden Arbeiten nachdenken. Kann das nicht gelöst werden? Programmierer werden verrückt, wenn es Hunderte von Unterklassen gibt. Programmierer konkurrieren oft darum, wer „fauler“ ist, wenn dies keinen Einfluss auf die Effizienz hat. Programmierer werden sich dumm fühlen, wenn sie so weitermachen. (Eigentlich benehme ich mich oft wie dieser Idiot)

abstract class Toy
{
    public abstract function openMouth();

    public abstract function closeMouth();

    //为红枣遥控公司控制接口增加doMouthOpen方法
    public abstract function doMouthOpen();

    //为红枣遥控公司控制接口增加doMouthClose方法
    public abstract function doMouthClose();
}

class Dog extends Toy
{
    public function openMouth()
    {
        echo "Dog open Mouth\n";
    }

    public function closeMouth()
    {
        echo "Dog open Mouth\n";
    }

    //增加的方法
    public function doMouthOpen()
    {
        $this->doMouthOpen();
    }

    //增加的方法
    public function doMouthClose()
    {
        $this->closeMouth();
    }
}

class Cat extends Toy
{
    public function openMouth()
    {
        echo "Cat open Mouth\n";
    }

    public function closeMouth()
    {
        echo "Cat open Mouth\n";
    }

    //增加的方法
    public function doMouthOpen()
    {
        $this->doMouthOpen();
    }

    //增加的方法
    public function doMouthClose()
    {
        $this->closeMouth();
    }
}

Mehr gereizt

Der Programmierer war gerade mit dem Codieren fertig und trank einen Schluck Wasser, als plötzlich eine weitere Nachricht kam. Die Heizao Toy Company möchte auch mit der Luzao Remote Control Company zusammenarbeiten, da die Fernbedienungsausrüstung der Luzao Remote Control Company günstiger und stabiler ist. Das Fernbedienungsgerät der Green Date Remote Control Company ruft jedoch die operMouth(Typ)-Methode des Tieres auf, um eine Mundkontrolle zu erreichen. Wenn Typ 0 ist, „Halt die Klappe“, andernfalls öffne deinen Mund. Jetzt muss der Programmierer Toy und seine Unterklassen aktualisieren, damit Toy die Methode operMouth() aufrufen kann. Niemand ist mehr ruhig.

abstract class Toy  
{  
    public abstract function openMouth();  
  
    public abstract function closeMouth();  
  
    public abstract function doMouthOpen();  
  
    public abstract function doMouthClose();  
  
    //为绿枣遥控公司控制接口增加doMouthClose方法  
    public abstract function operateMouth($type = 0);  
}  
  
class Dog extends Toy  
{  
    public function openMouth()  
    {  
        echo "Dog open Mouth\n";  
    }  
  
    public function closeMouth()  
    {  
        echo "Dog open Mouth\n";  
    }  
  
    public function doMouthOpen()  
    {  
        $this->doMouthOpen();  
    }  
  
    public function doMouthClose()  
    {  
        $this->closeMouth();  
    }  
  
    public function operateMouth($type = 0)  
    {  
        if ($type == 0) {  
            $this->closeMouth();  
        } else {  
            $this->operateMouth();  
        }  
    }  
}  
  
class Cat extends Toy  
{  
    public function openMouth()  
    {  
        echo "Cat open Mouth\n";  
    }  
  
    public function closeMouth()  
    {  
        echo "Cat open Mouth\n";  
    }  
  
    public function doMouthOpen()  
    {  
        $this->doMouthOpen();  
    }  
  
    public function doMouthClose()  
    {  
        $this->closeMouth();  
    }  
  
    public function operateMouth($type = 0)  
    {  
        if ($type == 0) {  
            $this->closeMouth();  
        } else {  
            $this->operateMouth();  
        }  
    }  
}

Zu diesem Zeitpunkt müssen Programmierer ihr Gehirn einsetzen, um eine Lösung zu finden, auch wenn sie eines Tages alle Fernsteuerungsunternehmen wie lila Datteln, grüne Datteln, gelbe Datteln und Bergdatteln verwenden Kommen Sie, sie werden sich weiterhin selbst ignorieren, diese Toy-Klasse wird immer größer. Eines Tages wird auch das System abstürzen.

Was ist das Problem?

Beim Schreiben von Code wie oben verstößt die Codeimplementierung gegen das „Offen-Geschlossen“-Prinzip, das eine Software-Entität haben sollte Offen für Erweiterungen, geschlossen für Änderungen. Das heißt, beim Entwerfen eines Moduls sollte das Modul erweitert werden, ohne dass es geändert wird. Mit anderen Worten, jede Leiche ist ein kleines Königreich. Sie können mich an Ihren Angelegenheiten teilhaben lassen, aber Sie können meinen internen Code nicht ändern, es sei denn, mein interner Code kann wirklich optimiert werden.

Mit dieser Idee verstehen wir, wie man Vererbung nutzt, wie man Polymorphismus nutzt und sogar wie man „hohe Kohäsion, geringe Kopplung“ erreicht.

回到这个问题，我们现在面临这么一个问题，新的接口方法我要实现，旧的接口（Toy抽象类）也不能动，那么总得有个解决方法吧。那就是引入一个新的类--我们本文的主角--适配器。 适配器要完成的功能很明确，引用现有接口的方法实现新的接口的方法。更像它名字描述的那样，你的接口不改的话，我就利用现有接口和你对接一下吧。

到此，解决方法已经呼之欲出了，下面贴上代码。

<?php
abstract class Toy  
{  
    public abstract function openMouth();  
  
    public abstract function closeMouth();  
}  
  
class Dog extends Toy  
{  
    public function openMouth()  
    {  
        echo "Dog open Mouth\n";  
    }  
  
    public function closeMouth()  
    {  
        echo "Dog close Mouth\n";  
    }  
}  
  
class Cat extends Toy  
{  
    public function openMouth()  
    {  
        echo "Cat open Mouth\n";  
    }  
  
    public function closeMouth()  
    {  
        echo "Cat close Mouth\n";  
    }  
}


//目标角色:红枣遥控公司  
interface RedTarget  
{  
    public function doMouthOpen();  
  
    public function doMouthClose();  
}  
  
//目标角色:绿枣遥控公司及  
interface GreenTarget  
{  
    public function operateMouth($type = 0);  
}


//类适配器角色:红枣遥控公司  
class RedAdapter implements RedTarget  
{  
    private $adaptee;  
  
    function __construct(Toy $adaptee)  
    {  
        $this->adaptee = $adaptee;  
    }  
  
    //委派调用Adaptee的sampleMethod1方法  
    public function doMouthOpen()  
    {  
        $this->adaptee->openMouth();  
    }  
  
    public function doMouthClose()  
    {  
        $this->adaptee->closeMouth();  
    }  
}  
  
//类适配器角色:绿枣遥控公司  
class GreenAdapter implements GreenTarget  
{  
    private $adaptee;  
  
    function __construct(Toy $adaptee)  
    {  
        $this->adaptee = $adaptee;  
    }  
  
    //委派调用Adaptee：GreenTarget的operateMouth方法  
    public function operateMouth($type = 0)  
    {  
        if ($type) {  
            $this->adaptee->openMouth();  
        } else {  
            $this->adaptee->closeMouth();  
        }  
    }  
}



class testDriver  
{  
    public function run()  
    {  
         //实例化一只狗玩具  
        $adaptee_dog = new Dog();  
        echo "给狗套上红枣适配器\n";  
        $adapter_red = new RedAdapter($adaptee_dog);  
        //张嘴  
        $adapter_red->doMouthOpen();  
        //闭嘴  
        $adapter_red->doMouthClose();  
        echo "给狗套上绿枣适配器\n";  
        $adapter_green = new GreenAdapter($adaptee_dog);  
        //张嘴  
        $adapter_green->operateMouth(1);  
        //闭嘴  
        $adapter_green->operateMouth(0);  
    }  
}  
  
$test = new testDriver();  
$test->run();

更加烦躁
最后的结果就是，Toy类及其子类在不改变自身的情况下，通过适配器实现了不同的接口。

最后的总结

将一个类的接口转换成客户希望的另外一个接口,使用原本不兼容的而不能在一起工作的那些类可以在一起工作.

适配器模式核心思想：把对某些相似的类的操作转化为一个统一的“接口”(这里是比喻的说话)--适配器，或者比喻为一个“界面”，统一或屏蔽了那些类的细节。适配器模式还构造了一种“机制”，使“适配”的类可以很容易的增减，而不用修改与适配器交互的代码，符合“减少代码间耦合”的设计原则。

Das obige ist der detaillierte Inhalt vonÜber PHP-Designmuster – detaillierte Erläuterung der Adaptermethode. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!