适配器模式就是把一个类或接口转换成其他的接口或类

类图如下

适配器模式类图

适配器模式分成两种一种是类适配，通过继承的方式，一种是对象适配，通过组合的方式

类适配

假设我们现在有自己的一个运行系统，由用户信息接口

public interface UserInfo {
    String getName();
    String getAge();

    String getAddress();

    String getIDNumber();
}

实现类

public class StaffIn implements UserInfo{

    @Override
    public String getName() {
        return "张三";
    }

    @Override
    public String getAge() {
        return "16";
    }

    @Override
    public String getAddress() {
        return "北京市";
    }

    @Override
    public String getIDNumber() {
        return "10000";
    }
}

现在需要跟另一个系统对接，他们的用户类定义跟我们的完全不同
用户接口

public interface BaseUserInfo {
    Map<String,String> getBaseInfo();
    Map<String,String> getAddressInfo();
    Map<String,String> getIdInfo();
}

实现类

public class OtherUser implements BaseUserInfo {
    @Override
    public Map<String, String> getBaseInfo() {
        Map<String,String> map = new HashMap<>();
        map.put("name","zhangsan");
        map.put("age","20");
        return map;
    }

    @Override
    public Map<String, String> getAddressInfo() {
        Map<String,String> map = new HashMap<>();
        map.put("address","shanghai");
        return map;
    }

    @Override
    public Map<String, String> getIdInfo() {
        Map<String,String> map = new HashMap<>();
        map.put("id","3000");
        return map;
    }
}

这种情况要对接到我们的系统，满足我们的接口，代码如下

public class StaffOut extends OtherUser implements UserInfo{
    @Override
    public String getName() {
        return super.getBaseInfo().get("name");
    }

    @Override
    public String getAge() {
        return super.getBaseInfo().get("age");
    }

    @Override
    public String getAddress() {
        return super.getAddressInfo().get("address");
    }

    @Override
    public String getIDNumber() {
        return super.getIdInfo().get("id");
    }
}

这样在调用的时候我们只需要修改一行代码就能满足需求

public class Main {
    public static void main(String[] args){
//        UserInfo info = new StaffIn();
        UserInfo info = new StaffOut();
        System.out.println("员工姓名：" +info.getName() );
        System.out.println("员工年龄：" +info.getAge() );
        System.out.println("员工地址：" +info.getAddress() );
        System.out.println("员工身份证号：" +info.getIDNumber() );
    }
}

对象适配

对接对象不是一个了，而是多个，显然继承的方式是不可以了，这就需要组合的方式。
对接的类如下

public class PsersonInfo {
    public String getName(){
        return "lisi";
    }

    public String getAge(){
        return "30";
    }
}

public class AddressInfo {
    public String getAddress(){
        return "南京";
    }
}

public class IDInfo {
    public String getID(){
        return "4000";
    }
}

核心的适配代码

public class StaffOut2 implements UserInfo{

    private PsersonInfo psersonInfo;
    private AddressInfo addressInfo;
    private IDInfo idInfo;

    public StaffOut2(PsersonInfo psersonInfo,AddressInfo addressInfo,IDInfo idInfo){
        this.psersonInfo = psersonInfo;
        this.addressInfo = addressInfo;
        this.idInfo = idInfo;
    }


    @Override
    public String getName() {
        return this.psersonInfo.getName();
    }

    @Override
    public String getAge() {
        return this.psersonInfo.getAge();
    }

    @Override
    public String getAddress() {
        return this.addressInfo.getAddress();
    }

    @Override
    public String getIDNumber() {
        return this.idInfo.getID();
    }
}

我们通过构造函数将需要的类注入到适配的类中，在调用时分别调用实际需要调用的类

public class Main {
    public static void main(String[] args){
        PsersonInfo psersonInfo = new PsersonInfo();
        AddressInfo addressInfo = new AddressInfo();
        IDInfo idInfo = new IDInfo();
        UserInfo info = new StaffOut2(psersonInfo,addressInfo,idInfo);
        System.out.println("员工姓名：" +info.getName() );
        System.out.println("员工年龄：" +info.getAge() );
        System.out.println("员工地址：" +info.getAddress() );
        System.out.println("员工身份证号：" +info.getIDNumber() );
    }
}