适配器模式--Adapter Pattern

时间：2014-04-28 13:44:44 阅读：491 评论：0 收藏：0 [点我收藏+]

标签：com http class blog style div code img java javascript string

　　模拟场景：很多人都喜欢看NBA吧，姚明进驻NBA，打开了中国的市场。虽然后面姚明在NBA打得还不错，但是在刚进入NBA篮坛的时候，并不是那么顺利的。语言交流就是一个最大的问题。刚开始打球期间，教练及队员的战术部署姚明都无法理解，所以他需要这么一个翻译者，将教练及队员的意思转达给姚明，这样才可以进行合作。

　　现在进行场景的模拟，先不考虑那么多。假如姚明一开始进入NBA的时候就已经会英语，可以进行交流了。那么这个时候教练就可以进行战术的部署了。

　　转换成类，所有的队员都要服从教练的战术要求，假设现在教练都要给队员部署进攻和防守的指令。所有大家接收的动作是一致的，只是实现不一样而已。所有这里需要先定义出一个接口或者抽象类。

IPlayer

 1 package com.zqz.dp.adapter;
 2 /**
 3  * @author Qin 所有运动员的父接口，完成同样的动作
 4  */
 5 public interface IPlayer {
 6     /**
 7      * 运动员进攻
 8      */
 9     void attack();
10     /**
11      * 运动员防守
12      */
13     void defense();
14 }

　　构建完接口之后，就是对接口进行实现了。假设现在有前锋forwards、中锋center、后卫guards三种运动员，来根据教练的指令完成不同的动作。

Forwards

 1 package com.zqz.dp.adapter;
 2 /**
 3  * @author Qin
 4  * 前锋类，实现运动员接口，实现自己的动作
 5  */
 6 public class Forwards implements IPlayer {
 7     private String name;    //定义运动员的名字
 8     public Forwards(String name) {        //构造方法赋值
 9         this.name = name;
10     }
11     @Override
12     public void attack() {
13         System.out.println("前锋〖"+this.name+"〗攻击。。。");
14     }
15     @Override
16     public void defense() {
17         System.out.println("前锋〖"+this.name+"〗防守。。。");
18     }
19 }

Center

 1 package com.zqz.dp.adapter;
 2 /**
 3  * @author Qin
 4  * 中锋类，实现运动员接口，实现自己的动作
 5  */
 6 public class Center implements IPlayer {
 7     private String name;    //定义运动员的名字
 8     public Center(String name) {        //构造方法赋值
 9         this.name = name;
10     }
11     @Override
12     public void attack() {
13         System.out.println("中锋〖"+this.name+"〗攻击。。。");
14     }
15     @Override
16     public void defense() {
17         System.out.println("中锋〖"+this.name+"〗防守。。。");
18     }
19 }

Guards

 1 package com.zqz.dp.adapter;
 2 /**
 3  * @author Qin
 4  * 后卫类，实现运动员接口，实现自己的动作
 5  */
 6 public class Guards implements IPlayer {
 7     private String name;    //定义运动员的名字
 8     public Guards(String name) {        //构造方法赋值
 9         this.name = name;
10     }
11     @Override
12     public void attack() {
13         System.out.println("后卫〖"+this.name+"〗攻击。。。");
14     }
15     @Override
16     public void defense() {
17         System.out.println("后卫〖"+this.name+"〗防守。。。");
18     }
19 }

Client

 1 package com.zqz.dp.adapter;
 2 /**
 3  * @author 
 4  * Qin 场景类，模拟NBA比赛
 5  */
 6 public class Client {
 7     public static void main(String[] args) {
 8         IPlayer ba=new Forwards("巴蒂尔");
 9         ba.attack();
10         IPlayer yao=new Center("姚明");
11         yao.attack();
12         yao.defense();
13         IPlayer mai=new Guards("麦迪");
14         mai.defense();
15     }
16 }

　　以上的操作很简单，说白了就是父类引用指向子类实例，但是现在姚明是直接可以听懂了教练的战术安排了，这个已经是后面发展得很好的姚明了。并不是一开始不能进行交流的那个大姚了。

　　要模拟刚入NBA的大姚，那么说明需要创建一个新的类来表示大姚这个对象。在这里我们把Center改成foreignCenter，表示外籍中锋。而很明显这个时候大姚根本无法听懂教练的意思，所以需要一个翻译者translator，翻译者是可以听懂教练的意思的，但是听懂了总不能自己上场比赛吧，所以要把教练的意思传递给大姚，交给大姚去执行。

　　转化为类之间的关系也就是translator类要实现IPlayer接口，并且要有一个fireignCenter的引用，具体的实现交给引用去调用自己的方法。

ForeignCenter

 1 package com.zqz.dp.adapter;
 2 /**
 3  * @author Qin 
 4  * 外籍中锋类，外籍中锋是新引进的类，并不能听懂教练的意思，所以只能执行自己的功能
 5  */
 6 public class ForeignCenter {
 7     private String name; // 定义运动员的名字
 8     public ForeignCenter(String name) { // 构造方法赋值
 9         this.name = name;
10     }
11     public void attack() {
12         System.out.println("外籍中锋〖" + this.name + "〗攻击。。。");
13     }
14     public void defense() {
15         System.out.println("外籍中锋〖" + this.name + "〗防守。。。");
16     }
17 }

Translator

 1 package com.zqz.dp.adapter;
 2 /**
 3  * @author Qin
 4  * 翻译者类，适配器对象。传递教练的意思给外籍中锋
 5  */
 6 public class Translator implements IPlayer {
 7     private ForeignCenter fc;
 8     public Translator() {    //翻译者类知道要把消息传递给谁，所以立即生成外籍中锋实例
 9         fc=new ForeignCenter("大姚");
10     }
11     @Override
12     public void attack() {
13         this.fc.attack();    //告诉大姚要进行攻击
14     }
15     @Override
16     public void defense() {
17         this.fc.defense();    //告诉大姚进行防守
18     }
19 }

　　其他类不变。这样就完成了功能，由翻译者转达大姚进行战术的安排。

　　上面的操作其实很简单，只是在执行的时候调用的是具体真实类的操作而已。是否会觉得有点跟代理类似，其实会这样觉得是因为我把ForeignCenter中的方法定义成和IPlayer的方法一致。也就是说虽然教练给大姚下达了战术的安排，但是大姚可以执意按自己的想法进行安排。所以这也是和代理不同的地方。

　　以上的操作就是适配器模式，准确来说是对象适配器，因为在类中传递了另一个类的引用。还有另一种叫做类适配器。要实现类适配器就方便多了，只要让Translator继承ForeignCenter即可，再调用父类的方法。很明显在这里是不合适的，因为两者不存在is-a的关系，所以在真正开发中，对象适配器用的必类适配器多。

　　听名字大家就应该能明白意思了，何为适配器？就是把两个不合适的对象通过一个中间对象连接起来。像我们平常的电池充电不也需要一个电源适配器吗？就是一样的道理。

　　适配器模式是一个补救的模式，也就是说一般在开发前期不会考虑该模式，而是在后期扩展中才会考虑到。还是以上面的例子为例，NBA事先根本就不能料想到是否会有中国球员参加比赛，所以才会有翻译者的存在，翻译者就是一个适配器。