从抽象类到接口

假设有以下的类

 1    public abstract class GunBase//枪械
 2    {
 3        public abstract void Shoot();//射击
 4        public abstract ClipMode Clip//配置弹夹
 5        {
 6            set;
 7            get;
 8        }
 9        public abstract void Load();//装填弹药
10    }
11
12    public enum ClipMode
13    {
14        Inside,
15        Outside
16    }

我们当然它为抽象类，但这样一个抽象类，其没有构造函数，其所有成员也都完全是抽象的，我们还可以称其为纯抽象（虚）类。因为这个类，是完全的抽象的，但如果代码改为

 1    public abstract class GunBase//枪械
 2    {
 3        public abstract void Shoot();//射击
 4        private ClipMode clipMode;
 5        public abstract ClipMode Clip//配置弹夹
 6        {
 7            set
 8            {
 9                clipMode = value;
10            }
11            get
12            {
13                return clipMode;
14            }
15        }
16        public abstract void Load();//装填弹药
17    }

同样是抽象类，但修改后的类，就不再是纯抽象类了。纯抽象的类，我们要求是没有构造函数，没有任何的非抽象成员，所有成员的访问修饰都是public的，这样我们有了一个新的名词：接口interface。

现了解一下接口的定义要求
接口就是一个纯抽象类（所以接口是引用类型），接口可以包含方法、属性、事件和索引器，实现该接口的类或结构必须实现这些成员。
相比起抽象类，接口有以下特征

不需要声明接口为抽象或虚拟（本来就是）
接口不允许有构造函数（纯抽象了，根本不需要构造）
接口不允许有析构函数（本来无构造，何需有析构）
接口的所有成员都是抽象的（纯抽象类嘛）
接口只可以从接口继承（因为只有接口可以保证使纯虚的，如果从抽象类继承，不能保证抽象类中可能存在非抽象的成员）
接口成员不允许有任何修饰（默认就是public的，也只有是public的）
一个类或结构可以实现多个接口

那为什么要接口呢？
我们设想一个场景，假设我要写一个模拟角色的游戏，每个玩家都可以拥有多个角色（职业），如果有一个人其职业是医生，但同时他也是研究生，在学校带课，但又在攻读博士，同时呢，由于工作出色，担任了科室主任，在回家的路上又去了超市。
那我们可以观察到，这个人实现了的角色有：医生、学生、讲师、领导、顾客。那类怎么描述实现呢？用继承？

 1    public class Person
 2    {
 3        public string Name;
 4        public Sex Sex;
 5    }
 6
 7    public class Doctor : Person//医生
 8    {
 9        public bool Operations()
10        {
11        }//返回成功与否
12        public string Diagnosis()
13        {
14        }//返回诊断意见
15    }
16
17
18    public class Gaduate : Doctor //学生
19    {
20        public void GotoClass()
21        {
22
23        }
24        public int Exam()
25        {
26
27        }//作练习返回成绩
28    }
29
30    public class Professor : Gaduate//教授
31    {
32        public void Disquisition()
33        {
34        }
35    }
36
37    public class Consumer : Professor//顾客
38    {
39        public void stock()
40        {
41        }
42        public void paying(double cash)
43        {
44
45        }//支付
46    }

如果你还有一点点面向对象的理智的话，就知道这个非常非常的错误的设计。不但类的结构非常的臃肿，还难以代码重用。

所以我们将代码改为使用接口来实现。
我们把job角色定义为接口，而不是类

 1    public interface IDoctor//医生
 2    {
 3        bool Operations();//返回成功与否
 4        string Diagnosis();//返回诊断意见
 5    }
 6
 7
 8    public interface IGaduate //学生
 9    {
10        void GotoClass();
11        int Exam();//作练习返回成绩
12    }
13
14    public interface IProfessor//教授
15    {
16        void Disquisition();
17    }
18
19    public interface IConsumer
20    {
21        void Stock();
22        void Paying(double cash);//支付
23    }

这样Person 类就可以实现（继承）多个接口

 1public class Person : IDoctor, IGaduate, IProfessor, IConsumer
 2    {
 3        public string Name;
 4        public Sex Sex;
 5        public int Age;
 6
 7
 8        IDoctor 成员#region IDoctor 成员
 9
10        public bool Operations()
11        {
12            return false;
13        }
14
15        public string Diagnosis()
16        {
17            return "";
18        }
19
20        #endregion
21
22        IGaduate 成员#region IGaduate 成员
23
24        public void GotoClass()
25        {
26        }
27
28        public int Exam()
29        {
30            return 0;
31        }
32
33        #endregion
34
35        IProfessor 成员#region IProfessor 成员
36
37        public void Disquisition()
38        {
39        }
40
41        #endregion
42
43
44
45        IConsumer 成员#region IConsumer 成员
46
47        void IConsumer.Stock()
48        {
49
50        }
51
52        void IConsumer.Paying(double cash)
53        {
54
55        }
56
57        #endregion
58    }

注意，IConsumer 成员采用的是显式实现。
标准实现的模型是：public 接口成员[返回值 名字 参数] {}
显式实现的模型是：没有访问修饰符 接口名称.接口成员[返回值 名字 参数] {}

显式实现的接口成员没有访问修饰符，也就意味着显式实现的成员感觉上是私有的，不能被访问。那这样的实现有什么意思呢？
请看下篇：我，只关心接口。