(7)设计模式笔记[桥接模式Bridge]

桥是连接彼岸的，Bridge模式就是对两个类进行连接以便于从一个类调用另一个类的属性和方法

这很容易让人想到Adapter模式，也是封装另一个类，以便调用

但是这里略有不同：Adapter的被调用类是不可以修改的

Bridge模式的特点是：被调用的是接口或者抽象类，它的动作在子类，可以在子类改变动作

好了上代码：

package com.vatana.bridge.frame;
/**
* 接口，提供给桥来调用。
* @author Vatana
*/
public interface DisplayImpl {
void impOpen();
void impPrint();
void impClose();
}

package com.vatana.bridge.frame;
/**
* 桥，调用接口方法
* @author Vatana
*/
public class Display {
DisplayImpl impl;
public Display(DisplayImpl impl) {
this.impl = impl;
}
protected void open() {
impl.impOpen();
}
protected void print() {
impl.impPrint();
}
protected void close() {
impl.impClose();
}
public void display() {
open();
print();
close();
}
}

package com.vatana.bridge.work;
import com.vatana.bridge.frame.DisplayImpl;
/**
* 被调用类的具体实现
* @author Vatana
*/
public class StringDisplayImpl implements DisplayImpl{
String msg;
public StringDisplayImpl(String msg){
this.msg = msg;
}
@Override
public void impOpen() {
StringBuilder sb = new StringBuilder();
sb.append("+-");
for(int i = 0; i<msg.length();i++){
sb.append('-');
}
sb.append("-+");
System.out.println(sb);
}
@Override
public void impPrint() {
StringBuilder sb = new StringBuilder();
sb.append("| ").append(msg).append(" |");
System.out.println(sb);
}
@Override
public void impClose() {
StringBuilder sb = new StringBuilder();
sb.append("+-");
for(int i = 0; i<msg.length();i++){
sb.append('-');
}
sb.append("-+");
System.out.println(sb);
}

}

package com.vatana.bridge.work;
import com.vatana.bridge.frame.Display;
import com.vatana.bridge.frame.DisplayImpl;
/**
* 桥的子类，做了其它动作
* @author Vatana
*/
public class MutiDisplay extends Display {
public MutiDisplay(DisplayImpl impl) {
super(impl);
}
public void multiDisplay(int times) {
open();
for (int i = 0; i < times; i++) {
print();
}
close();
}
}

package com.vatana.bridge;
import com.vatana.bridge.frame.Display;
import com.vatana.bridge.frame.DisplayImpl;
import com.vatana.bridge.work.MutiDisplay;
import com.vatana.bridge.work.StringDisplayImpl;
/**
* 测试类
* @author Vatana
*/
public class Test {
public static void main(String[] a){
DisplayImpl impl = new StringDisplayImpl("Hello China!");
Display dis = new MutiDisplay(impl);
dis.display();
((MutiDisplay )dis).multiDisplay(3);
}
}

运行结果：

+--------------+
| Hello China! |
+--------------+
+--------------+
| Hello China! |
| Hello China! |
| Hello China! |
+--------------+

这个模式应该比较容易理解，为什么要使用接口这么多余的东西呢？

我们前面提到要尽量使用接口和抽象类，在这里就显然就体现了这一点。

不知道你注意到包名了没有。我把接口和抽象类都放到frame下。把具体的实现放到work下，这样方便对代码进行管理，

如果需要实现其它逻辑只需要再建立一个work2包，并建两个新的类就行了。

这是分层的好处。