设计模式——适配器模式

适配器模式定义：将一个接口转换为另一个接口，以符合客户的期望

目标接口：Duck

建一个鸭子接口，鸭子具有呱呱叫和飞行的能力。

/**
 * 适配器模式：将一个接口转换为另一个接口，以符合客户的期望
 *
 * @author lingluo
 * @date 2021/12/1 22:16
 */
public interface Duck {
    // 呱呱叫能力
    public void quack();
    // 飞行能力
    public void fly();
}

具体实现类

/**
 * 绿头鸭，可以呱呱叫，可以飞
 *
 * @author lingluo
 * @date 2021/12/1 22:18
 */
public class MallardDuck implements Duck {
    @Override
    public void quack() {
        System.out.println("Quack");
    }

    @Override
    public void fly() {
        System.out.println("I am flying");
    }
}

原始接口：Turkey

建一个火鸡接口，火鸡只会咕咕叫，会飞但飞不远。

/**
 * 火鸡接口
 */
public interface Turkey {
    // 不会呱呱叫，只会咕咕叫
    public void gobble();
    // 会飞，但飞不远
    public void fly();
}

具体实现类

/**
 * @author lingluo
 * @date 2021/12/1 22:22
 */
public class WildTurkey implements Turkey{
    @Override
    public void gobble() {
        System.out.println("Gobble gobble");
    }

    @Override
    public void fly() {
        System.out.println("I am flying a short distance.");
    }
}

建立适配器，将原始接口适配成目标接口

现在，缺鸭子对象，想用一些火鸡对象来冒充，写个适配器，把火鸡对象适配成鸭子。

/**
 * 现在，缺鸭子对象，想用一些火鸡对象来冒充，写个适配器
 *
 * 1.实现需要转换成的期望的接口
 * 2.在构造器里取得适配的对象的引用
 * 3.实现接口的方法
 *
 * @author lingluo
 * @date 2021/12/1 22:23
 */
public class TurkeyAdaptor implements Duck{
    Turkey turkey;

    public TurkeyAdaptor(Turkey turkey) {
        this.turkey = turkey;
    }

    @Override
    public void quack() {
        turkey.gobble();
    }

    @Override
    public void fly() {
        for (int i = 0; i < 5; i++) {
            turkey.fly();
        }
    }
}

测试代码

/**
 * @author lingluo
 * @date 2021/12/1 22:27
 */
public class AdaptorTest {
    public static void main(String[] args) {
        MallardDuck duck = new MallardDuck();

        WildTurkey turkey = new WildTurkey();
        Duck turkeyAdaptor = new TurkeyAdaptor(turkey);

        System.out.println("The turkey says...");
        turkey.gobble();
        turkey.fly();

        System.out.println("\nThe duck says...");
        testDuck(duck);

        System.out.println("\nThe turkeyAdaptor says...");
        testDuck(turkeyAdaptor);
    }

    private static void testDuck(Duck duck) {
        duck.quack();
        duck.fly();
    }
}

运行结果：

另一个例子：将枚举适配到迭代器

/**
 * 将一个枚举类适配成迭代器
 *
 *
 * @author lingluo
 * @date 2021/12/1 22:44
 */
public class EnumerationIterator implements Iterator {
    Enumeration enumeration;
    @Override
    public boolean hasNext() {
        return enumeration.hasMoreElements();
    }

    @Override
    public Object next() {
        return enumeration.nextElement();
    }
}

总结

适配器模式定义：将一个接口转换为另一个接口，以符合客户的期望。

实现适配器模式的步骤:
1.实现需要转换成的期望的接口
2.在适配器的构造器里，取得适配的对象的引用
3.实现接口的方法

与装饰者模式、外观模式的区别

装饰者模式：不改变接口，但加入责任。
适配器模式：将一个接口，转换为另一个接口。
外观模式：让接口更简单。提供一个统一的接口，用来访问子系统的一群接口。外观定义了一个高层接口，让子系统更容易使用。