编程自学指南：java程序设计开发，Java 桥接模式（Bridge），桥接模式的概念和核心思想，桥接模式的结构和各个角色的作用，桥接模式解决实际开发中的多维度变化问题-优快云博客

本文链接：https://blog.youkuaiyun.com/beijing_oracle/article/details/146429808

编程自学指南：java程序设计开发，Java 桥接模式（Bridge）

一、课程信息

学习目标

理解桥接模式的概念和核心思想。
掌握桥接模式的结构和各个角色的作用。
学会使用桥接模式解决实际开发中的多维度变化问题。
能够区分桥接模式与其他相关设计模式的差异。

二、课程导入

生活实例引入

以手机为例，手机有不同的品牌（如苹果、华为、小米），同时还有不同的功能（如拍照、音乐播放、游戏）。如果我们要为每个品牌的手机都实现所有的功能，就会导致类的数量急剧增加，代码变得复杂且难以维护。
提问学生思考如何解决这个问题，引导他们关注将品牌和功能进行分离的思路，从而引出桥接模式。

三、桥接模式的基本概念

定义

桥接模式（Bridge Pattern）是一种结构型设计模式，它将抽象部分与实现部分分离，使它们可以独立地变化。通过桥接模式，我们可以将一个多维度变化的问题拆分成多个独立的维度，每个维度可以独立扩展，从而降低了系统的耦合度。

核心思想

将抽象和实现解耦，让它们可以独立地变化，而不是将它们绑定在一起。

桥接模式的好处

提高系统的可扩展性，抽象和实现可以独立扩展。
降低系统的耦合度，使代码更易于维护和理解。

四、桥接模式的结构和角色

结构

桥接模式主要由以下四个角色组成：

抽象化角色（Abstraction）：定义抽象类，并包含一个对实现化角色的引用。
扩展抽象化角色（Refined Abstraction）：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法。
实现化角色（Implementor）：定义实现化角色的接口，供扩展抽象化角色调用。
具体实现化角色（Concrete Implementor）：给出实现化角色接口的具体实现。

角色关系图

可以使用简单的 UML 图展示四个角色之间的关系，帮助学生理解。

示例代码结构

// 实现化角色接口
interface Implementor {
    void operationImpl();
}

// 具体实现化角色
class ConcreteImplementorA implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("具体实现化角色 A 的操作");
    }
}

class ConcreteImplementorB implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("具体实现化角色 B 的操作");
    }
}

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

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

    public abstract void operation();
}

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

    @Override
    public void operation() {
        System.out.println("扩展抽象化角色的操作");
        implementor.operationImpl();
    }
}

代码解释

Implementor 接口是实现化角色，定义了具体实现的操作方法。
ConcreteImplementorA 和 ConcreteImplementorB 是具体实现化角色，实现了 Implementor 接口。
Abstraction 是抽象化角色，包含一个对 Implementor 的引用，并定义了抽象的操作方法。
RefinedAbstraction 是扩展抽象化角色，继承自 Abstraction，并实现了具体的操作，同时调用了 Implementor 的方法。

五、实际案例分析

案例一：手机与功能的桥接

// 实现化角色：手机功能接口
interface PhoneFunction {
    void performFunction();
}

// 具体实现化角色：拍照功能
class CameraFunction implements PhoneFunction {
    @Override
    public void performFunction() {
        System.out.println("拍照功能");
    }
}

// 具体实现化角色：音乐播放功能
class MusicPlayFunction implements PhoneFunction {
    @Override
    public void performFunction() {
        System.out.println("音乐播放功能");
    }
}

// 抽象化角色：手机品牌
abstract class PhoneBrand {
    protected PhoneFunction phoneFunction;

    public PhoneBrand(PhoneFunction phoneFunction) {
        this.phoneFunction = phoneFunction;
    }

    public abstract void usePhone();
}

// 扩展抽象化角色：苹果手机
class ApplePhone extends PhoneBrand {
    public ApplePhone(PhoneFunction phoneFunction) {
        super(phoneFunction);
    }

    @Override
    public void usePhone() {
        System.out.print("苹果手机使用：");
        phoneFunction.performFunction();
    }
}

// 扩展抽象化角色：华为手机
class HuaweiPhone extends PhoneBrand {
    public HuaweiPhone(PhoneFunction phoneFunction) {
        super(phoneFunction);
    }

    @Override
    public void usePhone() {
        System.out.print("华为手机使用：");
        phoneFunction.performFunction();
    }
}

// 测试代码
public class PhoneBridgeDemo {
    public static void main(String[] args) {
        PhoneFunction cameraFunction = new CameraFunction();
        PhoneFunction musicPlayFunction = new MusicPlayFunction();

        PhoneBrand applePhoneWithCamera = new ApplePhone(cameraFunction);
        applePhoneWithCamera.usePhone();

        PhoneBrand huaweiPhoneWithMusic = new HuaweiPhone(musicPlayFunction);
        huaweiPhoneWithMusic.usePhone();
    }
}

代码解释

PhoneFunction 是实现化角色，定义了手机功能的接口。
CameraFunction 和 MusicPlayFunction 是具体实现化角色，实现了不同的手机功能。
PhoneBrand 是抽象化角色，包含一个对 PhoneFunction 的引用，并定义了使用手机的抽象方法。
ApplePhone 和 HuaweiPhone 是扩展抽象化角色，继承自 PhoneBrand，并实现了具体的使用手机的方法，同时调用了 PhoneFunction 的方法。

案例二：图形与颜色的桥接

// 实现化角色：颜色接口
interface Color {
    void applyColor();
}

// 具体实现化角色：红色
class RedColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("应用红色");
    }
}

// 具体实现化角色：蓝色
class BlueColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("应用蓝色");
    }
}

// 抽象化角色：图形
abstract class Shape {
    protected Color color;

    public Shape(Color color) {
        this.color = color;
    }

    public abstract void draw();
}

// 扩展抽象化角色：圆形
class Circle extends Shape {
    public Circle(Color color) {
        super(color);
    }

    @Override
    public void draw() {
        System.out.print("绘制圆形，");
        color.applyColor();
    }
}

// 扩展抽象化角色：矩形
class Rectangle extends Shape {
    public Rectangle(Color color) {
        super(color);
    }

    @Override
    public void draw() {
        System.out.print("绘制矩形，");
        color.applyColor();
    }
}

// 测试代码
public class ShapeBridgeDemo {
    public static void main(String[] args) {
        Color redColor = new RedColor();
        Color blueColor = new BlueColor();

        Shape redCircle = new Circle(redColor);
        redCircle.draw();

        Shape blueRectangle = new Rectangle(blueColor);
        blueRectangle.draw();
    }
}