类,抽象类与接口之我所见!
在学习过程中,抽象类与接口二者的关系已被高手阐述了N遍,但是,仅仅罗列出他们之间的区别是不能够表述清晰的，我看了Anytao和KeithDa两位高手写的文章,他们说的都非常好,让我受益非浅,结合二位前辈的经验和我在项目中的体会，斗胆也谈谈他们的关系和取舍!
定义:
接口:接口是包含一组虚方法的抽象类型，其中每一种方法都有其名称、参数和返回值。接口方法不能包含任何实现;
抽象类:抽象类提供多个派生类共享基类的公共定义，它既可以提供抽象方法，也可以提供非抽象方法。抽象类不能实例化，必须通过继承由派生类实现其抽象方法.
应用与取舍:
二者的使用要看具体情况,有可能只有其中一种,也可能全部使用效果才好.下面做一个我自己认为能说明问题的例子:
如果我们定义的类只有具体的人，那以上代码基本可以实现功能，我们也没必要非要用接口，但是.... ，如果有一天我们还要增加其他的类别，比如说：
比较两段代码，有没有发现其中有共同的部分，其实两个种类有相同的方法成员，（交谈和移动），我们可以把它提取出来做为接口，让所有具体有该行为的类继承该接口.
可是，慢着，如果我不提取出来，保持现在这个样子不是很好吗？ 现在看起来是没有任何问题，但是如果某一天，系统要求中国人，美国人,鸡，羊都要增加＂吃饭＂ 这个方法呢？ 以后还要增加 ＂喝水＂ ，＂高兴的表情＂.... 诸如此类，，现在只有两个抽象类还不算太坏，如果还增加其他种类，比如说：我想从动物种类中单独出来 ＂家畜类＂，＂哺乳动物类＂，＂鸟类＂.... 在这种情况下还是用这种单一的抽象类继承是非常棘手的． 这时我们可以将所有类的普遍行为归为一个接口，而将每个种类特有的行为和属性归类到一个抽象类中，这样既保持了具体类既有它的特有行为，也有共同的行为 ，具体时候之后大概会是酱紫：
定义:
接口:接口是包含一组虚方法的抽象类型，其中每一种方法都有其名称、参数和返回值。接口方法不能包含任何实现;
抽象类:抽象类提供多个派生类共享基类的公共定义，它既可以提供抽象方法，也可以提供非抽象方法。抽象类不能实例化，必须通过继承由派生类实现其抽象方法.
应用与取舍:
二者的使用要看具体情况,有可能只有其中一种,也可能全部使用效果才好.下面做一个我自己认为能说明问题的例子:
1 // 定义人的抽象类
2 abstract class people
3 {
4 // 定义成员
5 protected string _name;
6
7 // 定义姓名属性
8 public abstract string name
9 {
10 get:
11 set:
12 }
13
14 // 定义交谈方法
15 public abstract void talk()
16
17 // 定义移动方法
18 public abstract void move()
19 }
20
21
22 /////////////////////////////////////////////
23
24 // 定义中国人
25 abstract class Chinaman:people
26 {
27 // 构造函数
28 public Chinaman(string strname)
29 {
30 _name = strname
31 }
32
33 // 实现姓名属性成员
34 public override string name
35 {
36 get
37 {
38 return _name;
39 }
40 set
41 {
42 _name = value;
43 }
44 }
45
46 // 实现交谈方法
47 public override void talk()
48 {
49 Response.write("我说的是汉语!");
50 }
51
52 // 实现移动方法
53 public override void move()
54 {
55 Response.write("我步行移动！");
56 }
57 }
58
59
60 // 定义美国人
61 abstract class American:people
62 {
63 // 构造函数
64 public American(string strname)
65 {
66 _name = strname
67 }
68
69 // 实现姓名属性成员
70 public override string name
71 {
72 get
73 {
74 return _name;
75 }
76 set
77 {
78 _name = value;
79 }
80 }
81
82 // 实现交谈方法
83 public override void talk()
84 {
85 Response.write("我说的是英语!");
86 }
87
88 // 实现移动方法
89 public override void move()
90 {
91 Response.write("我开车移动！");
92 }
93 }
94
95 ．．．．
2 abstract class people
3 {
4 // 定义成员
5 protected string _name;
6
7 // 定义姓名属性
8 public abstract string name
9 {
10 get:
11 set:
12 }
13
14 // 定义交谈方法
15 public abstract void talk()
16
17 // 定义移动方法
18 public abstract void move()
19 }
20
21
22 /////////////////////////////////////////////
23
24 // 定义中国人
25 abstract class Chinaman:people
26 {
27 // 构造函数
28 public Chinaman(string strname)
29 {
30 _name = strname
31 }
32
33 // 实现姓名属性成员
34 public override string name
35 {
36 get
37 {
38 return _name;
39 }
40 set
41 {
42 _name = value;
43 }
44 }
45
46 // 实现交谈方法
47 public override void talk()
48 {
49 Response.write("我说的是汉语!");
50 }
51
52 // 实现移动方法
53 public override void move()
54 {
55 Response.write("我步行移动！");
56 }
57 }
58
59
60 // 定义美国人
61 abstract class American:people
62 {
63 // 构造函数
64 public American(string strname)
65 {
66 _name = strname
67 }
68
69 // 实现姓名属性成员
70 public override string name
71 {
72 get
73 {
74 return _name;
75 }
76 set
77 {
78 _name = value;
79 }
80 }
81
82 // 实现交谈方法
83 public override void talk()
84 {
85 Response.write("我说的是英语!");
86 }
87
88 // 实现移动方法
89 public override void move()
90 {
91 Response.write("我开车移动！");
92 }
93 }
94
95 ．．．．
如果我们定义的类只有具体的人，那以上代码基本可以实现功能，我们也没必要非要用接口，但是.... ，如果有一天我们还要增加其他的类别，比如说：
1 // 定义动物的抽象类
2 abstract class animal
3 {
4 // 定义成员
5 protected string _kind;
6
7 // 定义类型属性
8 public abstract string kind
9 {
10 get:
11 set:
12 }
13
14 // 定义交谈方法
15 public abstract void talk()
16
17 // 定义移动方法
18 public abstract void move()
19 }
20
21
22 /////////////////////////////////////////////
23
24 // 定义羊
25 abstract class sheep:animal
26 {
27 // 构造函数
28 public sheep(string strkind)
29 {
30 _kind = strkind
31 }
32
33 // 实现类型属性成员
34 public override string kind
35 {
36 get
37 {
38 return _kind;
39 }
40 set
41 {
42 _kind = value;
43 }
44 }
45
46 // 实现交谈方法
47 public override void talk()
48 {
49 Response.write("咩咩的叫!");
50 }
51
52 // 实现移动方法
53 public override void move()
54 {
55 Response.write("四蹄行走！");
56 }
57 }
58
59
60 // 定义鸡
61 abstract class chicken:animal
62 {
63 // 构造函数
64 public chicken(string strkind)
65 {
66 _kind = strname
67 }
68
69 // 实现类型属性成员
70 public override string kind
71 {
72 get
73 {
74 return _kind;
75 }
76 set
77 {
78 _kind = value;
79 }
80 }
81
82 // 实现交谈方法
83 public override void talk()
84 {
85 Response.write("喔喔的叫!");
86 }
87
88 // 实现移动方法
89 public override void move()
90 {
91 Response.write("两爪行走！");
92 }
93 }
94
95
96
2 abstract class animal
3 {
4 // 定义成员
5 protected string _kind;
6
7 // 定义类型属性
8 public abstract string kind
9 {
10 get:
11 set:
12 }
13
14 // 定义交谈方法
15 public abstract void talk()
16
17 // 定义移动方法
18 public abstract void move()
19 }
20
21
22 /////////////////////////////////////////////
23
24 // 定义羊
25 abstract class sheep:animal
26 {
27 // 构造函数
28 public sheep(string strkind)
29 {
30 _kind = strkind
31 }
32
33 // 实现类型属性成员
34 public override string kind
35 {
36 get
37 {
38 return _kind;
39 }
40 set
41 {
42 _kind = value;
43 }
44 }
45
46 // 实现交谈方法
47 public override void talk()
48 {
49 Response.write("咩咩的叫!");
50 }
51
52 // 实现移动方法
53 public override void move()
54 {
55 Response.write("四蹄行走！");
56 }
57 }
58
59
60 // 定义鸡
61 abstract class chicken:animal
62 {
63 // 构造函数
64 public chicken(string strkind)
65 {
66 _kind = strname
67 }
68
69 // 实现类型属性成员
70 public override string kind
71 {
72 get
73 {
74 return _kind;
75 }
76 set
77 {
78 _kind = value;
79 }
80 }
81
82 // 实现交谈方法
83 public override void talk()
84 {
85 Response.write("喔喔的叫!");
86 }
87
88 // 实现移动方法
89 public override void move()
90 {
91 Response.write("两爪行走！");
92 }
93 }
94
95
96
比较两段代码，有没有发现其中有共同的部分，其实两个种类有相同的方法成员，（交谈和移动），我们可以把它提取出来做为接口，让所有具体有该行为的类继承该接口.
可是，慢着，如果我不提取出来，保持现在这个样子不是很好吗？ 现在看起来是没有任何问题，但是如果某一天，系统要求中国人，美国人,鸡，羊都要增加＂吃饭＂ 这个方法呢？ 以后还要增加 ＂喝水＂ ，＂高兴的表情＂.... 诸如此类，，现在只有两个抽象类还不算太坏，如果还增加其他种类，比如说：我想从动物种类中单独出来 ＂家畜类＂，＂哺乳动物类＂，＂鸟类＂.... 在这种情况下还是用这种单一的抽象类继承是非常棘手的． 这时我们可以将所有类的普遍行为归为一个接口，而将每个种类特有的行为和属性归类到一个抽象类中，这样既保持了具体类既有它的特有行为，也有共同的行为 ，具体时候之后大概会是酱紫：
1 // 人的抽象类
2 public abstract class people
3 {
4 // 人类特有的行为
5 public abstract void 劳动()
6 }
7
8 // 鸟类的抽象类
9 public abstract class Aves
10 {
11 // 鸟类动物特有的行为
12 public abstract void 飞翔()
13 }
14
15 // 公共接口
16 public interface IAction
17 {
18 // 普遍的行为
19 public void move();
20 public void talk();
21 }
22
23 /////////////////////////////////////////
24
25 // 定义中国人
26 public class Chinaman:people,IAction
27 {
28 // 实现抽象类和接口方法
29 }
30
31
32 // 定义麻雀
33 public class spadger:Aves,IAction
34 {
35 // 实现抽象类和接口方法
36 }
37
2 public abstract class people
3 {
4 // 人类特有的行为
5 public abstract void 劳动()
6 }
7
8 // 鸟类的抽象类
9 public abstract class Aves
10 {
11 // 鸟类动物特有的行为
12 public abstract void 飞翔()
13 }
14
15 // 公共接口
16 public interface IAction
17 {
18 // 普遍的行为
19 public void move();
20 public void talk();
21 }
22
23 /////////////////////////////////////////
24
25 // 定义中国人
26 public class Chinaman:people,IAction
27 {
28 // 实现抽象类和接口方法
29 }
30
31
32 // 定义麻雀
33 public class spadger:Aves,IAction
34 {
35 // 实现抽象类和接口方法
36 }
37
经过上面的改造，定义的麻雀和中国人既有自己的特殊方法，也有普遍方法，（有人说把接口定义改成抽象方法，虽然也可以，但是类继承是单一继承的，多继承好象不可以），当然，你也可以扩展你的接口，例如说你可以将 鸟类，猫科动物类共同的行为提取出来，做为一个新的接口.定义一个新类,要他包含接口中定义的所有方法,那么就继承该接口并实现它.
抽象类和接口在结构比较单一的类集合中区别不是太大，但如果系统复杂，类关系多样，利用二者，相互结合使用，会大大降低系统耦合度，也让整个系统功能更容易扩展，其内部结构也一目了然．
个人认为，抽象类注重小范围的，具有某些共性成员的成员描述，而接口，是对某些成员具有的共同行为的形态描述．它是不限范围的．
