设计模式深入学习---Adapter 适配器模式(结构型模式)

   首先我们了解下什么是Adapter 适配器模式。在多人开发程序中，经常会碰到这样的问题，A编写了一套数据，B也编写了一套数据，两个人的实现目的相同，结构相同，但就是名字不一样。这时候A要把B的代码结合到自己的程序中，如A制作了几个敌人攻击类，里面都有Attack方法，通过循环把全部敌人的Attack方法调用。B也制作了一个敌人类，但是B的敌人类的方法不是Attack方法，叫Hit方法，那这时怎么办呢，可能你会说把B的方法名字改一下不就好了，那如果B写的代码很多，修改起来很复杂，又或者这时候CDEF又有新的类需要接入过来呢，几十个人共同开发的话那不就得累死人了么。这时候就用得上Adapter 适配器模式了，简单说，Adapter 适配器模式就像我们生活中的转接头一样，相当于实现了一个转接头，把各种不同的插头，统一转换过来，并改造成适合我们使用的类。废话完毕，开动代码。正好之前做过类似某民突击的实现，就用这个做下例子，我们做几个AI敌人，分别是 步兵，狙击手，他们分别继承于一个虚类Soldier，然后都有一个攻击方法，防御方法。

public abstract class Soldier
 {
   public string Name;
 
     public Soldier(string name)
     {
         this.Name = name;
     }
 
     public abstract void Attack();
     public abstract void Defense();
 }

   上面就是虚类的构成，我们现在把步兵和狙击兵实现一下 ：

//步兵
   public class Infantry : Soldier {
        public Infantry(string name) : base(name)
        {
 
        }
 
        public override void Attack()
        {
            Console.WriteLine(this.Name + "使用突击枪攻击");
        }
 
        public override void Defense()
        {
            Console.WriteLine(this.Name + "使用突击枪防御");
        }
    }
 
    //狙击兵
    public class Sniper : Soldier
    {
        public Sniper(string name) : base(name)
        {
        }
 
        public override void Attack()
        {
            Console.WriteLine(this.Name+"使用狙击枪攻击");
        }
[mw_shl_code=applescript,true]   static void Main(string[] args)
        {
            Soldier sniper = new Sniper("狙击手1号");
            sniper.Attack();
            sniper.Defense();
 
            Soldier infantry=new Infantry("步兵2号");
            infantry.Attack();
            infantry.Defense();
  
            Console.Read();
        }

   好了，这时候我们在初始化的时候把他们分别new一下，然后就可以看到两个士兵分别运行了起来。

static void Main(string[] args)
     {
         Soldier sniper = new Sniper("狙击手1号");
         sniper.Attack();
         sniper.Defense();
 
         Soldier infantry=new Infantry("步兵2号");
         infantry.Attack();
         infantry.Defense();
 
         Console.Read();
     }

   如果这时候，我们有了一个新的机器人的一个类进来，它的攻击和防御方法都和我们不一样，回到我们原来说的 ，如果这段代码不允许我们去更改的话，那应该怎么办呢 ？

public class RobotSoldier
   {
       public string Name;
 
       public RobotSoldier()
       {
       }
 
       public RobotSoldier(string name)
       {
           this.Name = name;
       }
 
       public void RobotAttack()
       {
           Console.WriteLine(Name+"使用激光器攻击");
       }
 
       public void RobotDefense()
       {
           Console.WriteLine(Name + "使用光盾防御");
       }
   }

   这时候，我们的适配器模式就可以派上用场了。首先我们新建一个 Translator类（适配器类），继承于士兵类，然后在类里面new一个外部的机器人 类， 我们在我们的适配器 里面重新封装里面的方法，就可以让我们的程序和适配器类一块调用起来了。

public class Translator : Soldier
   {
       private RobotSoldier RotSoldier=new RobotSoldier();
 
       public Translator(string name) : base(name)
       {
           RotSoldier.Name = name;
 
       }
 
       public override void Attack()
       {
        RotSoldier.RobotAttack();
       }
 
       public override void Defense()
       {
          RotSoldier.RobotDefense();
       }
   }

好，现在我们重新再来声明一下，就可以让机器人和我们之前的士兵们一块运行，并统一调配了：

class Program
  {
      static void Main(string[] args)
      {
          Soldier sniper = new Sniper("狙击手1号");
          sniper.Attack();
          sniper.Defense();
 
          Soldier infantry=new Infantry("步兵2号");
          infantry.Attack();
          infantry.Defense();
 
          Soldier rotSoldier=new Translator("机器人5号");
          rotSoldier.Attack();
          rotSoldier.Defense();
 
 
          Console.Read();
      }
  }

   我们就可以看到画面按照我们设想的一样正常运行了：  

 

     看到这里是不是觉得适配器模式又简单又好用呢，我们简单的来回顾一下适配器设计模式。
    Adapter模式主要应用于"希望复用一些现存的类，但是接口又和复用环境要求不一致的情况"，在遗留代码复用，类库迁移等方法非常有效。
     Adapter模式本身要求我们尽可能的使用"面向接口的编程"风格，这样才能在后期很方便的适配。