深入剖析C#的多态三
在派生类中对虚方法进行重载
先让我们回顾一下普通的方法重载,普通的方法重载指的是：类中两个以上的方法（包括隐藏的继承而来的方法），取的名字相同，只要使用的参数类型或者参数个数不同，编译器便知道在何种情况下应该调用哪个方法。
而对基类虚方法的重载是函数重载的另一种特殊形式。在派生类中重新定义此虚函数时，要求的是方法名称，返回值类型、参数表中的参数个数、类型顺序都必须与基类中的虚函数完全一致。在派生类中声明对虚方法的重载，要求在声明中加上override 关键字，而且不能有new, static 或virtual 修饰符。
看一个用汽车类的例子来说明多态性的实现的程序：
分析上面的例子我们看到:
● Vehicle 类中的Speak 方法被声明为虚方法，那么在派生类中就可以重新定义此方法。
● 在派生类Car 和Truck 中分别重载了Speak 方法，派生类中的方法原型和基类中的方法原型必须完全一致。
● 在Test 类中，创建了Vehicle 类的实例v1， 并且先后指向Car 类的实例c1 和Truck 类的实例t1。
运行该程序结果应该是：
The Vehicle is speaking!
The car is speaking:Di-di!
The car is speaking:Di-di!
The truck is speaking:Ba-ba!
The truck is speaking:Ba-ba!
这里，Vehicle 类的实例v1 先后被赋予Car 类的实例c1， 以及Truck 类的实例t1的值。在执行过程中，v1 先后指代不同的类的实例，从而调用不同的版本。这里v1 的Speak 方法实现了多态性，并且v1.Speak 究竟执行哪个版本，不是在程序编译时确定的，而是在程序的动态运行时，根据v1 某一时刻的指代类型来确定的，所以还体现了动态的多态性。
四、接口多态性
多个类可实现相同的“接口”，而单个类可以实现一个或多个接口。接口本质上是类需要如何响应的定义。接口描述类需要实现的方法、属性和事件，以及每个成员需要接收和返回的参数类型，但将这些成员的特定实现留给实现类去完成。
组件编程中的一项强大技术是能够在一个对象上实现多个接口。每个接口由一小部分紧密联系的方法、属性和事件组成。通过实现接口，组件可以为要求该接口的任何其他组件提供功能，而无需考虑其中所包含的特定功能。这使后续组件的版本得以包含不同的功能而不会干扰核心功能。
其他开发人员最常使用的组件功能自然是组件类本身的成员。然而，包含大量成员的组件使用起来可能比较困难。可以考虑将组件的某些功能分解出来，作为私下实现的单独接口。
根据接口来定义功能的另一个好处是，可以通过定义和实现附加接口增量地将功能添加到组件中。优点包括：
● 简化了设计过程，因为组件开始时可以很小，具有最小功能；之后，组件继续提供最小功能，同时不断插入其他的功能，并通过实际使用那些功能来确定合适的功能。
● 简化了兼容性的维护，因为组件的新版本可以在添加新接口的同时继续提供现有接口。客户端应用程序的后续版本可以利用这些接口的优点（如果这样做有意义）。
五、继承多态性
多个类可以从单个基类“继承”。通过继承，类在基类所在的同一实现中接收基类的所有方法、属性和事件。这样，便可根据需要来实现附加成员，而且可以重写基成员以提供不同的实现。请注意，继承类也可以实现接口，这两种技术不是互斥的。
C# 通过继承提供多态性。对于小规模开发任务而言，这是一个功能强大的机制，但对于大规模系统，通常证明会存在问题。过分强调继承驱动的多态性一般会导致资源大规模地从编码转移到设计，这对于缩短总的开发时间没有任何帮助。看下面的例子：
和C++、Java相比，C#的override关键字使得阅读源代码时可以清晰地看出哪些方法是重载的。不过，使用虚方法有利有弊。第一个有利点是：避免使用虚方法轻微的提高了执行速度。第二点是可以清楚地知道哪些方法会被重载。
我们看一个关于飞机描述的类。假设我们有一个描述飞机的基类。现在，我们要完成一个飞机控制系统，有一个全局的函数fly，它负责让传递给它的飞机起飞，那么，只需要这样：
就可以让所有传给它的飞机（plane的子类对象）正常起飞！不管是直升机还是喷气机，甚至是现在还不存在的，以后会增加的飞碟。因为，每个子类都已经定义了自己的起飞方式。
可以看到 plane.fly()函数接受参数的是 plane类对象引用，而实际传递给它的都是 plane的子类对象，多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。 很显然，parent = child; 就是多态的实质！因为直升机“是一种”飞机，喷气机也“是一种”飞机，因此，所有对飞机的操作，都可以对它们操作，此时，飞机类就作为一种接口。多态的本质就是将子类类型的指针赋值给父类类型的指针（在OP中是引用），只要这样的赋值发生了，多态也就产生了，因为实行了“向上映射”。
先让我们回顾一下普通的方法重载,普通的方法重载指的是：类中两个以上的方法（包括隐藏的继承而来的方法），取的名字相同，只要使用的参数类型或者参数个数不同，编译器便知道在何种情况下应该调用哪个方法。
而对基类虚方法的重载是函数重载的另一种特殊形式。在派生类中重新定义此虚函数时，要求的是方法名称，返回值类型、参数表中的参数个数、类型顺序都必须与基类中的虚函数完全一致。在派生类中声明对虚方法的重载，要求在声明中加上override 关键字，而且不能有new, static 或virtual 修饰符。
看一个用汽车类的例子来说明多态性的实现的程序：
using System ;
class Vehicle//定义汽车类
{
public int wheels; //公有成员轮子个数
protected float weight; //保护成员重量
public Vehicle(int w,float g)
{
wheels = w;
weight = g;
}
public virtual void Speak( )
{
Console.WriteLine( " the w vehicle is speaking!" ) ;
}
};
class Car:Vehicle //定义轿车类
{
int passengers; //私有成员乘客数
public Car(int w,float g,int p) : base(w,g)
{
wheels = w;
weight = g;
passengers = p;
}
public override void Speak( )
{
Console.WriteLine( " The car is speaking:Di-di!" ) ;
}
}
class Truck:Vehicle //定义卡车类
{
int passengers; //私有成员乘客数
float load; //私有成员载重量
public Truck (int w,float g,int p, float l) : base(w,g)
{
wheels = w;
weight = g;
passengers = p;
load = l;
}
public override void Speak( )
{
Console.WriteLine( " The truck is speaking:Ba-ba!" ) ;
}
public static void Main( )
{
Vehicle v1 = new Vehicle(0,0 ) ;
Car c1 = new Car(4,2,5) ;
Truck t1 = new Truck(6,5,3,10) ;
v1.Speak( ) ;
v1 = c1;
v1.Speak( ) ;
c1.Speak( ) ;
v1 = t1;
v1.Speak( ) ;
t1.Speak( ) ;
}
}
class Vehicle//定义汽车类
{
public int wheels; //公有成员轮子个数
protected float weight; //保护成员重量
public Vehicle(int w,float g)
{
wheels = w;
weight = g;
}
public virtual void Speak( )
{
Console.WriteLine( " the w vehicle is speaking!" ) ;
}
};
class Car:Vehicle //定义轿车类
{
int passengers; //私有成员乘客数
public Car(int w,float g,int p) : base(w,g)
{
wheels = w;
weight = g;
passengers = p;
}
public override void Speak( )
{
Console.WriteLine( " The car is speaking:Di-di!" ) ;
}
}
class Truck:Vehicle //定义卡车类
{
int passengers; //私有成员乘客数
float load; //私有成员载重量
public Truck (int w,float g,int p, float l) : base(w,g)
{
wheels = w;
weight = g;
passengers = p;
load = l;
}
public override void Speak( )
{
Console.WriteLine( " The truck is speaking:Ba-ba!" ) ;
}
public static void Main( )
{
Vehicle v1 = new Vehicle(0,0 ) ;
Car c1 = new Car(4,2,5) ;
Truck t1 = new Truck(6,5,3,10) ;
v1.Speak( ) ;
v1 = c1;
v1.Speak( ) ;
c1.Speak( ) ;
v1 = t1;
v1.Speak( ) ;
t1.Speak( ) ;
}
}
分析上面的例子我们看到:
● Vehicle 类中的Speak 方法被声明为虚方法，那么在派生类中就可以重新定义此方法。
● 在派生类Car 和Truck 中分别重载了Speak 方法，派生类中的方法原型和基类中的方法原型必须完全一致。
● 在Test 类中，创建了Vehicle 类的实例v1， 并且先后指向Car 类的实例c1 和Truck 类的实例t1。
运行该程序结果应该是：
The Vehicle is speaking!
The car is speaking:Di-di!
The car is speaking:Di-di!
The truck is speaking:Ba-ba!
The truck is speaking:Ba-ba!
这里，Vehicle 类的实例v1 先后被赋予Car 类的实例c1， 以及Truck 类的实例t1的值。在执行过程中，v1 先后指代不同的类的实例，从而调用不同的版本。这里v1 的Speak 方法实现了多态性，并且v1.Speak 究竟执行哪个版本，不是在程序编译时确定的，而是在程序的动态运行时，根据v1 某一时刻的指代类型来确定的，所以还体现了动态的多态性。
四、接口多态性
多个类可实现相同的“接口”，而单个类可以实现一个或多个接口。接口本质上是类需要如何响应的定义。接口描述类需要实现的方法、属性和事件，以及每个成员需要接收和返回的参数类型，但将这些成员的特定实现留给实现类去完成。
组件编程中的一项强大技术是能够在一个对象上实现多个接口。每个接口由一小部分紧密联系的方法、属性和事件组成。通过实现接口，组件可以为要求该接口的任何其他组件提供功能，而无需考虑其中所包含的特定功能。这使后续组件的版本得以包含不同的功能而不会干扰核心功能。
其他开发人员最常使用的组件功能自然是组件类本身的成员。然而，包含大量成员的组件使用起来可能比较困难。可以考虑将组件的某些功能分解出来，作为私下实现的单独接口。
根据接口来定义功能的另一个好处是，可以通过定义和实现附加接口增量地将功能添加到组件中。优点包括：
● 简化了设计过程，因为组件开始时可以很小，具有最小功能；之后，组件继续提供最小功能，同时不断插入其他的功能，并通过实际使用那些功能来确定合适的功能。
● 简化了兼容性的维护，因为组件的新版本可以在添加新接口的同时继续提供现有接口。客户端应用程序的后续版本可以利用这些接口的优点（如果这样做有意义）。
五、继承多态性
多个类可以从单个基类“继承”。通过继承，类在基类所在的同一实现中接收基类的所有方法、属性和事件。这样，便可根据需要来实现附加成员，而且可以重写基成员以提供不同的实现。请注意，继承类也可以实现接口，这两种技术不是互斥的。
C# 通过继承提供多态性。对于小规模开发任务而言，这是一个功能强大的机制，但对于大规模系统，通常证明会存在问题。过分强调继承驱动的多态性一般会导致资源大规模地从编码转移到设计，这对于缩短总的开发时间没有任何帮助。看下面的例子：
class B
{ public virtual void foo () {} }
class D : B
{
public override void foo () {}
}
//试图重载一个非虚的方法将会导致一个编译时错误，除非对该方法加上“new”关键字，//以指明该方法意欲隐藏父类的方法。
class N : D
{
public new void foo () {}
public static void Main() {
N n = new N ();
n.foo( ) ; // 调用N的foo
((D)n).foo( ) ; // 调用D的foo
((B)n).foo( ) ; // 调用D的foo
}
}
{ public virtual void foo () {} }
class D : B
{
public override void foo () {}
}
//试图重载一个非虚的方法将会导致一个编译时错误，除非对该方法加上“new”关键字，//以指明该方法意欲隐藏父类的方法。
class N : D
{
public new void foo () {}
public static void Main() {
N n = new N ();
n.foo( ) ; // 调用N的foo
((D)n).foo( ) ; // 调用D的foo
((B)n).foo( ) ; // 调用D的foo
}
}
和C++、Java相比，C#的override关键字使得阅读源代码时可以清晰地看出哪些方法是重载的。不过，使用虚方法有利有弊。第一个有利点是：避免使用虚方法轻微的提高了执行速度。第二点是可以清楚地知道哪些方法会被重载。
我们看一个关于飞机描述的类。假设我们有一个描述飞机的基类。现在，我们要完成一个飞机控制系统，有一个全局的函数fly，它负责让传递给它的飞机起飞，那么，只需要这样：
using System ;
class plane
{
public virtual void fly(){} //起飞纯虚函数
public virtual void land() {} //着陆纯虚函数
public virtual string modal(){} //查寻型号纯虚函数
}
// 然后，我们从plane派生出两个子类，直升机（copter）和喷气式飞机（jet）：
class copter:plane
{
private String fModal ;
public override void fly(){}
public override void land(){}
public override string modal(){}
}
class jet : plane
{
private String fModal ;
public override void fly(){}
public override void land(){}
public override string modal{}
}
class plane
{
public virtual void fly(){} //起飞纯虚函数
public virtual void land() {} //着陆纯虚函数
public virtual string modal(){} //查寻型号纯虚函数
}
// 然后，我们从plane派生出两个子类，直升机（copter）和喷气式飞机（jet）：
class copter:plane
{
private String fModal ;
public override void fly(){}
public override void land(){}
public override string modal(){}
}
class jet : plane
{
private String fModal ;
public override void fly(){}
public override void land(){}
public override string modal{}
}
就可以让所有传给它的飞机（plane的子类对象）正常起飞！不管是直升机还是喷气机，甚至是现在还不存在的，以后会增加的飞碟。因为，每个子类都已经定义了自己的起飞方式。
可以看到 plane.fly()函数接受参数的是 plane类对象引用，而实际传递给它的都是 plane的子类对象，多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。 很显然，parent = child; 就是多态的实质！因为直升机“是一种”飞机，喷气机也“是一种”飞机，因此，所有对飞机的操作，都可以对它们操作，此时，飞机类就作为一种接口。多态的本质就是将子类类型的指针赋值给父类类型的指针（在OP中是引用），只要这样的赋值发生了，多态也就产生了，因为实行了“向上映射”。
