Gekoppeltes Designmuster in PHP

In diesem Artikel wird hauptsächlich das Kopplungsentwurfsmuster für die Implementierung von PHP vorgestellt, das einen gewissen Referenzwert hat. Jetzt können Freunde in Not darauf verweisen.

Eine Software mit vielen Klassen Sobald eine Klasse eine enge Beziehung zu einer anderen Klasse hat, wird die Wiederverwendbarkeit der Software stark eingeschränkt. Daher hängt die Wiederverwendbarkeit einer Software von ihrem Kopplungsgrad ab.

Kopplungsgrad: der Grad der Assoziation und Abhängigkeit zwischen Programmmodulen.

Während des Entwurfsprozesses vorgeschlagen: Beim Entwurf der Architektur dieser Software wurde festgestellt, dass der logische Operationsteil (SimpleRouter-Klasse) und der Ausgabeteil (SimpleRouterFrame-Klasse) dieser Software nicht gut kombiniert werden können. Das heißt: Wir müssen die Referenz auf die Programmschnittstelle (Referenz auf SimpleRouterFrame) Schicht für Schicht an den Kernteil des Programms übergeben, um die Ausgabefunktion bereitzustellen.

Während des Entwicklungsprozesses wurde darauf hingewiesen, dass, wenn wir einige Änderungen an der Ausgabeschnittstelle (SimpleRouterFrame-Klasse) vornehmen, insbesondere nachdem die Namen einiger Methoden geändert wurden, der Code des entsprechenden Kernteils des Programms (SimpleRouter-Klasse) muss ebenfalls geändert werden, um sich an diese neue Ausgabeschnittstelle anzupassen.

Ursache des Problems: Die Kopplung zwischen Klassen ist zu eng, sodass jedes Mal, wenn eine Klasse geändert werden muss, die entsprechende zugehörige Klasse den Code ändern muss, um sich an die geänderte Klasse anzupassen. Beispiel: Eine bestimmte Klasse A muss die öffentliche Methode einer anderen Klasse B direkt aufrufen. Sobald B diese Methode nicht mehr unterstützt oder den Methodennamen neu schreibt, muss A den Code zur Anpassung neu schreiben. Eine andere Situation: Eine bestimmte Klasse A muss Klasse B mit einer bestimmten Methode verwenden, aber die Form von B ist nicht bestimmt. Sobald sich die interne Struktur von B ändert, muss A möglicherweise den Code neu schreiben.

Um diese Situation zu vermeiden, muss die Kopplung zwischen A und B verringert werden. Unabhängig von der Form muss A den Code nicht neu schreiben, solange B noch die von A erforderlichen Funktionen erreichen kann. Lösung: Lassen Sie B eine bestimmte Schnittstelle I implementieren und I.Method(); gleichzeitig kann A die Methode von B direkt aufrufen, und B würde als Parameter an A übergeben würde die Methode von B aufrufen. Die Stelle

1    {      
2        A.AMethod(B b ) {      
3            b.BMethod();      
4            /*….*/      
5        }      
6    }

wird geändert in:

1    {      
2        A.AMethod(I i ) {      
3            i.Method();      
4        }      
5    }

Hier muss B nur die Methode I.Method() implementieren und die Implementierungsdetails vollständig verbergen. Mit dieser Methode wird eine lose Kopplung zwischen Klassen erreicht und die Wiederverwendbarkeit von Klassen erheblich verbessert. Wenn wir auf die Entwurfsmuster zurückblicken, die wir zuvor gelernt haben, können wir feststellen, dass sie dem Observer-Muster ähneln.

下面是一个完整的例子：

001    <?php    
002    interface Calculation {    
003        function compute($a, $b);    
004    }    
005         
006    class Addition implements Calculation {    
007        function compute($a, $b)    
008        {    
009            return "加法运算结果为:".($a+$b);    
010        }    
011    }    
012         
013    class Subtraction implements Calculation {    
014        function compute($a, $b)    
015        {    
016            return "减法运算结果为:".($a-$b);    
017        }    
018    }    
019         
020    class Multiplication implements Calculation {    
021        function compute($a, $b)    
022        {    
023            return "乘法运算结果为:".($a*$b);    
024        }    
025    }    
026         
027    class pision implements Calculation{    
028        function compute($a, $b)    
029        {    
030            return "除法运算结果为:".($a/$b);    
031        }    
032    }    
033         
034    class Modf implements Calculation {    
035        function compute($a, $b)    
036        {    
037            return "取模运算结果为:".($a % $b);    
038        }    
039    }    
040         
041    class Coupling implements Calculation {    
042        //这里直接：public $varl = new LazyDog(); 会出错。    
043        public $varl = null;    
044             
045        function __construct()    
046        {    
047            $this->varl = new LazyDog();    
048        }    
049             
050        function compute($a, $b)    
051        {    
052            return $this->varl->say();    
053        }    
054    }    
055         
056    /*也可以用继承的方式实现哟:    
057    class Coupling extends LazyDog implements Calculation {    
058        function compute($a, $b)    
059        {    
060            return parent::say();    
061        }    
062    }    
063    */    
064         
065    class LazyDog {    
066        function say()    
067        {    
068            return "我什么运算都不做...只是为了实现&#39;耦合设计模式&#39;...我是出来打酱油的......";    
069        }    
070    }    
071         
072    class Test {    
073        private $one;    
074        private $two;    
075        public function __construct($x,$y)    
076        {    
077            $this->one=$x;    
078            $this->two=$y;    
079            echo "Class Test 初始化：属性\$one=".$this->one."，属性\$two=".$this->two."<h />";    
080       }    
081       function display(Calculation $a){    
082            return "用PHP接口技术实现的运算：".$a->compute($this->one,$this->two)."<hr/>";    
083       }    
084    }    
085         
086    $t = new Test(96,12);    
087    $t1 = new Addition();    
088    $t2 = new Subtraction();    
089    $t3 = new Multiplication();    
090    $t4 = new pision();    
091    $t5 = new Modf();    
092         
093    $dog = new Coupling();    
094         
095    echo $t->display($t1);    
096    echo $t->display($t2);    
097    echo $t->display($t3);    
098    echo $t->display($t4);    
099    echo $t->display($t5);    
100         
101    echo $t->display($dog);    
102         
103    ?>

程序运行结果：

1    Class Test 初始化：属性$one=96，属性$two=12    
2    用PHP接口技术实现的运算：加法运算结果为:108    
3    用PHP接口技术实现的运算：减法运算结果为:84    
4    用PHP接口技术实现的运算：乘法运算结果为:1152    
5    用PHP接口技术实现的运算：除法运算结果为:8    
6    用PHP接口技术实现的运算：取模运算结果为:0    
7    用PHP接口技术实现的运算：我什么运算都不做...只是为了实现'耦合设计模式'...我是出来打酱油的......

相关推荐：

PHP的标准库

Das obige ist der detaillierte Inhalt vonGekoppeltes Designmuster in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!