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 }Nach dem Login kopieren
wird geändert in:
1 {
2 A.AMethod(I i ) {
3 i.Method();
4 }
5 }Nach dem Login kopieren
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 "我什么运算都不做...只是为了实现'耦合设计模式'...我是出来打酱油的......";
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 ?>Nach dem Login kopieren
程序运行结果：
1 Class Test 初始化：属性$one=96，属性$two=12
2 用PHP接口技术实现的运算：加法运算结果为:108
3 用PHP接口技术实现的运算：减法运算结果为:84
4 用PHP接口技术实现的运算：乘法运算结果为:1152
5 用PHP接口技术实现的运算：除法运算结果为:8
6 用PHP接口技术实现的运算：取模运算结果为:0
7 用PHP接口技术实现的运算：我什么运算都不做...只是为了实现'耦合设计模式'...我是出来打酱油的......
Nach dem Login kopieren
相关推荐：
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!
