【结构型模式】适配器模式

前言（一些废话，可以忽略）

• 4种创建型模式就已经梳理完了，总的来说还是很简单，只要把握住核心思想，代码这种具象的东西都不会跑偏
• 今天来聊一聊第一种，比较简单的结构型设计模式，适配器模式
• PS.部分类实现见文末

要解决的问题

• 适配器模式顾名思义，就是要将一个类与另外一个类连接起来，但是他们的接口关系不匹配，不能直接连接，所以我们只能使用某种结构方式，来讲一个接口转为另外一个接口可以调用的形式
• 当然用更简单的话说，就是起一个转接头的作用，像充电器一样，将220V的电压转为5V
• 这里我们使用泰国标准和中国标准的插座来进行举例

基于类的适配器模式

• 既然是基于类的，那么被适配、被转换的对象就是需要们继承的一个类

/**
 * @program: ade-someproblem
 * @author: cade franklin
 * @create: 2019-12-26 26:21
 **/
public class ThailandStandard {

    public void charge(){
        System.out.println("给手机充电");
    }
}

• 我们要使用的是中国标准，通过一个指定中国标准的接口

/**
 * @program: ade-someproblem
 * @author: cade franklin
 * @create: 2019-12-26 26:21
 **/
public interface ChinaStandard {
    void charge();
}

• 不能直接使用泰国标准，所以需要将其转换为中国标准

/**
 * @program: ade-someproblem
 * @author: cade franklin
 * @create: 2019-12-26 26:21
 **/
public class ClassAdapter extends ThailandStandard implements ChinaStandard {
}

• 基本结构就已经完成了，接下来再看一下如何使用
• 通过创建一个适配器对象，就可以获得一个兼容中国标准的子类，但是当你实际调用时，使用的却是泰国的插座，这就达到了我们的效果

/**
 * 类对象适配器
 * @program: ade-someproblem
 * @author: cade franklin
 * @create: 2019-12-26 26:21
 **/
public class ClassMode {
    public static void main(String[] args) {
        ChinaStandard chager = new ClassAdapter();
        chager.charge();
    }
}

• 基于类的适配器模式，通过继承来实现转换，而我们知道，继承这东西不具有灵活性，且有较强的依赖性，是不推荐使用的，那么我们有没有什么更好的方式呢

基于对象的适配器模式

• 基于对象的适配器，不再采用继承的方式，而是通过聚合的方式，这样就适当降低了依赖，更加的灵活
• 聚合的是被转换类的对象，所以称为基于对象的适配器模式

/**
 * 对象适配器
 * @program: ade-someproblem
 * @author: cade franklin
 * @create: 2019-12-26 26:21
 **/
public class ObjectAdapter implements ChinaStandard {
    private ThailandStandard thailandStandard;
   
    public ObjectAdapter(ThailandStandard thailandStandard) {
        this.thailandStandard = thailandStandard;
    }

    @Override
    public void charge() {
        thailandStandard.charge();
    }
}

• 其他的相关类无需变动，当然这里也可以用组合的方式

基于接口的适配器模式

• 最后一种适配器模式的方式为基于接口，将被适配的类通过实现接口，将需要的转接写在抽象类中
• 下面为我们要实现的类

/**
 * @program: ade-someproblem
 * @author: cade franklin
 * @create: 2019-12-26 26:21
 **/
public interface ThailandStandard {
    void charge();

    void quickCharge();
}

• 我们的适配器去实现被适配的接口

/**
 * 接口适配器
 *
 * @program: ade-someproblem
 * @author: cade franklin
 * @create: 2019-12-26 26:21
 **/
public abstract class InterfaceAdapter implements ThailandStandard {
    @Override
    public void charge() {
        System.out.println("InterfaceAdapter.charge");
    }

    @Override
    public void quickCharge() {
        throw new UnsupportedOperationException();
    }
}

• 转接为中国的标准后，可以加上自己的相关实现方法，比如说降压之类的

/**
 * @program: ade-someproblem
 * @author: cade franklin
 * @create: 2019-12-26 26:21
 **/
public class ChinaStandard extends InterfaceAdapter{
}

• 这就是使用过程

/**
 * 接口适配器
 * @program: ade-someproblem
 * @author: cade franklin
 * @create: 2019-12-26 26:21
 **/
public class InterfaceMode {
    public static void main(String[] args) {
        ChinaStandard standard = new ChinaStandard();
        standard.charge();
    }
}

总结

• 适配器模式大概就是这三种了，主要根据已经存在的类进行选择使用哪一种模式
• 这个模式的核心就是将一个我们要使用的类通过继承、实现 、聚合组合，转为我们另外一个我们可以直接调用的类， bingo！

愿你不舍爱与自由。