Java 设计模式之桥接模式

发表于 更新于 分类于 ，

桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。

简单来说，可以通过桥接模式实现使用相同的抽象方法、不同的桥接实现类获得不同的结果。

猪八戒转世成为猪，孙悟空是转世成为猴子，他们的“灵魂”是同类的，但“肉身”不同。下面用代码来模拟这种关系；

类继承/实现关系简图

具体实现

  1. 创建转世接口

    1
    2
    3
    4
    public interface TurnAPI {
        /**  转世肉体 */
        public String body();
    }

  2. 创建转世接口的实现类

    1
    2
    3
    4
    5
    6
    public class Pig implements TurnAPI {
        @Override
        public String body() {
            return "猪！";
        }
    }
    1
    2
    3
    4
    5
    6
    public class Monkey implements TurnAPI {
        @Override
        public String body() {
            return "猴子！";
        }
    }

  3. 创建抽象灵魂类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public abstract class Soul {
        /** 将TurnAPI作为属性注入Soul，这是实现桥接的关键 */
        protected TurnAPI turnAPI;
        private String name;

        public Soul(String name, TurnAPI turnAPI) {
            this.name = name;
            this.turnAPI=turnAPI;
        }

        public String getName() {
            return name;
        }
        public abstract String body();

        public abstract String type();
    }

  4. 创建抽象灵魂类的子类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public class God extends Soul{
        public God(String name, TurnAPI turnAPI) {
            super(name, turnAPI);
        }

        @Override
        public String body() {
            return turnAPI.body();
        }

        @Override
        public String type() {
            return "神";
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public class Monster extends Soul{
        public Monster(String name, TurnAPI turnAPI) {
            super(name, turnAPI);
        }

        @Override
        public String body() {
            return turnAPI.body();
        }

        @Override
        public String type() {
            return "妖";
        }
    }

  5. 创建测试类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class Test {
        public static void main(String[] args) {
            Soul tianPeng = new God("猪八戒", new Pig());
            Soul monkeyKing = new God("孙悟空", new Monkey());
            Soul sixEar = new Monster("六耳猕猴", new Monkey());
            System.out.println("灵魂：" + tianPeng.getName() + "，肉身：" + tianPeng.body()+"，属性："+tianPeng.type());
            System.out.println("灵魂：" + monkeyKing.getName() + "，肉身：" + monkeyKing.body()+"，属性："+monkeyKing.type());
            System.out.println("灵魂：" + sixEar.getName() + "，肉身：" + sixEar.body()+"，属性："+sixEar.type());
        }
    }

    执行结果

小结

通过上面代码，实现了将猪八戒的灵魂放进了猪的肉体内，将孙悟空的灵魂放进了猴子的肉体内；灵魂的具体类也有妖和神的区别，上面也实现了将六耳猕猴的灵魂放进猴子肉体中，当然也可以放进猪内；

由上可知，桥接模式适用于两个独立变化的维度之间。通过桥接模式，我们可以将不同的实现类和不同的接口实现进行连接。使用桥接模式避免了抽象类实现接口，抽象与实现分离；由于桥接模式是在抽象层面建立关联关系，这也加大了系统的设计与理解难度。