适配器模式

什么是适配器模式

适配器模式将一个类的接口，转换成客户期望的另一个接口，适配器让原本接口不兼容的类可以合作无闻

对象适配器和类适配器

对象适配器和类适配器使用两种不同的适配方法（分别是组合与继承），类适配器是多继承的，所以不能在java中使用

代码实现

鸭子接口

1
2
3
4
5
6
7
/**
 * 鸭子接口
 */
public interface Duck {
    public void quack();
    public void fly();
}

绿头鸭

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * 绿头鸭
 */
public class MallardDuck implements Duck {
    @Override
    public void quack() {
        System.out.println("quack,叫叫叫");
    }
    @Override
    public void fly() {
        System.out.println("fly,飞飞飞");
    }
}

火鸡接口

1
2
3
4
5
6
7
/**
 * 街头禽兽
 */
public interface Turkey {
    public void gobble();//火鸡不会呱呱叫，但会咯咯叫
    public void fly();//火鸡会飞，但飞不远
}

火鸡

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * 火鸡
 */
public class WildTurkey implements Turkey {
    @Override
    public void gobble() {
        System.out.println("Gobble gobble,咯咯叫");
    }
    @Override
    public void fly() {
        System.out.println("I'm flying a short distance,我飞的不远");
    }
}

火鸡适配器，让火鸡冒充鸭子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * 火鸡适配器
 */
public class TurkeyAdapter implements Duck {
    Turkey turkey;
    public TurkeyAdapter(Turkey turkey){
        this.turkey = turkey;
    }
    @Override
    public void quack() {
        turkey.gobble();
    }
    @Override
    public void fly() {
        for(int i = 0; i < 5; i++){
            turkey.fly();
        }
    }
}

测试类

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
/**
 * 测试类
 */
public class DuckTestDrive {
    public static void main(String[] args){
        MallardDuck mallardDuck = new MallardDuck();//创建一只鸭子
        WildTurkey wildTurkey = new WildTurkey();//创建一只火鸡
        Duck trukeyAdapter = new TurkeyAdapter(wildTurkey);//将火鸡包装到火鸡适配器中，使它看起来像是一只鸭子
        System.out.println("The turkey says....");
        wildTurkey.gobble();
        wildTurkey.fly();
        System.out.println("\nThe Duck says...");
        mallardDuck.quack();
        mallardDuck.fly();
        System.out.println("\nThe TurkeyAdapter says....");
        testDuck(trukeyAdapter);
    }
    static void testDuck(Duck duck){
        duck.quack();
        duck.fly();
    }
}

输出结果
Gobble gobble,咯咯叫
I’m flying a short distance,我飞的不远

The Duck says…
quack,叫叫叫
fly,飞飞飞

The TurkeyAdapter says….
Gobble gobble,咯咯叫
I’m flying a short distance,我飞的不远
I’m flying a short distance,我飞的不远
I’m flying a short distance,我飞的不远
I’m flying a short distance,我飞的不远
I’m flying a short distance,我飞的不远

总结

1.客户通过目标接口调用适配器的方法对适配器发出请求
2.适配器使用被适配者接口把请求转换成被适配者的一个或多个接口
3.客户接收到调用的结果，但并未觉察这一切是适配器在起转换作用
4.适配器模式可以通过创建适配器进行接口转换，让不兼容的接口变成兼容，这可以让客户从实现的接口解耦。一段时间后如果我们想要改变接口，适配器可以将改变的部分封装起来，客户就不必为了应对不同的接口而每次进行修改