场景介绍：（1）假设我们做了一个第一版的一个系统，这个系统里有一个接口和一个实现类（2）接着我们开始做第二版的系统，这个系统我们定义了一个新的接口，和新的实现类（3）但是我们同时在第二版的系统中，也要使用第一版系统中定义的那个老接口和老实现类

1.常规

package com.example.demo.pattern.adapter;
/**
 * @author chenchao
 * @date 2021/11/8
 */
public class WithoutAdapterPatternDemo {
    public static void main(String[] args) {
        OldInterface oldObject = new OldInterfaceImpl();
        NewInterface newObject = new NewInterfaceImpl();
        oldObject.oldExecute();
        newObject.newExecute();
        // 如果不用任何设计模式，我们的问题在哪儿？
        // 问题其实很明显，就是说，我们的新的代码中，融合了新老两套接口，很麻烦的一个事情
        // 首先如果你这么干的话，就会导致代码很恶心，面向的是规范和风格完全不同的两套接口，你理解和维护的成本提高了
        // 其次，假如说，现在都不给你选择使用老版本接口的机会
        // 直接强制性公司规范要求按照新版本接口来走，你的老版本接口的实现类，就没法用了啊？
        // 难不成还要基于新版本的接口重新写一套？
    }
    /**
     * 老版本接口
     * @author chenchao
     *
     */
    public static interface OldInterface {
        void oldExecute();
    }
    /**
     * 老版本接口的实现类
     * @author chenchao
     *
     */
    public static class OldInterfaceImpl implements OldInterface {
        @Override
        public void oldExecute() {
            System.out.println("老版本接口实现的功能逻辑");  
        }
    }
    /**
     * 新版本接口
     * @author chenchao
     *
     */
    public static interface NewInterface {
        void newExecute();
    }
    /**
     * 新版本接口的实现类
     * @author chenchao
     *
     */
    public static class NewInterfaceImpl implements NewInterface {
        @Override
        public void newExecute() {
            System.out.println("新版本接口实现的功能逻辑");  
        }
    }
}

2.适配器模式

package com.example.demo.pattern.adapter;
/**
 * @author chenchao
 * @date 2021/11/8
 */
public class AdapterPatterDemo {
    public static void main(String[] args) {
        NewInterface oldObject = new NewInterfaceAdapter(new OldInterfaceImpl());
        NewInterface newObject = new NewInterfaceImpl();
        oldObject.newExecute();
        newObject.newExecute();
        // 适配器模式
        // 就是你手上有新老俩接口和一个老接口的实现类
        // 但是现在系统中要面向新接口来开发，老接口的实现类就不能直接用了，不能直接面向老接口来开发
        // 开发一个老接口到新接口的一个适配器
        // 适配器是实现了新接口的，但是适配器中持有老接口实现类实例的引用
        // 适配器的新接口方法的实现，全部基于老接口实现类的老方法来实现即可
        // 对于调用方而言，只要使用适配器来开发即可，就可以通过面向新接口开发，底层使用老接口实现类
    }
    /**
     * 老版本接口
     *
     * @author chenchao
     */
    public static interface OldInterface {
        void oldExecute();
    }
    /**
     * 新版本接口
     *
     * @author chenchao
     */
    public  interface NewInterface {
        void newExecute();
    }
    /**
     * 定义一个适配器类
     *
     * @author chenchao
     */
    public static class NewInterfaceAdapter implements NewInterface {
        private OldInterface oldObject;
        public NewInterfaceAdapter(OldInterface oldObject) {
            this.oldObject = oldObject;
        }
        @Override
        public void newExecute() {
            oldObject.oldExecute();
        }
    }
    /**
     * 老版本接口的实现类
     *
     * @author chenchao
     */
    public static class OldInterfaceImpl implements OldInterface {
        @Override
        public void oldExecute() {
            System.out.println("老版本接口实现的功能逻辑");
        }
    }
    /**
     * 新版本接口的实现类
     *
     * @author chenchao
     */
    public static class NewInterfaceImpl implements NewInterface {
        @Override
        public void newExecute() {
            System.out.println("新版本接口实现的功能逻辑");
        }
    }
}

3.好处

这个模式一般是在系统不断升级的过程中使用，对已经写好的老的类，写一套适配器来适配老类，但是提供新的接口，这个我们在后面系统升级的时候，可以去实践。在项目阶段二的时候，会去实践的，真的有版本升级的时候，才可以完美的去演示这个模式的使用效果。

还有一种情况，是对于已有的第三方类库，比如redis的客户端，或者是elasticsearch的客户端，他们提供了一套API，但是我们这里的要求是需要面向我们这里的DAO接口来进行编程，此时可以写一个适配器，将比如redis客户端的接口适配到我们的接口，这个我们会在本次课程来实践。

比如我们的DAO接口，要求的接口风格都是：save、update、remove、list、get，这些方法风格

DAORedisImpl，redis客户端，get、set、mset、mget，一套接口；适配器，DAORedisImpl就是一个适配器，这个适配器实现的是我们的DAO接口，在我们的save、update、remove等方法中，去调用redis客户端的get、set、mset、mget等方法。

03 筑基_设计模式

02 适配器模式：适配老版本接口和第三方接口

1.常规

2.适配器模式

3.好处