适配器模式 转贴

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