[1][
2] [
3]
1。。。。。。。。。。。。。。。。
2。。。。。。。。。。。。。。。。。。 top
3。。。。。。。。。。。。。。。。。 top
4..............................................................
1。。。。。。。。。。。。。。。。
好象这是一个老生常谈的问题,最近有个学生问我他们的区别,于是我就又想起这个话题。
有不少的文章在描述这两者,但好象都没有怎么从初学者的浅显角度来看。
其实这两者有很多相识之处,当然也有很多不同之处。要理解它们,应该先从面向对象思想开始。面向对象思想里面,最基本的就是封装,继承和多态。所谓封装,说的小,方法(函数)也就是对一种操作的封装,说的大,用类来描述一个具体的对象。
那么在面向对象程序中应该说对封装还有一层新的定义,即将类的描述抽象化,也就是说描述类的外貌而不去考虑它的实际。
那么我们回过头来看抽象类,它必须被继承使用,描述的其实是一种继承关系,即 " is a " 的关系。类继承它,也就是说类拥有它所有抽象方法等,那么也就是类遵循了它所定义的规范。但是呢,这种规范是通过继承而来,类的发展必须依赖它的父类。
abstract class 工作
{
abstract void 上班()
}
class 张三 : 工作 {}
abstract class 工作
{
abstract void 上班()
}
class 人: 工作 {}
class 李四 : 人 {}
我们从这个例子中不难看出,张三和李四同样都遵循抽象工作的规范,都拥有上班这个方法,但是呢,他们的发展始终受到父类的影响。
当然,我这里只是从它们使用的角度来看,我们还能从他们设计角度度来看。上面我们虽然实现了人.上班()的过程,但是,这却违反了面向对象设计中的一个核心原则ISP(Interface Segregation Priciple),我们把李四的作为人的行为和他工作的行为混在一起。
那我们再来看看接口( interface ),引用航天奇侠兄的一句话,接口,就是一个类的函数规范。 一个类 “继承”一个接口,等于说这个类必须提供接口所要求的所有函数。但是呢他们是一种实现关系,虽然在C#里我们还叫它为继承接口,但实际它是一种 " like a " 的关系。
interface 工作
{
public void 上班();
}
class 张三 : 工作 {}
interface 工作
{
public void 上班();
}
class 人 {}
class 李四 : 人,工作 {}
interface 工作
{
public void 上班();
}
class 动物 {}
class 人 : 动物 {}
class 王五 : 人,工作 {}
此时我们来看,张三和李四同样遵循着interface工作所定义的规范,但是呢,他们(类)的发展并不受到父类的影响,张三、李四、王五都可以自由的发展自身类,具备有很高的自由度,我们再来从面向对象设计角度看,李四、王五继承人(因为他本质就是人),实现了工作。
应该说,接口的使用面比抽象类更广一些,而抽象类呢比接口更具限制性,体现的是继承关系。
当类的发展不需要受到限制和约束时,我们可以使用接口,此类可以自由的发展,此时继承接口的这个类它就是一个稳定的类,这也体现了接口保持类的稳定性。
这两者具备有很大的相似性,都源直面向对象思想,在使用何时抽象类,何时接口并没有一个定论,应该根据自己程序的大小,设计的方式,程序发展的空间来看,这就需要大家自己斟酌了。
有不少的文章在描述这两者,但好象都没有怎么从初学者的浅显角度来看。
其实这两者有很多相识之处,当然也有很多不同之处。要理解它们,应该先从面向对象思想开始。面向对象思想里面,最基本的就是封装,继承和多态。所谓封装,说的小,方法(函数)也就是对一种操作的封装,说的大,用类来描述一个具体的对象。
那么在面向对象程序中应该说对封装还有一层新的定义,即将类的描述抽象化,也就是说描述类的外貌而不去考虑它的实际。
那么我们回过头来看抽象类,它必须被继承使用,描述的其实是一种继承关系,即 " is a " 的关系。类继承它,也就是说类拥有它所有抽象方法等,那么也就是类遵循了它所定义的规范。但是呢,这种规范是通过继承而来,类的发展必须依赖它的父类。
abstract class 工作
{
abstract void 上班()
}
class 张三 : 工作 {}
abstract class 工作
{
abstract void 上班()
}
class 人: 工作 {}
class 李四 : 人 {}
我们从这个例子中不难看出,张三和李四同样都遵循抽象工作的规范,都拥有上班这个方法,但是呢,他们的发展始终受到父类的影响。
当然,我这里只是从它们使用的角度来看,我们还能从他们设计角度度来看。上面我们虽然实现了人.上班()的过程,但是,这却违反了面向对象设计中的一个核心原则ISP(Interface Segregation Priciple),我们把李四的作为人的行为和他工作的行为混在一起。
那我们再来看看接口( interface ),引用航天奇侠兄的一句话,接口,就是一个类的函数规范。 一个类 “继承”一个接口,等于说这个类必须提供接口所要求的所有函数。但是呢他们是一种实现关系,虽然在C#里我们还叫它为继承接口,但实际它是一种 " like a " 的关系。
interface 工作
{
public void 上班();
}
class 张三 : 工作 {}
interface 工作
{
public void 上班();
}
class 人 {}
class 李四 : 人,工作 {}
interface 工作
{
public void 上班();
}
class 动物 {}
class 人 : 动物 {}
class 王五 : 人,工作 {}
此时我们来看,张三和李四同样遵循着interface工作所定义的规范,但是呢,他们(类)的发展并不受到父类的影响,张三、李四、王五都可以自由的发展自身类,具备有很高的自由度,我们再来从面向对象设计角度看,李四、王五继承人(因为他本质就是人),实现了工作。
应该说,接口的使用面比抽象类更广一些,而抽象类呢比接口更具限制性,体现的是继承关系。
当类的发展不需要受到限制和约束时,我们可以使用接口,此类可以自由的发展,此时继承接口的这个类它就是一个稳定的类,这也体现了接口保持类的稳定性。
这两者具备有很大的相似性,都源直面向对象思想,在使用何时抽象类,何时接口并没有一个定论,应该根据自己程序的大小,设计的方式,程序发展的空间来看,这就需要大家自己斟酌了。
2。。。。。。。。。。。。。。。。。。 top
抽象方法是必须实现的方法。就象动物都要呼吸。但是鱼用鳃呼吸,猪用肺呼吸。
动物类要有呼吸方法。怎么呼吸就是子类的事了。
现在有很多讨论和建议提倡用interface代替abstract类,两者从理论上可以做一般性的混用,但是在实际应用中,他们还是有一定区别的。抽象类一般作为公共的父类为子类的扩展提供基础,这里的扩展包括了属性上和行为上的。而接口一般来说不考虑属性,只考虑方法,使得子类可以自由的填补或者扩展接口所定义的方法,就像JAVA王子所说的事件中的适配器就是一个很好的应用。
用一个简单的例子,比如说一个教师,我们把它作为一个抽象类,有自己的属性,比如说年龄,教育程度,教师编号等等,而教师也是分很多种类的,我们就可以继承教师类而扩展特有的种类属性,而普遍属性已经直接继承了下来。
而接口呢~还是拿教师做例子,教师的行为很多,除了和普通人相同的以外,还有职业相关的行为,比如改考卷,讲课等等,我们把这些行为定义成无body的方法,作为一个集合,它是一个interface。而教师张三李四的各自行为特点又有不同,那么他们就可以扩展自己的行为body。从这点意义上来说, interface偏重于行为。
总之,在许多情况下,接口确实可以代替抽象类,如果你不需要刻意表达属性上的继承的话。
动物类要有呼吸方法。怎么呼吸就是子类的事了。
现在有很多讨论和建议提倡用interface代替abstract类,两者从理论上可以做一般性的混用,但是在实际应用中,他们还是有一定区别的。抽象类一般作为公共的父类为子类的扩展提供基础,这里的扩展包括了属性上和行为上的。而接口一般来说不考虑属性,只考虑方法,使得子类可以自由的填补或者扩展接口所定义的方法,就像JAVA王子所说的事件中的适配器就是一个很好的应用。
用一个简单的例子,比如说一个教师,我们把它作为一个抽象类,有自己的属性,比如说年龄,教育程度,教师编号等等,而教师也是分很多种类的,我们就可以继承教师类而扩展特有的种类属性,而普遍属性已经直接继承了下来。
而接口呢~还是拿教师做例子,教师的行为很多,除了和普通人相同的以外,还有职业相关的行为,比如改考卷,讲课等等,我们把这些行为定义成无body的方法,作为一个集合,它是一个interface。而教师张三李四的各自行为特点又有不同,那么他们就可以扩展自己的行为body。从这点意义上来说, interface偏重于行为。
总之,在许多情况下,接口确实可以代替抽象类,如果你不需要刻意表达属性上的继承的话。
3。。。。。。。。。。。。。。。。。 top
本文将介绍以下内容:
• 面向对象思想:多态
• 接口
• 抽象类
1. 引言
在我之前的一篇post《抽象类和接口的谁是谁非》中,和同事管伟的讨论,得到很多朋友的关注,因为是不成体系的论道,所以给大家了解造成不便,同时关于这个主题的系统性理论,我认为也有必要做以总结,因此才有了本篇的新鲜出炉。同时,我将把上贴中的问题顺便也在此做以交代。
2. 概念引入
* 什么是接口?
接口是包含一组虚方法的抽象类型,其中每一种方法都有其名称、参数和返回值。接口方法不能包含任何实现,CLR允许接口可以包含事件、属性、索引器、静态方法、静态字段、静态构造函数以及常数。但是注意:C#中不能包含任何静态成员。一个类可以实现多个接口,当一个类继承某个接口时,它不仅要实现该接口定义的所有方法,还要实现该接口从其他接口中继承的所有方法。
定义方法为:
public interface System.IComparable
{
int CompareTo(object o);
}
public class TestCls: IComparable
{
public TestCls()
{
}
private int _value;
public int Value
{
get { return _value; }
set { _value = value; }
}
public int CompareTo(object o)
{
//使用as模式进行转型判断
TestCls aCls = o as TestCls;
if (aCls != null)
{
//实现抽象方法
return _value.CompareTo(aCls._value);
}
}
}
* 什么是抽象类?
抽象类提供多个派生类共享基类的公共定义,它既可以提供抽象方法,也可以提供非抽象方法。抽象类不能实例化,必须通过继承由派生类实现其抽象方法,因此对抽象类不能使用new关键字,也不能被密封。如果派生类没有实现所有的抽象方法,则该派生类也必须声明为抽象类。另外,实现抽象方法由 overriding方法来实现。
定义方法为:
/// < summary >
/// 定义抽象类
/// </ summary >
abstract public class Animal
{
//定义静态字段
static protected int _id;
//定义属性
public abstract static int Id
{
get;
set;
}
//定义方法
public abstract void Eat();
//定义索引器
public string this[int i]
{
get;
set;
}
}
/// < summary >
/// 实现抽象类
/// </ summary >
public class Dog: Animal
{
public static override int Id
{
get {return _id;}
set {_id = value;}
}
public override void Eat()
{
Console.Write("Dog Eats.")
}
}
3. 相同点和不同点
3.1 相同点
* 都不能被直接实例化,都可以通过继承实现其抽象方法。
* 都是面向抽象编程的技术基础,实现了诸多的设计模式。
3.2 不同点
* 接口支持多继承;抽象类不能实现多继承。
* 接口只能定义抽象规则;抽象类既可以定义规则,还可能提供已实现的成员。
* 接口是一组行为规范;抽象类是一个不完全的类,着重族的概念。
* 接口可以用于支持回调;抽象类不能实现回调,因为继承不支持。
* 接口只包含方法、属性、索引器、事件的签名,但不能定义字段和包含实现的方法;抽象类可以定义字段、属性、包含有实现的方法。
* 接口可以作用于值类型和引用类型;抽象类只能作用于引用类型。例如,Struct就可以继承接口,而不能继承类。
通过相同与不同的比较,我们只能说接口和抽象类,各有所长,但无优略。在实际的编程实践中,我们要视具体情况来酌情量才,但是以下的经验和积累,或许能给大家一些启示,除了我的一些积累之外,很多都来源于经典,我相信经得起考验。所以在规则与场合中,我们学习这些经典,最重要的是学以致用,当然我将以一家之言博大家之笑,看官请继续。
3.3 规则与场合
1. 请记住,面向对象思想的一个最重要的原则就是:面向接口编程。
2. 借助接口和抽象类,23个设计模式中的很多思想被巧妙的实现了,我认为其精髓简单说来就是:面向抽象编程。
3. 抽象类应主要用于关系密切的对象,而接口最适合为不相关的类提供通用功能。
4. 接口着重于CAN-DO关系类型,而抽象类则偏重于IS-A式的关系;
5. 接口多定义对象的行为;抽象类多定义对象的属性;
6. 接口定义可以使用public、protected、internal 和private修饰符,但是几乎所有的接口都定义为public,原因就不必多说了。
7. “接口不变”,是应该考虑的重要因素。所以,在由接口增加扩展时,应该增加新的接口,而不能更改现有接口。
8. 尽量将接口设计成功能单一的功能块,以.NET Framework为例,IDisposable、IDisposable、IComparable、IEquatable、IEnumerable等都只包含一个公共方法。
9. 接口名称前面的大写字母“I”是一个约定,正如字段名以下划线开头一样,请坚持这些原则。
10. 在接口中,所有的方法都默认为public。
11. 如果预计会出现版本问题,可以创建“抽象类”。例如,创建了狗(Dog)、鸡(Chicken)和鸭(Duck),那么应该考虑抽象出动物(Animal)来应对以后可能出现风马牛的事情。而向接口中添加新成员则会强制要求修改所有派生类,并重新编译,所以版本式的问题最好以抽象类来实现。
12. 从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实实现。
13. 对抽象类不能使用new关键字,也不能被密封,原因是抽象类不能被实例化。
14. 在抽象方法声明中不能使用 static 或 virtual 修饰符。
以上的规则,我就厚颜无耻的暂定为T14条吧,写的这么累,就当一时的奖赏吧。大家也可以互通有无,我将及时修订。
4. 经典示例
4.1 绝对经典
.NET Framework是学习的最好资源,有意识的研究FCL是每个.NET程序员的必修课,关于接口和抽象类在FCL中的使用,我有以下的建议:
1. FCL对集合类使用了基于接口的设计,所以请关注System.Collections中关于接口的设计实现;
2. FCL对数据流相关类使用了基于抽象类的设计,所以请关注System.IO.Stream类的抽象类设计机制。
4.2 别样小菜
下面的实例,因为是我的理解,因此给经典打上“相对”的记号,至于什么时候晋升为“绝对”,就看我在.NET追求的路上,是否能够一如既往的如此执着,因此我将把相对重构到绝对为止(呵呵)。本示例没有阐述抽象类和接口在设计模式中的应用,因为那将是另一篇有讨论价值的文本,本文着眼与概念和原则的把握,但是真正的应用来自于具体的需求规范。
设计结构如图所示:
1. 定义抽象类
public abstract class Animal
{
protected string _name;
//声明抽象属性
public abstract string Name
{
get;
}
//声明抽象方法
public abstract void Show();
//实现一般方法
public void MakeVoice()
{
Console.WriteLine("All animals can make voice!");
}
}
2. 定义接口
public interface IAction
{
//定义公共方法标签
void Move();
}
3. 实现抽象类和接口
public class Duck : Animal, IAction
{
public Duck(string name)
{
_name = name;
}
//重载抽象方法
public override void Show()
{
Console.WriteLine(_name + " is showing for you.");
}
//重载抽象属性
public override string Name
{
get { return _name;}
}
//实现接口方法
public void Move()
{
Console.WriteLine("Duck also can swim.");
}
}
public class Dog : Animal, IAction
{
public Dog(string name)
{
_name = name;
}
public override void Show()
{
Console.WriteLine(_name + " is showing for you.");
}
public override string Name
{
get { return _name; }
}
public void Move()
{
Console.WriteLine(_name + " also can run.");
}
}
4. 客户端实现
public class TestAnmial
{
public static void Main(string [] args)
{
Animal duck = new Duck("Duck");
duck.MakeVoice();
duck.Show();
Animal dog = new Dog("Dog");
dog.MakeVoice();
dog.Show();
IAction dogAction = new Dog("A big dog");
dogAction.Move();
}
}
5. 他山之石
正所谓真理是大家看出来的,所以将园子里有创新性的观点潜列于此,一是感谢大家的共享,二是完善一家之言的不足,希望能够将领域形成知识,受用于我,受用于众。
* dunai认为:抽象类是提取具体类的公因式,而接口是为了将一些不相关的类“杂凑”成一个共同的群体。至于他们在各个语言中的句法,语言细节并不是我关心的重点。
* 桦山涧的收藏也很不错。
* Artech认为:所代码共用和可扩展性考虑,尽量使用Abstract Class。当然接口在其他方面的优势,我认为也不可忽视。
* shenfx认为:当在差异较大的对象间寻求功能上的共性时,使用接口;当在共性较多的对象间寻求功能上的差异时,使用抽象基类。
最后,MSDN的建议是:
* 如果预计要创建组件的多个版本,则创建抽象类。抽象类提供简单易行的方法来控制组件版本。通过更新基类,所有继承类都随更改自动更新。另一方面,接口一旦创建就不能更改。如果需要接口的新版本,必须创建一个全新的接口。
* 如果创建的功能将在大范围的全异对象间使用,则使用接口。抽象类应主要用于关系密切的对象,而接口最适合为不相关的类提供通用功能。
* 如果要设计小而简练的功能块,则使用接口。如果要设计大的功能单元,则使用抽象类。
* 如果要在组件的所有实现间提供通用的已实现功能,则使用抽象类。抽象类允许部分实现类,而接口不包含任何成员的实现。
6. 结论
接口和抽象类,是论坛上、课堂间讨论最多的话题之一,之所以将这个老话题拿出来再议,是因为从我的体会来说,深刻的理解这两个面向对象的基本内容,对于盘活面向对象的抽象化编程思想至关重要。本文基本概况了接口和抽象类的概念、异同和使用规则,从学习的观点来看,我认为这些总结已经足以表达其核心。但是,对于面向对象和软件设计的深入理解,还是建立在不断实践的基础上,Scott说自己每天坚持一个小时用来写Demo,那么我们是不是更应该勤于键盘呢。对于接口和抽象类,请多用而知其然,多想而知其奥吧
• 面向对象思想:多态
• 接口
• 抽象类
1. 引言
在我之前的一篇post《抽象类和接口的谁是谁非》中,和同事管伟的讨论,得到很多朋友的关注,因为是不成体系的论道,所以给大家了解造成不便,同时关于这个主题的系统性理论,我认为也有必要做以总结,因此才有了本篇的新鲜出炉。同时,我将把上贴中的问题顺便也在此做以交代。
2. 概念引入
* 什么是接口?
接口是包含一组虚方法的抽象类型,其中每一种方法都有其名称、参数和返回值。接口方法不能包含任何实现,CLR允许接口可以包含事件、属性、索引器、静态方法、静态字段、静态构造函数以及常数。但是注意:C#中不能包含任何静态成员。一个类可以实现多个接口,当一个类继承某个接口时,它不仅要实现该接口定义的所有方法,还要实现该接口从其他接口中继承的所有方法。
定义方法为:
public interface System.IComparable
{
int CompareTo(object o);
}
public class TestCls: IComparable
{
public TestCls()
{
}
private int _value;
public int Value
{
get { return _value; }
set { _value = value; }
}
public int CompareTo(object o)
{
//使用as模式进行转型判断
TestCls aCls = o as TestCls;
if (aCls != null)
{
//实现抽象方法
return _value.CompareTo(aCls._value);
}
}
}
* 什么是抽象类?
抽象类提供多个派生类共享基类的公共定义,它既可以提供抽象方法,也可以提供非抽象方法。抽象类不能实例化,必须通过继承由派生类实现其抽象方法,因此对抽象类不能使用new关键字,也不能被密封。如果派生类没有实现所有的抽象方法,则该派生类也必须声明为抽象类。另外,实现抽象方法由 overriding方法来实现。
定义方法为:
/// < summary >
/// 定义抽象类
/// </ summary >
abstract public class Animal
{
//定义静态字段
static protected int _id;
//定义属性
public abstract static int Id
{
get;
set;
}
//定义方法
public abstract void Eat();
//定义索引器
public string this[int i]
{
get;
set;
}
}
/// < summary >
/// 实现抽象类
/// </ summary >
public class Dog: Animal
{
public static override int Id
{
get {return _id;}
set {_id = value;}
}
public override void Eat()
{
Console.Write("Dog Eats.")
}
}
3. 相同点和不同点
3.1 相同点
* 都不能被直接实例化,都可以通过继承实现其抽象方法。
* 都是面向抽象编程的技术基础,实现了诸多的设计模式。
3.2 不同点
* 接口支持多继承;抽象类不能实现多继承。
* 接口只能定义抽象规则;抽象类既可以定义规则,还可能提供已实现的成员。
* 接口是一组行为规范;抽象类是一个不完全的类,着重族的概念。
* 接口可以用于支持回调;抽象类不能实现回调,因为继承不支持。
* 接口只包含方法、属性、索引器、事件的签名,但不能定义字段和包含实现的方法;抽象类可以定义字段、属性、包含有实现的方法。
* 接口可以作用于值类型和引用类型;抽象类只能作用于引用类型。例如,Struct就可以继承接口,而不能继承类。
通过相同与不同的比较,我们只能说接口和抽象类,各有所长,但无优略。在实际的编程实践中,我们要视具体情况来酌情量才,但是以下的经验和积累,或许能给大家一些启示,除了我的一些积累之外,很多都来源于经典,我相信经得起考验。所以在规则与场合中,我们学习这些经典,最重要的是学以致用,当然我将以一家之言博大家之笑,看官请继续。
3.3 规则与场合
1. 请记住,面向对象思想的一个最重要的原则就是:面向接口编程。
2. 借助接口和抽象类,23个设计模式中的很多思想被巧妙的实现了,我认为其精髓简单说来就是:面向抽象编程。
3. 抽象类应主要用于关系密切的对象,而接口最适合为不相关的类提供通用功能。
4. 接口着重于CAN-DO关系类型,而抽象类则偏重于IS-A式的关系;
5. 接口多定义对象的行为;抽象类多定义对象的属性;
6. 接口定义可以使用public、protected、internal 和private修饰符,但是几乎所有的接口都定义为public,原因就不必多说了。
7. “接口不变”,是应该考虑的重要因素。所以,在由接口增加扩展时,应该增加新的接口,而不能更改现有接口。
8. 尽量将接口设计成功能单一的功能块,以.NET Framework为例,IDisposable、IDisposable、IComparable、IEquatable、IEnumerable等都只包含一个公共方法。
9. 接口名称前面的大写字母“I”是一个约定,正如字段名以下划线开头一样,请坚持这些原则。
10. 在接口中,所有的方法都默认为public。
11. 如果预计会出现版本问题,可以创建“抽象类”。例如,创建了狗(Dog)、鸡(Chicken)和鸭(Duck),那么应该考虑抽象出动物(Animal)来应对以后可能出现风马牛的事情。而向接口中添加新成员则会强制要求修改所有派生类,并重新编译,所以版本式的问题最好以抽象类来实现。
12. 从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实实现。
13. 对抽象类不能使用new关键字,也不能被密封,原因是抽象类不能被实例化。
14. 在抽象方法声明中不能使用 static 或 virtual 修饰符。
以上的规则,我就厚颜无耻的暂定为T14条吧,写的这么累,就当一时的奖赏吧。大家也可以互通有无,我将及时修订。
4. 经典示例
4.1 绝对经典
.NET Framework是学习的最好资源,有意识的研究FCL是每个.NET程序员的必修课,关于接口和抽象类在FCL中的使用,我有以下的建议:
1. FCL对集合类使用了基于接口的设计,所以请关注System.Collections中关于接口的设计实现;
2. FCL对数据流相关类使用了基于抽象类的设计,所以请关注System.IO.Stream类的抽象类设计机制。
4.2 别样小菜
下面的实例,因为是我的理解,因此给经典打上“相对”的记号,至于什么时候晋升为“绝对”,就看我在.NET追求的路上,是否能够一如既往的如此执着,因此我将把相对重构到绝对为止(呵呵)。本示例没有阐述抽象类和接口在设计模式中的应用,因为那将是另一篇有讨论价值的文本,本文着眼与概念和原则的把握,但是真正的应用来自于具体的需求规范。
设计结构如图所示:
1. 定义抽象类
public abstract class Animal
{
protected string _name;
//声明抽象属性
public abstract string Name
{
get;
}
//声明抽象方法
public abstract void Show();
//实现一般方法
public void MakeVoice()
{
Console.WriteLine("All animals can make voice!");
}
}
2. 定义接口
public interface IAction
{
//定义公共方法标签
void Move();
}
3. 实现抽象类和接口
public class Duck : Animal, IAction
{
public Duck(string name)
{
_name = name;
}
//重载抽象方法
public override void Show()
{
Console.WriteLine(_name + " is showing for you.");
}
//重载抽象属性
public override string Name
{
get { return _name;}
}
//实现接口方法
public void Move()
{
Console.WriteLine("Duck also can swim.");
}
}
public class Dog : Animal, IAction
{
public Dog(string name)
{
_name = name;
}
public override void Show()
{
Console.WriteLine(_name + " is showing for you.");
}
public override string Name
{
get { return _name; }
}
public void Move()
{
Console.WriteLine(_name + " also can run.");
}
}
4. 客户端实现
public class TestAnmial
{
public static void Main(string [] args)
{
Animal duck = new Duck("Duck");
duck.MakeVoice();
duck.Show();
Animal dog = new Dog("Dog");
dog.MakeVoice();
dog.Show();
IAction dogAction = new Dog("A big dog");
dogAction.Move();
}
}
5. 他山之石
正所谓真理是大家看出来的,所以将园子里有创新性的观点潜列于此,一是感谢大家的共享,二是完善一家之言的不足,希望能够将领域形成知识,受用于我,受用于众。
* dunai认为:抽象类是提取具体类的公因式,而接口是为了将一些不相关的类“杂凑”成一个共同的群体。至于他们在各个语言中的句法,语言细节并不是我关心的重点。
* 桦山涧的收藏也很不错。
* Artech认为:所代码共用和可扩展性考虑,尽量使用Abstract Class。当然接口在其他方面的优势,我认为也不可忽视。
* shenfx认为:当在差异较大的对象间寻求功能上的共性时,使用接口;当在共性较多的对象间寻求功能上的差异时,使用抽象基类。
最后,MSDN的建议是:
* 如果预计要创建组件的多个版本,则创建抽象类。抽象类提供简单易行的方法来控制组件版本。通过更新基类,所有继承类都随更改自动更新。另一方面,接口一旦创建就不能更改。如果需要接口的新版本,必须创建一个全新的接口。
* 如果创建的功能将在大范围的全异对象间使用,则使用接口。抽象类应主要用于关系密切的对象,而接口最适合为不相关的类提供通用功能。
* 如果要设计小而简练的功能块,则使用接口。如果要设计大的功能单元,则使用抽象类。
* 如果要在组件的所有实现间提供通用的已实现功能,则使用抽象类。抽象类允许部分实现类,而接口不包含任何成员的实现。
6. 结论
接口和抽象类,是论坛上、课堂间讨论最多的话题之一,之所以将这个老话题拿出来再议,是因为从我的体会来说,深刻的理解这两个面向对象的基本内容,对于盘活面向对象的抽象化编程思想至关重要。本文基本概况了接口和抽象类的概念、异同和使用规则,从学习的观点来看,我认为这些总结已经足以表达其核心。但是,对于面向对象和软件设计的深入理解,还是建立在不断实践的基础上,Scott说自己每天坚持一个小时用来写Demo,那么我们是不是更应该勤于键盘呢。对于接口和抽象类,请多用而知其然,多想而知其奥吧
4..............................................................