大话设计模式——桥接模式

紧耦合的程序

/**
 * 手机游戏类
 */
public abstract class HandsetGame {
    public abstract void run();
}

/**
 * M品牌手机中的游戏
 */
public class HandsetMGame extends HandsetGame {
    public void run() {
        System.out.println("运行M品牌手机游戏");
    }
}

/**
 * N品牌手机中的游戏
 */
public class HandsetNGame extends HandsetGame {
    public void run() {
        System.out.println("运行N品牌手机游戏");
    }
}

客户端

/**
 * 现在有一个N品牌的手机，有一个小游戏
 */
public class Client {
    public static void main(String[] args) {
        HandsetNGame handsetNGame = new HandsetNGame();
        handsetNGame.run();
    }
}

增加通讯录功能

手机品牌

/**
 * 手机品牌
 */
public abstract class HandsetBrand {
    public abstract void run();
}

/**
 * 手机品牌M
 */
public class HandsetBrandM extends HandsetBrand {
    public void run() {
        
    }
}

/**
 * 手机品牌N
 */
public class HandsetBrandN extends HandsetBrand {
    public void run() {
        
    }
}

通讯录

/**
 * 手机品牌M的通讯录
 */
public class HandsetBrandMAddressList extends HandsetBrandM {
    @Override
    public void run() {
        System.out.println("运行M品牌手机通讯录");
    }
}

/**
 * 手机品牌N的通讯录
 */
public class HandsetBrandNAddressList extends HandsetBrandN {
    @Override
    public void run() {
        System.out.println("运行N品牌手机通讯录");
    }
}

游戏

/**
 * 手机品牌M的游戏
 */
public class HandsetBrandMGame extends HandsetBrandM {
    @Override
    public void run() {
        System.out.println("运行M品牌手机游戏");
    }
}

/**
 * 手机品牌N的游戏
 */
public class HandsetBrandNGame extends HandsetBrandN {
    @Override
    public void run() {
        System.out.println("运行N品牌手机游戏");
    }
}

客户端

public class Client {
    public static void main(String[] args) {
        HandsetBrand ab;
        ab = new HandsetBrandMAddressList();
        ab.run();

        ab = new HandsetBrandMGame();
        ab.run();

        ab = new HandsetBrandNAddressList();
        ab.run();

        ab = new HandsetBrandNGame();
        ab.run();
    }
}

如果增加MP3播放器呢？

对象的继承关系是在编译时就定义好了，所以无法在运行时改变从父类继承的实现。
子类的实现与它的父类有非常紧密的依赖关系，以至于父类实现中的任何变化必然会导致子类发生变化。
当你需要复用子类时，如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更合适的类替换。
这种依赖关系限制了灵活性并最终限制了复用性。

松耦合的程序

手机品牌

手机品牌和手机软件是什么关系呢？手机品牌包含手机软件，但软件并不是品牌的一部分。

/**
 * 手机品牌
 */
public abstract class HandsetBrand {
    protected HandsetSoft soft;
    /**
     * 品牌需要关注软件，所以可在机器中安装软件（设置手机软件），以备运行
     */
    // 设置手机软件
    public void setHandsetSoft(HandsetSoft soft) {
        this.soft = soft;
    }
    // 运行
    public abstract void run();
}

/**
 * 手机品牌M
 */
public class HandsetBrandM extends HandsetBrand {
    @Override
    public void run() {
        soft.run();
    }
}

/**
 * 手机品牌N
 */
public class HandsetBrandN extends HandsetBrand {
    @Override
    public void run() {
        soft.run();
    }
}

/**
 * 手机品牌S
 */
public class HandsetBrandS extends HandsetBrand {
    @Override
    public void run() {
        soft.run();
    }
}

手机软件

/**
 * 手机软件
 */
public abstract class HandsetSoft {
    public abstract void run();
}

public class HandsetMP3 extends HandsetSoft {
    @Override
    public void run() {
        System.out.println("运行手机MP3播放");
    }
}

public class HandsetGame extends HandsetSoft {
    @Override
    public void run() {
        System.out.println("运行手机游戏");
    }
}

客户端

public class Client {
    public static void main(String[] args) {
        HandsetBrand ab;
        ab = new HandsetBrandN();
        // 将具体的软件合成到品牌中，作为品牌的成员变量，品牌中用软件父类接收
        ab.setHandsetSoft(new HandsetGame());
        ab.run();

        ab.setHandsetSoft(new HandsetAddressList());
        ab.run();

        ab = new HandsetBrandM();
        
        ab.setHandsetSoft(new HandsetGame());
        ab.run();
        
        ab.setHandsetSoft(new HandsetAddressList());
        ab.run();
    }
}

桥接模式

桥接模式，将抽象部分与它的实现部分分离，使它们都可以独立地变化。

抽象与它的实现分离，并不是说，让抽象类与其派生类分离，因为这没有任何意义。实现指的是抽象类和它的派生类用来实现自己的对象。例如：让“手机”既可以按照品牌来分类，也可以按照功能来分类。

桥接模式的核心意图就是将这些实现独立出来，让它们各自地变化。这就使得每种实现的变化不会影响其他实现，从而达到应对变化的目的。

Implementor

/**
 * Implementor类：实现
 */
public abstract class Implementor {
    public abstract void operation();
}

public class ConcreteImplementorA extends Implementor {
    public void operation() {
        System.out.println("具体实现A的方法执行");
    }
}

public class ConcreteImplementorB extends Implementor {
    public void operation() {
        System.out.println("具体实现B的方法执行");
    }
}

Abstraction

public class Abstraction {
    protected Implementor implementor;

    public void setImplementor(Implementor implementor) {
        this.implementor = implementor;
    }
    
    public void operation() {
        implementor.operation();
    }
    
}

public class RefinedAbstraction extends Abstraction {

    public void operation() {
        implementor.operation();
    }
    
}

客户端

public class Client {
    public static void main(String[] args) {
        Abstraction ab = new RefinedAbstraction();
        ab.setImplementor(new ConcreteImplementorA());
        ab.operation();

        ab.setImplementor(new ConcreteImplementorB());
        ab.operation();
    }
}

实现系统可能有多角度分类，每一种分类都有可能变化，那么就把这种多角度分离出来让它们独立变化，减少它们之间的耦合。

只要深入理解了设计原则，很多设计模式其实就是原则的应用而已，或许在不知不觉中就在使用设计模式了。

注：本文内容源自程杰的《大话设计模式》