设计模式-结构型-适配器模式

适配器模式（Adapter Pattern）：

　　将某个类的接口转换成客户端期望的另一个接口表示，主要的目的是兼容性，让原本因接口不匹配不能一起工作的两个类可以协同工作。如读卡器是作为内存卡和笔记本之间的适配器，需要将内存卡插入读卡器，再将读卡器插入笔记本，这样笔记本就可以读取内存卡了。

适配器模式的主要角色：

　　

　　1、目标接口（Target）：当前系统业务所期待的接口，它可以是抽象类或接口。

　　2、适配者类（Adaptee）：被访问和适配的现存组件库中的组件接口。

　　3、适配器类（Adapter）：转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。

适配器模式主要分三类：类适配器模式、对象适配器模式、接口适配器模式（java中使用）。接下来我们来详细介绍下这三种形式。

　　1、类适配器模式

　　　　当前去外地出差，工作繁忙，回到宾馆也不得不工作。当你拿出电脑，准备接电源，卧槽...不支持！！！电源是两孔的，而插座是三孔的，怎么办呢？你会想到去楼下小商店买个转换插座，将三孔插座转成两孔的来用，简直太聪明了。 

　　　　（以该图代替，原理类似）

internal class Program
{
    private static void Main(string[] args)
    {
        Computer computer = new Computer(new TwoHoleSocket());
        computer.Connect();
        // 类适配器的缺点
        TwoHoleSocket twoHoleSocket = new TwoHoleSocket();
        twoHoleSocket.Test();
    }
}

internal class Computer
{
    private readonly Transformer transformer;

    public Computer(Transformer transformer)
    {
        this.transformer = transformer;
    }

    public void Connect()
    {
        transformer.Transfrom();
        Console.WriteLine("连接成功！！！");
    }
}

/// <summary>
/// 三孔插座Adaptee
/// </summary>
internal class ThreeHoleSocket
{
    public void Show()
    {
        Console.WriteLine("我是三孔插座");
    }

    public void Test()
    {
        Console.WriteLine("我是多余的");
    }
}

/// <summary>
/// 转换器Target
/// </summary>
internal interface Transformer
{
    void Transfrom();
}

/// <summary>
///  两孔插座Adapter
/// </summary>
internal class TwoHoleSocket : ThreeHoleSocket, Transformer
{
    public void Transfrom()
    {
        base.Show();
        Console.WriteLine("转换中。。。。");
        Console.WriteLine("哈哈哈，我已经是两孔插座");
    }
}

　　　　分析：对于类适配器来说，Adapter与Adaptee过于耦合，增加了使用成本，且会暴露不必要的方法。

　　2、对象适配器模式

　　　　当手机没电需要充电，你不可能直接使用220V的电压，如果你真这么做了，请注意人身安全及购买一台新机。此时，充电器就起到了转换器的作用，将220V电压转换成手机可使用的5V电压。

　　　　

class Program
{
    static void Main(string[] args)
    {
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter(new Voltage220V()));
    }
}

class Phone
{
    public void charging(Voltage5V voltage5V)
    {
        voltage5V.output5V();
    }
}

class Voltage220V
{
    public void output220V()
    {
        Console.WriteLine("220V");
    }
}

interface Voltage5V
{
    void output5V();
}

class VoltageAdapter : Voltage5V
{
    private readonly Voltage220V voltage220V;

    public VoltageAdapter(Voltage220V voltage220V)
    {
        this.voltage220V = voltage220V;
    }

    public void output5V()
    {
        voltage220V.output220V();
        Console.WriteLine("5V");
    }
}

　　　　分析：以松耦合的方式实现适配器模式，推荐使用。　　　

　　3、接口适配器模式（java中使用，c#中能够实现但意义不大）

　　　　 

class Program
{
    static void Main(string[] agrs)
    {
        Power5VAdapter power5VAdapter = new Power5VAdapter(new AC220());
        Console.WriteLine(power5VAdapter.output5V());
    }
}

class AC220
{
    public int output220V()
    {
        int output = 220;
        return output;
    }
}

interface Voltage
{
    int output5V();
    int output9V();
    int output12V();
    int output24V();
}

abstract class PowerAdapter : Voltage
{
    private readonly AC220 ac220;

    public PowerAdapter(AC220 ac220)
    {
        this.ac220 = ac220;
    }

    public virtual int output12V()
    {
        return ac220.output220V();
    }

    public virtual int output24V()
    {
        return ac220.output220V();
    }

    public virtual int output5V()
    {
        return ac220.output220V();
    }

    public virtual int output9V()
    {
        return ac220.output220V();
    }
}

class Power5VAdapter : PowerAdapter
{
    private AC220 ac220;

    public Power5VAdapter(AC220 ac220)
        : base(ac220)
    {
        this.ac220 = ac220;
    }

    public override int output5V()
    {
        int output = 0;
        if (this.ac220 != null)
        {
            output = this.ac220.output220V() / 44;
        }
        return output;
    }
}

优点：

　　1、客户端通过适配器可以透明地调用目标接口。

　　2、复用了现存的类，开发人员不需要修改原有代码而重用现有的适配者类。

　　3、将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题。

缺点：

　　1、对类适配器来说，更换适配器的实现过程比较复杂。

　　2、过多的适配器，会让系统零乱，不易整体进行把握。