设计模式——桥接模式

设计模式——桥接模式

1桥接模式的定义

桥接模式：桥接模式（Bridge Pattern）是将类的功能层次结构与类的实现层次结构独立，是两者互不影响独立的变化，从而实现了解耦，提高了扩展性。也可以表述为将类的抽象化和实现化独立，使得两者可以独立变化。独立后，还需要提供抽象化和实现化之间的桥接结构，使得两者联系起来，从而降低类之间的耦合度。下面通过具体的代码来介绍桥接模式！

No BB，Show Code！

2桥接模式的代码实现

2-1定义抽象类

定义一个抽象类，功能的扩展在这个抽象类中进行，需要新的功能只需要添加额外添加一个抽象方法即可，代码如下：

package designPattern.test.bridge;

/**
 * 操作系统抽象类
 */
public abstract class OperSystem {

    //操作系统版本
    private String version;

    public OperSystem(String version) {
        this.version = version;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    //管理文件功能
    abstract void manageFile();

    //进程调度
    abstract void manageProcess();

    //设备管理
    abstract void manageDevice();

    //存储管理
    abstract void manageStorage();

    //作业管理
    abstract void manageTask();
}

2-2定义一个桥接类

在桥接类中实现包含一个2-1定义的抽象类，通过不同的方式调用抽象类的方法实现不同的功能，代码如下：

package designPattern.test.bridge;

import java.io.Serializable;

/**
 * 计算机类
 */
public class Computer implements Serializable {

    //操作系统
    private OperSystem operSystem;

    public Computer(OperSystem operSystem) {
        this.operSystem = operSystem;
    }

    //管理文件功能
    public void manageFile() {
        operSystem.manageFile();
    }

    //进程调度
    public void manageProcess() {
        operSystem.manageProcess();
    }

    //设备管理
    public void manageDevice() {
        operSystem.manageDevice();
    }

    //存储管理
    public void manageStorage() {
        operSystem.manageStorage();
    }

    //作业管理
    public void manageTask() {
        operSystem.manageTask();
    }

    //电脑在工作
    public void working() {
        manageProcess();
        manageFile();
        manageDevice();
        manageTask();
        manageStorage();
    }
}

2-3实现的扩展

通过重写抽象类中的抽象方法实现实现的扩展，在本例中，定义了两个具体的OperSystem的实现类，分别为Windows,Linux，代码如下：

Windows：

package designPattern.test.bridge;

/**
 * Windows操作系统类
 */
public class Windows extends OperSystem {

    public Windows(String version) {
        super(version);
    }

    @Override
    void manageFile() {
        System.out.println("Windows " + this.getVersion() + " manageFile......");
    }

    @Override
    void manageProcess() {
        System.out.println("Windows " + this.getVersion() + "  manageProcess......");
    }

    @Override
    void manageDevice() {
        System.out.println("Windows  " + this.getVersion() + " manageDevice......");
    }

    @Override
    void manageStorage() {
        System.out.println("Windows " + this.getVersion() + "  manageStorage......");
    }

    @Override
    void manageTask() {
        System.out.println("Windows " + this.getVersion() + "  manageTask......");
    }
}

Linux:

package designPattern.test.bridge;

/**
 * Created by yanhuan1 on 2018/2/27.
 */
public class Linux extends OperSystem {

    public Linux(String version) {
        super(version);
    }

    @Override
    void manageFile() {
        System.out.println("Linux " + this.getVersion() + " manageFile......");
    }

    @Override
    void manageProcess() {
        System.out.println("Linux " + this.getVersion() + "  manageProcess......");
    }

    @Override
    void manageDevice() {
        System.out.println("Linux  " + this.getVersion() + " manageDevice......");
    }

    @Override
    void manageStorage() {
        System.out.println("Linux " + this.getVersion() + "  manageStorage......");
    }

    @Override
    void manageTask() {
        System.out.println("Linux " + this.getVersion() + "  manageTask......");
    }
}

2-4功能的扩展

功能的扩展则通过继承Computer类来实现，每一种电脑有自己独有的功能！在本例中定义了两个具体的Computer子类，分别为ThinkPad和HPComputer，两个类实现了不同的功能扩展，具体代码如下：

ThinkPad：

package designPattern.test.bridge;

/**
 * ThinkPad电脑
 */
public class ThinkPad extends Computer {

    public ThinkPad(OperSystem operSystem) {
        super(operSystem);
    }

    //从Computer类功能扩展来的方法
    public void thinkPad() {
        System.out.println("ThinkPad manangeProcess start....");
        manageProcess();
        System.out.println("ThinkPad manangeProcess end....");
    }
}

HPComputer：

package designPattern.test.bridge;

/**
 * 惠普电脑
 */
public class HPComputer extends Computer {

    public HPComputer(OperSystem operSystem) {
        super(operSystem);
    }

    //惠普电脑扩展的方法
    public void hpComputer() {
        System.out.println("HPComputer manageFile start....");
        manageFile();
        System.out.println("HPComputer manageFile end....");
    }
}

3测试

测试代码如下：

package designPattern.test.bridge;

import org.junit.Test;

/**
 * 桥接模式测试
 */
public class BridgeTest {

    @Test
    public void testBridge() {
        Computer thinkPad = new ThinkPad(new Windows("Win7"));
        Computer hp = new HPComputer(new Linux("CentOS 7.0"));
        thinkPad.working();
        hp.working();
        ThinkPad thinkPad1 = new ThinkPad(new Linux("CentOS 6.8"));
        HPComputer hpComputer = new HPComputer(new Windows("Win10"));
        thinkPad1.thinkPad();
        hpComputer.hpComputer();
    }
}

打印结果：

Windows Win7  manageProcess......
Windows Win7 manageFile......
Windows  Win7 manageDevice......
Windows Win7  manageTask......
Windows Win7  manageStorage......
Linux CentOS 7.0  manageProcess......
Linux CentOS 7.0 manageFile......
Linux  CentOS 7.0 manageDevice......
Linux CentOS 7.0  manageTask......
Linux CentOS 7.0  manageStorage......
ThinkPad manangeProcess start....
Linux CentOS 6.8  manageProcess......
ThinkPad manangeProcess end....
HPComputer manageFile start....
Windows Win10 manageFile......
HPComputer manageFile end....

总结：桥接模式将抽象部分和实现部分分离，使得它们都可以独立的变化，桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计与编程。