Adapter
适配器模式是一种结构型模式，主要应对：由于应用环境的变化，常常需要将“一些现存的对象”放在新的环境中应用，但是，新环境要求的接口是现存对象所不满足的。
《设计模式》中说道：将一个类的接口转换成客户希望的另一个接口。
Adapter
模式使得原本由于接口不兼容而不能一起工作的类可以一起工作。
在实际的生活中有很多例子，如：我们常使用的移动硬盘，无论是笔记本硬盘还是台式机硬盘，对于数据的传输都不使用
Usb
的数据线，外接的硬盘盒就是将原来的硬盘数据传输方式适合
Usb
数据线。（哎，我那个硬盘盒买的时候还
190
元，其实一点都不值，整个一个盒，就那个转接芯片比较值钱，我说
50
，人家不卖）。
我再接着说适配器模式，先举个简单的代码例子，我现在要做一个队列的类，实现先进先出的功能。利用
ArrayList
对象。
首先，我们先定义一些队列的接口，接口中定义队列的方法，代码如下：
interface
IQueue
{
void push(object item); //
进队列
object putout(); //
出队列
object ShowLastItem(); //
返回队列中最后一项
object ShowFirstItem(); //
返回队列中第一项
}
下面我们再来利用ArrayList对象实现一个队列：
class Queue:IQueue
{
ArrayList adaptee;
public Queue()
{
adaptee = new ArrayList();
}
public
void push(object item)
{
adaptee.Add(item);
}
public
object putout()
{
object item = adaptee[0];
adaptee.RemoveAt(0);
return item;
}
public
object ShowLastItem()
{
return adaptee[adaptee.Count-1];
}
public
object ShowFirstItem()
{
return adaptee[0];
}
}
实现有了，现在用客户端程序调用来看一下结果：
class Class1
{
///
<summary>
///
应用程序的主入口点。
///
</summary>
[STAThread]
static
void
Main(string[] args)
{
Queue queue = new Queue();
queue.push(1);
queue.push(2);
queue.push(3);
queue.push(4);
queue.push(5);
Console.Write("FirstItem:" + queue.ShowFirstItem().ToString() + "\n");
Console.Write("LastItem:" + queue.ShowLastItem().ToString() + "\n");
Console.Write("output:" + queue.putout().ToString() + "\n");
queue.push(6);
Console.Write("FirstItem:" + queue.ShowFirstItem().ToString() + "\n");
Console.Write("LastItem:" + queue.ShowLastItem().ToString() + "\n");
Console.Read();
}
}
输出结果：
FirstItem:1
LastItem:5
output:1
FirstItem:2
LastItem:6
适配器模式实现有两种类型：对象适配器、类适配器。上面的代码是对象适配器方式。也就是适配器（Queue）中是使用被适配（ArrayList）的对象实现。它的结构如下：
Gof
《设计模式》中提到了两种Adapter适配器模式，一种叫对象适配器模式，另一种叫类适配器模式。对象适配器模式的结构如上图，也就是我刚才举的那个例子，那什么是类适配器模式呢？实际上类适配器模式就是让Adapter的实现继承Adaptee。换句话说：类适配器模式是以继承的方式来实现，而对象适配器模式是以组合的方式实现。以前我们说过：继承增加了模块间的耦合程度，而组合降低了耦合程度，所以有人建议多使用对象适配器模式，少用类适配器模式。不过既然提到，我也具体谈谈类适配器模式。它的结构如下图：
我们依然用上面的那个队列的例子，首先我们要实现一个Adapter的类，这个类要继承适配对象Adaptee类，也就是例子中的ArrayList，还有队列接口，就是我们定义的IQueue，代码如下：
class ClassAdapter:ArrayList,IQueue
{
public ClassAdapter()
{
}
public
void push(object item)
{
this.Add(item);
}
public
object putout()
{
object item = this[0];
this.RemoveAt(0);
return item;
}
public
object ShowLastItem()
{
return
this[this.Count-1];
}
public
object ShowFirstItem()
{
return
this[0];
}
}
然后我们再修改一下客户代码：
static
void
Main(string[] args)
{
ClassAdapter queue = new ClassAdapter();
queue.push(1);
queue.push(2);
queue.push(3);
queue.push(4);
queue.push(5);
Console.Write("FirstItem:" + queue.ShowFirstItem().ToString() + "\n");
Console.Write("LastItem:" + queue.ShowLastItem().ToString() + "\n");
Console.Write("output:" + queue.putout().ToString() + "\n");
queue.push(6);
Console.Write("FirstItem:" + queue.ShowFirstItem().ToString() + "\n");
Console.Write("LastItem:" + queue.ShowLastItem().ToString() + "\n");
Console.Read();
}
输出结果为：
FirstItem:1
LastItem:5
output:1
FirstItem:2
LastItem:6
要说明一点：从实现的代码看：ClassAdapter类同时继承了ArrayList,IQueue，这样违反了设计原则中的单一职责原则（SRP）——一个类应该仅有一个引起他变化的原因。
接下来，我们在看看Adapter模式的几个要点：
1、
Adapter
模式主要应用于“希望服用一些现存的类，但是接口又与复用环境要求不一致的情况”，在遗留代码复用、类库迁移等方面非常有用。
2、
Gof23
定义了两种Adapter模式的实现结构：对象适配器和类适配器。但类适配器采用“多继承”的实现方式，带来了不良的高耦合，所以一般不推荐使用。对象适配器采用“对象组合”的方式，更符合松耦合精神。
3、
Adapter
模式本身要求我们尽可能的使用“面向接口的编程”风格，这样才能在后期很方便的适配
Adapter
模式的实现方法有很多，说到这我在举一个例子，我现在有这样一个场景。我有一辆BORA车子和BMW的Engine和Wheel，我现在想改装这辆BORA使其拥有BMW的Engine和Wheel，我如何做呢？
首先，我们要拥有一些BMW的零部件，代码如下：
class
BMWPartClass
{
public
void BMWEngine()
{
Console.Write("It is a BMWEngine\n");
}
public
void BMWWheel()
{
Console.Write("It is a BMWWheel\n");
}
}
然后，再来实现对这些零部件的适配，代码如下：
interface
ITarget
{
void Request();
}
class Adapter:ITarget
{
BMWPartClass adaptee = new BMWPartClass();
public
void Request()
{
adaptee.BMWEngine();
adaptee.BMWWheel();
}
}
对于我的BORA的实现：
class
MyBORAClass
{
public
void Process(ITarget target)
{
target.Request();
}
}
最后是客户端代码：
static
void
Main(string[] args)
{
MyBORAClass bora = new MyBORAClass();
bora.Process(new Adapter());
Console.Read();
}
输出结果是：
It is a BMWEngine
It is a BMWWheel