设计模式之适配器模式

适配器模式是一种结构性设计模式，它允许接口不兼容的类能够相互通信。该模式通常使用于需要将旧系统升级到新系统的情况

适配器模式(Adapter)的基本概念：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

适配器的作用：当系统的数据和行为都正确，但接口不符时，我们应该考虑使用适配器，目的是使控制范围之外的一个原有对象与某个接口匹配。

适配器的使用范围：适配器模式主要应用于希望复用一些现存的类，但接口又与复用环境要求不一致的情况。

适配器模式的结构图

  class Target
    {
        public virtual void Request()
        {
            Console.WriteLine("普通请求!");
        }
    }

 class Adaptee
    {
        public void SpecificRequest()
        {
            Console.WriteLine("特殊请求！");
        }
    }


    class Adapter:Target
    {
        private Adaptee adaptee = new Adaptee();//建立一个私有的Adaptee类

        public override void Request()
        {
            adaptee.SpecificRequest(); //这样就可以把表面上调用Request()方法变成实际调用SpecificRequest()
        }
    }


 class Program
    {
        static void Main(string[] args)
        {
            Target target = new Adapter();//对于客户端来说，调用的就是Target的Request()方法
            target.Request();

            Console.Read();
        }
    }
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

适配器的使用情况。
如果想使用一个已经存在的类，但如果它的接口，也就是它的方法和你的要求不相同时，就应该考虑使用适配器模式

两个类所做的事情相同或者相似时，但是具有不同的接口时要使用它

例子，这里的代码取自大话设计模式中的适配器模式

Player类

abstract class Player
    {
        protected string name;
        public Player(string name)
        {
            this.name = name;
        }
        public abstract void Attack();//进攻
        public abstract void Defense();//防守
    }

    //前锋
    class Forwards : Player
    {
        public Forwards(string name) : base(name)
        { }

        public override void Attack()
        {
            Console.WriteLine("前锋{0}进攻",name);
        }

        public override void Defense()
        {
            Console.WriteLine("前锋{0}防守",name);
        }
    }

    //中锋
    class Center : Player
    {
       
        public Center(string name) : base(name){ }
   

        public override void Attack()
        {
            Console.WriteLine("中锋{0}进攻",name);
        }

        public override void Defense()
        {
            Console.WriteLine("中锋{0}防守",name);
        }
    }

    //后卫
    class Guards : Player
    {

        public Guards(string name) : base(name) { }
        public override void Attack()
        {
            Console.WriteLine("后卫{0}进攻",name);
        }

        public override void Defense()
        {
            Console.WriteLine("后卫{0}防守",name);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

    class ForeignCenter
    {
        private string name;
        public string Name//外籍中锋类球员的姓名故意用属性而不是构造方法来区别于前三个球员类的不同
        {
            get { return name; }
            set { name = value; }
        }
        public void 进攻()
        {
            Console.WriteLine("外籍中锋{0}进攻",name);
        }
        public void 防守()
        {
            Console.WriteLine("外籍中锋{0}防守",name);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

  class Translator:Player
    {
        private ForeignCenter wjzf = new ForeignCenter();//声明并实例化一个内部'外籍中锋'对象，表明翻译者与外籍球员有关联

        public Translator(string name):base(name)
        {
            wjzf.Name = name;
        }



        public override void Attack()
        {
            wjzf.进攻();
        }

        public override void Defense()
        {
            wjzf.防守();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

    class Program
    {
        static void Main(string[] args)
        {
            Player b = new Forwards("小巴");
            b.Attack();
            Player m = new Guards("麦迪");
            m.Attack();
            Player ym = new Translator("姚明");
            ym.Attack();
            Console.ReadKey();
          
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

这里外籍球员与球员就属于两个不同的类，通过Translator来进行适配，可以在不改变两个类的基础上，实现功能复用。