桥接模式

定义

将抽象和实现解耦，使得两者可以独立变化。
有点抽象，大家先继续往下看吧。

通用类图

通用类图.png

类说明

1. Implementor 实现化角色
   是一个接口或者抽象类，定义角色的属性和行为

2. ConcrecteImplement 具体实现化角色
   实现相应的行为

3. Abstraction 抽象化角色
   定义出该角色的行为，同时保存一个实现化角色的引用

4. RefinedAbstracton
   实现抽象化角色，利用实现化角色引用修正父类的行为

通用代码

// 定义实现化角色
public interface Implementor {
    void doSomething();
    void doAnything();
}

// 具体实现化
public class ConcreteImplementor implements Implementor {
    @Override
    public void doSomething() {
        // 业务逻辑
    }

    @Override
    public void doAnything() {
        // 业务逻辑
    }
}

// 抽象角色
public class Abstraction {
    private Implementor implementor;

    public Abstraction(Implementor implementor) {
        this.implementor = implementor;
    }

    // 自身的行为属性
    public void request() {
        this.implementor.doSomething();
    }

    public Implementor getImplementor() {
        return this.implementor;
    }
}

// 具体抽象
public class RefinedAbstraction extends Abstraction {

    public RefinedAbstraction(Implementor implementor) {
        super(implementor);
    }

    // 修正父类行为
    @Override
    public void request() {
        // 业务处理
        super.request();
        getImplementor().doAnything();
    }
}

// 客户端
public class Client {

    public static void main(String[] args) {
        Implementor imp = new ConcreteImplementor();
        Abstraction abstraction = new RefinedAbstraction(imp);
        abstraction.request();
    }
}

样例展示

一个咖啡店可以提供大杯(JorumCoffee)、中杯(MediumCoffee)、小杯(SmallCoffee)的咖啡(Coffee)，为了满足不同用户的口味，在咖啡中可以添加牛奶(Milk)，或者糖(Sugar)，或者柠檬(Lemon)，提供给用户不同口味的组合，如大杯咖啡加牛奶，中杯咖啡加糖，小杯咖啡加柠檬，小杯咖啡加糖等。

样例类图

样例类图.png

由类图可以很容易看出整个框架，回到最开始的定义：将抽象和现实解耦，使得两者可以独立变化。这里的抽象就是Coffee，而实现就是Flavor。如果按照正常的写法，在Coffee类中创建三种口味的方法，然后创建三个大、中、小杯咖啡，这样一来三个子类都得实现三种口味方法，也许大杯咖啡没有柠檬味的怎么办呢？所以，利用桥接模式来解决这多种组合问题，要是再来一种口味也很简单，实现Flavor接口就可以了。用户只需要创建相应的口味添加到咖啡中即可，降低了咖啡对口味的耦合度。

代码实现

// 佐料类
public interface Flavor {
    void taste(); // 口味
}

// 具体实现
public class Milk implements Flavor {
    @Override
    public void taste() {
        System.out.println("牛奶味的");
    }
}

public class Lemon implements Flavor {
    @Override
    public void taste() {
        System.out.println("柠檬味的");
    }
}

public class Sugar implements Flavor {
    @Override
    public void taste() {
        System.out.println("糖味，甜甜的");
    }
}

// 咖啡
public abstract class Coffee {
    private Flavor flavor;

    public Coffee(Flavor flavor) {
        this.flavor = flavor;
    }

    public void add() {
        flavor.taste();
    }
}

// 大、中、小杯
public class BigCup extends Coffee {

    public BigCup(Flavor flavor) {
        super(flavor);
    }

    @Override
    public void add() {
        System.out.println("这是大杯咖啡");
        super.add();
    }
}

public class MiddleCup extends Coffee {

    public MiddleCup(Flavor flavor) {
        super(flavor);
    }

    @Override
    public void add() {
        System.out.println("这是中杯咖啡");
        super.add();
    }
}

public class SmallCup extends Coffee {

    public SmallCup(Flavor flavor) {
        super(flavor);
    }

    @Override
    public void add() {
        System.out.println("这是小杯咖啡");
        super.add();
    }
}

// 客户端调用
public class Client {

    public static void main(String[] args) {
        Flavor milk = new Milk();
        Coffee big = new BigCup(milk);
        big.add();

        Flavor lemon = new Lemon();
        Coffee small = new SmallCup(lemon);
        small.add();
    }
}

本文为《设计模式之禅》读后笔记总结