八戒转世投胎竟然是Java设计模式：桥接模式

示例

请开发一个画图程序，可以画各种颜色不同形状的图形，请用面向对象的思
想设计图形
分析：
1、比如有红、黄、蓝三种颜色
2、形状有方形、圆、三角形
3、圆可以是红圆、黄圆、蓝圆

从上面可以看到，变化的地方有两个：
1、形状
2、颜色
任其在两个维度各自变化，为这两个维度搭个桥，让它们可以融合在一起，就是桥接模式，那么该如何搭呢？
需要从两个地方入手：
1：抽象
分别对各个维度进行抽象，将共同部分抽取出来

2：组合
将抽象组合在一起（桥接）

代码实例

抽象出形状和颜色，对应的类如下：
形状抽象类：持有颜色实例

public abstract class Shape {

    protected Color color;

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

    /** 画图形 */
    abstract void draw();
}
1
2
3
4
5
6
7
8
9
10
11

颜色接口：

public interface Color {

    /** 上色 */
    void coloring();
}
1
2
3
4
5

不同的形状对应的实现类：

public class Circle extends Shape {

    public Circle(Color color) {
        super(color);
    }

    @Override
    public void draw() {
        this.color.coloring();
        System.out.print("圆");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

public class Rect extends Shape {

    public Rect(Color color) {
        super(color);
    }

    @Override
    public void draw() {
        this.color.coloring();
        System.out.print("矩形");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

public class Triangle extends Shape {

    public Triangle(Color color) {
        super(color);
    }

    @Override
    public void draw() {
        this.color.coloring();
        System.out.print("三角形");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

不同的颜色对应的实现类：

public class Red implements Color {
    @Override
    public void coloring() {
        System.out.print("红色-》");
    }
}
1
2
3
4
5
6

public class Yellow implements Color {
    @Override
    public void coloring() {
        System.out.print("黄色-》");
    }
}
1
2
3
4
5
6

public class Blue implements Color {
    @Override
    public void coloring() {
        System.out.print("蓝色-》");
    }
}
1
2
3
4
5
6

测试类：

public class Test {

    public static void main(String[] args) {
        //画一个红色的圆
        Shape redCircle = new Circle(new Red());
        redCircle.draw();
        System.out.println();

        //画一个黄色的矩形
        Shape yellowRect = new Rect(new Yellow());
        yellowRect.draw();
        System.out.println();

        //画一个蓝色的三角形
        Shape blueTriangle = new Triangle(new Blue());
        blueTriangle.draw();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

类图：

桥接模式

定义

将多个维度的变化以抽象的方式组合在一起。使用者面向抽象。各维度间解耦，可自由变化

意图

将抽象部分与实现部分分离，使它们都可以独立的变化

主要解决问题

在有多种可能会变化的情况下，用继承会造成类爆炸问题，扩展起来不灵

何时使用

实现系统可能有多个角度分类，每一种角度都可能变

优缺点

优点：

1. 抽象和实现的分离
2. 优秀的扩展能力
3. 实现细节对客户透明

缺点：
桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计与编程

类图：

涉及的角色：

1. 抽象化（Abstraction）角色：抽象化给出的定义，并保存一个对实现化对象的引用
2. 修正抽象化（RefinedAbstraction）角色：扩展抽象化角色，改变和修正父类对抽象化的定义
3. 实现化（Implementor）角色：这个角色给出实现化角色的接口，但不给出具体的实现
4. 具体实现化（ConcreteImplementor）角色：这个角色给出实现化角色接口的具体实现

对应的源码如下：

public abstract class Abstraction {

    protected Implementor implementor;

    public void operation(){
        implementor.operationImpl();
    }
}
1
2
3
4
5
6
7
8

public class RefinedAbstraction extends Abstraction {

    @Override
    public void operation() {
        super.operation();
    }
}
1
2
3
4
5
6
7

public abstract class Implementor {

    public abstract void operationImpl();
}
1
2
3
4

public class ConcreteImplementor extends Implementor {
    @Override
    public void operationImpl() {
        //do something......
    }
}
1
2
3
4
5
6

八戒转世投胎的故事

《西游记》中天蓬元帅转世成为猪八戒的故事，大家耳熟能详，现在从桥接模式的观点出发，来看一下这个故事：
如果存在灵魂的话，应当是抽象化角色，而肉体则是实现化角色，肉体为灵魂的功能提供了实现

抽象化角色：灵魂

public interface Soul {

    /** 灵魂 */
    void mySoul();
}
1
2
3
4
5

修正抽象化角色：

public class SoulRefined1 implements Soul {

    private Body body;

    public SoulRefined1(Body body) {
        this.body = body;
    }

    @Override
    public void mySoul() {
        System.out.println("天蓬元帅");
        this.body.myBody();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class SoulRefined2 implements Soul {

    private Body body;

    public SoulRefined2(Body body) {
        this.body = body;
    }

    @Override
    public void mySoul() {
        System.out.println("飞禽走兽");
        this.body.myBody();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

实现化角色：肉体

public interface Body {

    /** 肉体 */
    void myBody();
}
1
2
3
4
5

具体实现化角色：

public class ConcreteBody1 implements Body {

    @Override
    public void myBody() {
        System.out.println("转世成人");
    }
}
1
2
3
4
5
6
7

public class ConcreteBody2 implements Body {
    @Override
    public void myBody() {
        System.out.println("转世成猪");
    }
}
1
2
3
4
5
6

测试类：

public class Test {

    public static void main(String[] args) {
        Body body = new ConcreteBody2();
        Soul soul = new SoulRefined1(body);
        soul.mySoul();
    }
}
1
2
3
4
5
6
7
8

类图：