设计模式.适配器(接口转换，分为：类，对象，接口)

适配器是各种结构模式的起源，根据转换接口的不同区分为类(功能图纸层面)，对象(已经有实物)，接口(接口转换)。

对比： 设计笔记本的时候就发现，主板接口和电源输出设计图纸不一样，那么就再设计一个转换器（实际中实现功能转换，现在还没new对象呢）；如果你笔记本(已经new出来)没有网口只有USB，那么就买个USB和网口装换器(实例，对象)； 某接口方法太多，实现类不想实现那么多，这是就通过抽象类实现方法。真正的类继承这个抽象方法接口。

 定义

就相当于一个TypeC口到USB的一个装换器，转接器一头连接TypeC一头连接USB，中间是转换逻辑。

关键字

转接接口

根据适配对象的不同分类

• 类适配：集成原始，扩展目标接口。
• 对象适配：组合原始，扩展目标接口。
• 接口适配：原始多个接口，输出一个接口。

区别

1. 接口适配 是 减少子类需要实现接口的方法数量
2. 类适配，将目标类封装到适配器中，适配器提供目标接口就行，两个对象。实现方式：继承
3. 对象适配，只是一个转接头，三个对象。实现方式：组合(子对象)

类适配器

场景：

笔记本生产工厂发现，现在的电源线是USB接口，电脑是TypeC接口，生产出来是不能用的。这时候还停留在类层面。

解决：

对USB电源线进行封装，形成新的电源线，新电源线暴露TypeC接口就行，以后一生产出来的电源线就是可用的。

类图：

图示：

 实现：完整见com.haiwei.structure.adapter.class1

	适配器
public class PowerAdaper extends UsbPowerCord implements TypeC{
    @Override
    public void receivePower() {
        //转换逻辑
        super.supplyPower();
    }
}
	调用
public class Client {
    public static void main(String[] args) {
        /**
         * OUT:
         * supplyPower ....
         * computer start ...
         */
        Computer c = new Computer();
        TypeC ele = new PowerAdaper();
        c.start(ele );
    }
}

对象适配器

场景：某人买了电脑是TypeC接口（接口），电源线坏了，有买了一个电源性USB接口电源线（对象），但是，没法把 USB的电源线插入到TypeC口内。

解决：再买一个转换器，实现了TypeC接口，又能接入USB线，那么问题就可解决。

类图：

图示：

 实现：(完整代码见：com.haiwei.structure.adapter.object1)

	适配器
public class PowerAdaper  implements TypeC{
    
    private USB usb;
    
    public void setUsbPower(USB usb){
        this.usb = usb;
    }

    @Override
    public void receivePower() {
        //转换逻辑
        this.usb.supplyPower();
    }

}
	调用
public class Client {
    public static void main(String[] args) {
        
        /**
         * OUT:
         * supplyPower ....
         * computer start ...
         */
        Computer c = new Computer();
        PowerAdaper adpter = new PowerAdaper();
        USB usb = new UsbPowerCord();
        adpter.setUsbPower(usb );
        c.start(adpter );
    }
}

接口适配器

场景：

某接口方法太多，实现类不想实现那么多，这是就通过抽象类实现方法。真正的类继承这个抽象方法接口。

类图：

 实现：完整见com.haiwei.structure.adapter.interface1

public interface SuperInterface {
    public void a();
    public void b();
    public void c();
}
public abstract class AbstractAdapter implements SuperInterface{
    public void a(){}
    public void b(){}
}
public class Object1 extends AbstractAdapter{
    public void c() {
    }
}