假如你有一个形状类(Shape)，目前它扩展出了两个子类，圆形类和正方形类。伪代码如下：

1. interface Shape 
2.  
3. { 
4.  
5.     function fill (); 
6.  
7. } 
8.  
9.  
10.  
11. class circleShage implements Shape 
12.  
13. { 
14.  
15.     public function fill () 
16.  
17.     { 
18.  
19.         echo '圆形' . PHP_EOL; 
20.  
21.     } 
22.  
23. } 
24.  
25.  
26.  
27. class SquareShape implements Shape 
28.  
29. { 
30.  
31.     public function fill () 
32.  
33.     { 
34.  
35.         echo '正方形' . PHP_EOL; 
36.  
37.     } 
38.  
39. } 

现在你想给形状增加颜色——红色、蓝色。那么，你应该如何做，如果用继承的思想，那么就需要写出四个类，分别如下：

1. class RedCircleShage implements Shape 
2.  
3. { 
4.  
5.     public function fill () 
6.  
7.     { 
8.  
9.         echo '红色圆形' . PHP_EOL; 
10.  
11.     } 
12.  
13. } 
14.  
15.  
16.  
17. class RedSquareShape implements Shape 
18.  
19. { 
20.  
21.     public function fill () 
22.  
23.     { 
24.  
25.         echo '红色正方形' . PHP_EOL; 
26.  
27.     } 
28.  
29. } 
30.  
31.  
32.  
33. class BlueCircleShage implements Shape 
34.  
35. { 
36.  
37.     public function fill () 
38.  
39.     { 
40.  
41.         echo '蓝色圆形' . PHP_EOL; 
42.  
43.     } 
44.  
45. } 
46.  
47.  
48.  
49. class BlueSquareShape implements Shape 
50.  
51. { 
52.  
53.     public function fill () 
54.  
55.     { 
56.  
57.         echo '蓝色正方形' . PHP_EOL; 
58.  
59.     } 
60.  
61. } 

但现在如果我想加入新的形状——三角形，新的颜色——黑色以及白色。那么我们就需要12个子类（类爆炸），那么有没有什么好的办法来解决呢?

合成（组合）与聚合

解决上述问题前，我们想理解合成与聚合的含义。

合成聚合原则：尽量使用合成/聚合，尽量不要使用继承。

合成（组合）：表示一种整体与部分的关系（强关系），它们具有相同的生命周期，比如人和心脏的关系，心脏是人的一部分。

聚合：表示一种整体与部分的关系（弱关系），表示A对象可以包含B对象，但B对象并不是A对象的一部分。比如，我们上面所说的形状和颜色，形状可以包含颜色，但颜色并不是形状的一部分。

桥接模式，就是使用聚合来对系统进行解耦的。

桥接模式

定义：将抽象部分与它的实现分离，使他们可以独立的变化

上面的定义很难理解，用我们上面的例子就是，一个系统可能有多个角度分类（颜色、形状），每一种分类都可能有变化（新增新的形状和颜色），那么我们就可以用多个角度将系统的实现分离出来，降低他们之间的耦合。

那么如何来实现呢？下面是实现代码：

1. abstract class FShape 
2.  
3. { 
4.  
5.     protected $color = null; 
6.  
7.     public function __construct(IColor $color) 
8.  
9.     { 
10.  
11.         $this->color = $color; 
12.  
13.     } 
14.  
15.     public function shape () 
16.  
17.     { 
18.  
19.         echo $this->color->color() . $this->setShape() . PHP_EOL; 
20.  
21.     } 
22.  
23.     protected abstract function setShape (); 
24.  
25. } 
26.  
27.  
28.  
29. class CircleShape extends FShape 
30.  
31. { 
32.  
33.     protected function setShape () 
34.  
35.     { 
36.  
37.         return '圆形'; 
38.  
39.     } 
40.  
41. } 
42.  
43.  
44.  
45. class SquareShape extends FShape 
46.  
47. { 
48.  
49.     protected function setShape () 
50.  
51.     { 
52.  
53.         return '正方形'; 
54.  
55.     } 
56.  
57. } 
58.  
59.  
60.  
61. interface IColor 
62.  
63. { 
64.  
65.     public function color (); 
66.  
67. } 
68.  
69.  
70.  
71. class BlueColor implements IColor 
72.  
73. { 
74.  
75.     public function color () 
76.  
77.     { 
78.  
79.         return '蓝色'; 
80.  
81.     } 
82.  
83. } 
84.  
85.  
86.  
87. class RedColor implements IColor 
88.  
89. { 
90.  
91.     public function color () 
92.  
93.     { 
94.  
95.         return '红色'; 
96.  
97.     } 
98.  
99. } 

测试代码如下：

1. $blueColor = new BlueColor(); 
2.  
3. $redColor = new RedColor(); 
4.  
5. $blueCircleShape = new CircleShape($blueColor); 
6.  
7. $redCircleShape = new CircleShape($redColor); 
8.  
9. $blueSquareShape = new SquareShape($blueColor); 
10.  
11. $redSquareShape = new SquareShape($redColor); 
12.  
13. $blueCircleShape->shape(); 
14.  
15. $redCircleShape->shape(); 
16.  
17. $blueSquareShape->shape(); 
18.  
19. $redSquareShape->shape(); 

使用桥接模式后，我们的代码就符合了“开闭原则”， 当有新的形状或颜色加入时，我们只需要添加新的类即可。而不用去修改之前的类。

Tags: php设计模式 php桥接模式

分享到：