桥接模式（BridgePattern）

场景

存在两个兵工厂，用来生产M4A1和AK47

将两个兵工厂与具体的步枪分开，通过聚合来实现相关联。

实现

兵工厂相关类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public abstract class AbstractArsenal {
    private AbstractRifle abstractRifle;

    public AbstractArsenal(AbstractRifle abstractRifle) {
        this.abstractRifle = abstractRifle;
    }

    // 这可用抽象方法，根据情况选择
    public void operationRifle() {
        this.abstractRifle.reloading();
        this.abstractRifle.fire();
    }
}

public class RussiaArsenal extends AbstractArsenal {

    public RussiaArsenal(AbstractRifle abstractRifle) {
        super(abstractRifle);
    }

    @Override
    public void operationRifle() {
        System.out.println("RussiaArsenal!!!");
        super.operationRifle();
    }
}

public class USAArsenal extends AbstractArsenal {
    public USAArsenal(AbstractRifle abstractRifle) {
        super(abstractRifle);
    }

    @Override
    public void operationRifle() {
        System.out.println("USAArsenal!!!");
        super.operationRifle();
    }
}

具体步枪类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public abstract class AbstractRifle {
    /**
     * 射击
     */
    protected abstract void fire();

    /**
     * 装弹中
     */
    protected abstract void reloading();
}

public class M4A1 extends AbstractRifle {
    @Override
    protected void fire() {
        System.out.println("M4A1射击，哒哒哒哒");
    }

    @Override
    protected void reloading() {
        System.out.println("M4A1装弹中......");
    }
}

public class Ak47 extends AbstractRifle {
    @Override
    protected void fire() {
        System.out.println("Ak47射击，乌拉乌拉");
    }

    @Override
    protected void reloading() {
        System.out.println("AK47装弹中......");
    }
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Test {
    public static void main(String[] args) {
        RussiaArsenal russiaArsenal1 = new RussiaArsenal(new Ak47());
        russiaArsenal1.operationRifle();
        
        RussiaArsenal russiaArsenal2 = new RussiaArsenal(new M4A1());
        russiaArsenal2.operationRifle();
        
        USAArsenal usaArsenal1 = new USAArsenal(new Ak47());
        usaArsenal1.operationRifle();
        
        USAArsenal usaArsenal2 = new USAArsenal(new M4A1());
        usaArsenal2.operationRifle();
    }
}

RussiaArsenal!!!
AK47装弹中……
Ak47射击，乌拉乌拉

RussiaArsenal!!!
M4A1装弹中……
M4A1射击，哒哒哒哒

USAArsenal!!!
AK47装弹中……
Ak47射击，乌拉乌拉

USAArsenal!!!
M4A1装弹中……
M4A1射击，哒哒哒哒

个人理解

桥接这个模式就是将抽象与实现解耦，使这两者可以独立的变化，就像上面的例子中，增加一个M16步枪类，扩展非常简单，或者增加一个中国兵工厂，并不影响具体的步枪类。这个模式也从一方面解决了用继承的话会产生类爆炸的问题，俄罗斯M4A1、俄罗斯AK47、美国M4A1、美国AK47等等，这样的话类就特别多，每次扩展也非常不方便。

突然感觉这个和抽象工厂解决工厂方法类爆炸问题好像(#>д<)ﾉ！