设计模式中, 桥接模式（Bridge Pattern）的原理理解，和示例说明。一文详解释！

桥接模式（Bridge Pattern）完整示例

如下片段是桥接模式（Bridge Pattern）的经典案例：把“品牌”维度和“发动机”维度解耦开来，用组合代替继承，避免子类爆炸。

使用传统继承方式

使用桥接设计模式后

我来把这段代码补全，并用通俗的语言解释。

桥接模式完整代码

// 定义Engine接口（引擎抽象层）
public interface Engine {
    void start();
}

// 几种具体引擎实现：
public class FuelEngine implements Engine {
    public void start() {
        System.out.println("Start Fuel Engine...");
    }
}

public class ElectricEngine implements Engine {
    public void start() {
        System.out.println("Start Electric Engine...");
    }
}

public class HybridEngine implements Engine {
    public void start() {
        System.out.println("Start Hybrid Engine...");
    }
}

// Car抽象类，持有一个Engine引用（桥接关键）
public abstract class Car {
    protected Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public abstract void drive();
}

// RefinedCar定义了一些通用行为
public abstract class RefinedCar extends Car {
    public RefinedCar(Engine engine) {
        super(engine);
    }

    @Override
    public void drive() {
        engine.start();
        System.out.println("Drive " + getBrand() + " car...");
    }

    public abstract String getBrand();
}

// 具体品牌
public class BigCar extends RefinedCar {
    public BigCar(Engine engine) {
        super(engine);
    }

    public String getBrand() {
        return "Big";
    }
}

public class TinyCar extends RefinedCar {
    public TinyCar(Engine engine) {
        super(engine);
    }

    public String getBrand() {
        return "Tiny";
    }
}

public class BossCar extends RefinedCar {
    public BossCar(Engine engine) {
        super(engine);
    }

    public String getBrand() {
        return "Boss";
    }
}

// 测试客户端
public class Main {
    public static void main(String[] args) {
        RefinedCar car1 = new BigCar(new FuelEngine());
        car1.drive();

        RefinedCar car2 = new TinyCar(new ElectricEngine());
        car2.drive();

        RefinedCar car3 = new BossCar(new HybridEngine());
        car3.drive();
    }
}

运行结果

Start Fuel Engine...
Drive Big car...
Start Electric Engine...
Drive Tiny car...
Start Hybrid Engine...
Drive Boss car...

通俗解释

传统继承方式的问题

• 3 个品牌 × 3 种引擎 = 9 个子类。
• 如果再多一个品牌或多一种引擎，子类数目会指数级膨胀。

桥接模式的做法

• Car 抽象类只负责“车”的通用逻辑，但不管引擎。
• Engine 接口负责定义“引擎”的行为，不管车是什么品牌。
• 最终通过组合：Car 桥接 一个 Engine。
• 品牌和引擎可以独立扩展，互不影响。

效果

• 想新增品牌？继承 RefinedCar。
• 想新增引擎？实现 Engine 接口。
• 两个维度解耦，随意组合，不会爆炸。

👉 一句话总结：桥接模式就是把“品牌”和“引擎”分开建模，再用组合把它们“桥接”起来。