设计模式系列：搞懂桥接模式，轻松应对类的多维度变化

桥接模式的定义：将抽象与实现分离，使它们可以独立变化。用组合关系代替继承关系，降低抽象和实现的耦合度。属于结构型模式。

桥接模式的主要目的是通过组合的方式建立两个类之间的关系，解耦抽象和实现类。

桥接模式的结构：桥接模式包含4个主要角色。

1. 抽象（Abstraction）角色：定义抽象类，并包含一个对实现角色的引用。
2. 扩展抽象（Refined Abstraction）角色：抽象角色的实现，实现抽象角色的方法，并通过组合关系调用实现角色中的业务方法进行扩展。
3. 实现（Implementor）角色：定义实现角色的接口，供扩展抽象角色调用。
4. 具体实现（Concrete Implementor）角色：实现角色接口的具体实现。

桥接模式的通用实现：

//实现角色
public interface Implementor {
    void doSomeThing();
}

//具体实现角色
public class ConcreteImplementor implements Implementor{
    @Override
    public void doSomeThing() {
        System.out.println("具体实现角色要做事了");
    }
}

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

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

    abstract void operation();
}

//扩展抽象角色
public class RefinedAbstraction extends Abstraction{
    public RefinedAbstraction(Implementor implementor) {
        super(implementor);
    }

    public void operation() {
        implementor.doSomeThing();
        System.out.println("扩展抽象角色扩展实现角色的方法");

    }
}

//测试类
public class BridgeTest {
    public static void main(String[] args) {
        Implementor implementor = new ConcreteImplementor();
        Abstraction abstraction = new RefinedAbstraction(implementor);
        abstraction.operation();
    }
}

桥接模式的结构图：

桥接模式的应用实例：用桥接模式模拟公司发放奖金。公司分为财务部、销售部、研发部，奖金类型有个人奖、团队奖。奖金类是一个维度，定义了实现角色；部门类为另一个维度，定义了抽象角色。

//实现角色
public interface Money {
    //奖金类型
    String getMoneyType();
    //金额
    Double getMoneyAmount();
}

//具体实现角色：个人奖
public class PersonMoney implements Money{
    @Override
    public String getMoneyType() {
        return "个人奖";
    }

    @Override
    public Double getMoneyAmount() {
        return 10000.00;
    }
}

//具体实现角色：团队奖
public class TeamMoney implements Money{
    @Override
    public String getMoneyType() {
        return "团队奖";
    }

    @Override
    public Double getMoneyAmount() {
        return 500000.00;
    }
}

//抽象角色
public abstract class Department {
    protected Money money;

    public Department(Money money){
        this.money = money;
    }

    //部门获奖情况
    public abstract String situation();
}

//扩展抽象角色：研发部
public class Development extends Department{
    public Development(Money money) {
        super(money);
    }

    @Override
    public String situation() {
        return "研发部奖金类型："+money.getMoneyType()+",金额："+money.getMoneyAmount();
    }
}

//扩展抽象角色：销售部
public class Sales extends Department{
    public Sales(Money money) {
        super(money);
    }

    @Override
    public String situation() {
        return "销售部奖金类型："+money.getMoneyType()+",金额："+money.getMoneyAmount();
    }
}

//测试类
public class MoneyTest {
    public static void main(String[] args) {
        Money money = new PersonMoney();
        Department department = new Sales(money);
        System.out.println(department.situation());

        money = new TeamMoney();
        department = new Development(money);
        System.out.println(department.situation());
    }
}

模拟公司发放奖金实例的结构图：

桥接模式的优点：

• 抽象与实现分离，扩展能力强。
• 符合开闭原则。
• 符合合成复用原则。

桥接模式的缺点：

• 需要正确地识别系统中两个独立变化的维度。
• 增加了系统的理解与设计难度。

桥接模式的应用场景：当一个类内部具备两种或两种以上变化维度时，使用桥接模式可以解耦这些变化的维度，使高层代码架构稳定。

1. 一个类存在多个独立变化的维度，且这些维度都需要进行扩展。
2. 不希望使用继承或因为多层次继承导致系统类的个数急剧增加。
3. 需要在构件的抽象角色和具体角色之间增加更多的灵活性。

桥接模式的一个常见使用场景就是替换继承。