本文实例分析了PHP耦合设计模式。分享给大家供大家参考，具体如下：

一个软件，它具有许多类，类与类之间需要互相调用，一旦某个类与另一个类具有紧密耦合关系的时候，这个软件的重用性就会大大降低。所以一个软件的重用性的高低就取决于它的耦合程度的高低。

耦合度：程序模块之间的关联、依赖程度。

在设计过程中提出：当设计这个软件的体系结构的时候，就发现了这个软件的逻辑运行部分（SimpleRouter类）和输出部分（SimpleRouterFrame类）不能很好的结合起来。即：我们不得不将程序界面的引用（reference to SimpleRouterFrame）一层一层的传递给程序的核心部分，以提供输出功能。

在开发过程中提出：当我们对输出界面（SimpleRouterFrame类）进行了一些修改后，特别是某些方法名称修改后，相应程序核心部分（SimpleRouter类）的代码也需要重新修改以适应这个新的输出界面。

问题的原因：类与类之间耦合的过于紧密，以至于每次需要修改一个类，它相应的关联类都需要修改代码来适应这个修改过的类。 比如说：某个类A需要直接显示的调用另一个类B的public方法，一旦B不再支持这个方法，或者重写了这个方法名称，A就需要重新编写代码来适应。另一种情况：某类A需要用到具有某种特定方法的类B，但B的形式并不确定，一旦B的内部结构改变，A就可能需要重写代码。

为避免这种情况，需要降低A与B之间的耦合度，不论形式如何，只要B仍然能够实现A所需要的功能，A就不需要重写代码， 解决方法：令B实现某种接口I，定义 I.Method(); 同时A在调用B的方法时候直接调用I的方法即可；而从前会将B当作参数传给A，然后A再调用B的方法的地方

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

修改成：

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

在这里，B只需要实现I.Method()方法即可，完全隐藏了实现细节。 按照这种方法，既实现了类与类之间的松散耦合，大大增强了类的可重用性。回顾从前学过的设计模式，可以发现，这与Observer模式有相似之处。

下面是一个完整的例子：

1. <?php 
2. interface Calculation { 
3.   function compute($a, $b); 
4. } 
5. class Addition implements Calculation { 
6.   function compute($a, $b) 
7.   { 
8.     return "加法运算结果为:".($a+$b); 
9.   } 
10. } 
11. class Subtraction implements Calculation { 
12.   function compute($a, $b) 
13.   { 
14.     return "减法运算结果为:".($a-$b); 
15.   } 
16. } 
17. class Multiplication implements Calculation { 
18.   function compute($a, $b) 
19.   { 
20.     return "乘法运算结果为:".($a*$b); 
21.   } 
22. } 
23. class Division implements Calculation{ 
24.   function compute($a, $b) 
25.   { 
26.     return "除法运算结果为:".($a/$b); 
27.   } 
28. } 
29. class Modf implements Calculation { 
30.   function compute($a, $b) 
31.   { 
32.     return "取模运算结果为:".($a % $b); 
33.   } 
34. } 
35. class Coupling implements Calculation { 
36.   //这里直接：public $varl = new LazyDog(); 会出错。 
37.   public $varl = null; 
38.   function __construct() 
39.   { 
40.     $this->varl = new LazyDog(); 
41.   } 
42.   function compute($a, $b) 
43.   { 
44.     return $this->varl->say(); 
45.   } 
46. } 
47. /*也可以用继承的方式实现哟: 
48. class Coupling extends LazyDog implements Calculation { 
49.   function compute($a, $b) 
50.   { 
51.     return parent::say(); 
52.   } 
53. } 
54. */ 
55. class LazyDog { 
56.   function say() 
57.   { 
58.     return "我什么运算都不做...只是为了实现'耦合设计模式'...我是出来打酱油的......"; 
59.   } 
60. } 
61. class Test { 
62.   private $one; 
63.   private $two; 
64.   public function __construct($x,$y) 
65.   { 
66.     $this->one=$x; 
67.     $this->two=$y; 
68.     echo "Class Test 初始化：属性\$one=".$this->one."，属性\$two=".$this->two."<hr />"; 
69.   } 
70.   function display(Calculation $a){ 
71.     return "用PHP接口技术实现的运算：".$a->compute($this->one,$this->two)."<hr />"; 
72.   } 
73. } 
74. $t = new Test(96,12); 
75. $t1 = new Addition(); 
76. $t2 = new Subtraction(); 
77. $t3 = new Multiplication(); 
78. $t4 = new Division(); 
79. $t5 = new Modf(); 
80. $dog = new Coupling(); 
81. echo $t->display($t1); 
82. echo $t->display($t2); 
83. echo $t->display($t3); 
84. echo $t->display($t4); 
85. echo $t->display($t5); 
86. echo $t->display($dog); 
87. ?> 

程序运行结果：

Class Test 初始化：属性$one=96，属性$two=12

用PHP接口技术实现的运算：加法运算结果为:108

用PHP接口技术实现的运算：减法运算结果为:84

用PHP接口技术实现的运算：乘法运算结果为:1152

用PHP接口技术实现的运算：除法运算结果为:8

用PHP接口技术实现的运算：取模运算结果为:0

用PHP接口技术实现的运算：我什么运算都不做...只是为了实现'耦合设计模式'...我是出来打酱油的......

Tags: PHP耦合设计 PHP设计模式

分享到：