c#简要概括面向对象的三大特征（三）

续上两篇。
三、多态
1、什么是多态
多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态实现另一个目的：接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
2、实现多态的方式
实现多态，有二种方式，覆盖（或者覆写，重写），重载。
覆盖，是指子类重新定义父类的虚函数的做法。
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
3、覆盖和重载的注意点
（1）、重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。举例来说，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！（实现多态的方式之一是重载，而“重载和多态无关”，多么奇怪的解释，自己琢磨吧。）
（2）、当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。
（3）、结论：重载只是一种语言特性，与多态无关，与面向对象也无关，因为“如果它不是晚绑定，它就不是多态“。真正和多态相关的是“覆盖”。
4、c#重载和覆盖举例
重载实例如下：

Code
using System;

interface IEat
{
    void Eat();
}

interface IRun
{
    void Run();
}

public abstract class Animal
{
    public string name;
    public Animal(string name)
    {
        this.name = name;
    }
}

/// <summary>
/// 狗继承自动物抽象类，实现吃和跑这两个接口
/// </summary>
public class Dog : Animal, IEat, IRun
{
    /* 重载，是指允许存在多个同名函数，而这些函数的参数表不同
     * （或许参数个数不同，或许参数类型不同，或许两者都不同），
     */
    public Dog(string name)
        : base(name)
    { }

    /// <summary>
    /// 1、 构造函数重载
    /// </summary>
    /// <param name="name"></param>
    /// <param name="owner"></param>
    public Dog(string name, string owner)
        : base(name)
    {

    }

    /* 狗这个类必须实现吃和跑这两个接口的方法 */
    public void Eat()
    {
        Console.WriteLine(this.name + " is eating");
    }
    public void Run()
    {
        Console.WriteLine(this.name + " is running");
    }
    /* 2、实例方法重载:带参数 */
    public void Eat(string foodName)
    {
        Console.WriteLine(this.name + " is eating:" + foodName);
    }

    /* 3、实例方法重载:参数类型不同 */
    public void Eat( DateTime dt)
    {
        Console.WriteLine(this.name + " is eating at " + dt.ToString());
    }

    /* 4、实例方法重载:参数个数和类型都不同 */
    public void Eat(string foodName,DateTime dt)
    {
        Console.WriteLine(this.name + " is eating:" + foodName+" at "+dt.ToString());
    }

    /// <summary>
    /// * 注意，返回类型不同但是函数名和参数相同不是重载，下面代码编译出错
    /// </summary>
    /// <param name="foodName"></param>
    /// <returns></returns>
    //public string Eat(string foodName)
    //{
    //    return this.name + " is eating:" + foodName;
    //}
}


public class Program
{
    static void Main()
    {
        Dog snoopy = new Dog("Snoopy");
        snoopy.Eat();
        snoopy.Run();

        Dog snoopy1 = new Dog("Snoopy", "Jeff Wong");
        snoopy1.Eat("meat");
        snoopy1.Run();

        //Console.WriteLine(snoopy1.Eat("meat"));

        Console.Read();
    }
}

覆盖的代码如下：

Code
using System;

public abstract class Animal
{
    public string name;
    public Animal(string name)
    {
        this.name = name;
    }
    /* 下面三个方法声明为虚方法，派生类根据要求可以重写 */
    public virtual void Eat()
    {
        Console.WriteLine(this.name + " is waiting to eat!");
    }
    public virtual void Run()
    {
        Console.WriteLine(this.name + " is ready to run!");
    }
    public virtual void ShowOwner()
    {
        Console.WriteLine(this.name + " has no owner!");
    }
}

/// <summary>
/// 狗继承自动物抽象类，覆盖动物抽象类中的吃，跑和显示主人的方法
/// </summary>
public class Dog : Animal
{
    public Dog(string name)
        : base(name)
    { }
    private string owner;//狗的主人
    public Dog(string name, string owner)
        : base(name)
    {
        this.owner = owner;
    }

    /// <summary>
    /// 覆盖，子类显示狗的主人
    /// </summary>
    public override void ShowOwner()
    {
        //base.DogOwner(); //父类的dog显示没有主人
        Console.WriteLine(this.name + " is " + this.owner + "'s dog");
    }
    public override void Eat()
    {
        Console.WriteLine(this.name + " is eating");
    }
    public override void Run()
    {
        Console.WriteLine(this.name + " is running");
    }
}



public class Cat : Animal
{
    public Cat(string name)
        : base(name)
    { }
    private string owner;//猫的主人
    public Cat(string name, string owner)
        : base(name)
    {
        this.owner = owner;
    }

    /// <summary>
    /// 覆盖，子类显示猫的主人
    /// </summary>
    public override void ShowOwner()
    {
        Console.WriteLine(this.name + " is " + this.owner + "'s cat");
    }

    public override void Eat()
    {
        Console.WriteLine(this.name + " is eating");
    }
    public override void Run()
    {
        //  Console.WriteLine(this.name + " is running");
        Console.WriteLine(this.name + " is very lazy,and now he is sleeping.");     
    }
}


public class Program
{
    static void Main()
    {
        Animal snoopy = new Dog("Snoopy", "Jeff Wong");
        snoopy.Eat();
        snoopy.Run();
        snoopy.ShowOwner();

        Animal garfield = new Cat("GarField", "Jeff Wong");
        garfield.Eat();
        garfield.Run();
        garfield.ShowOwner();

        Console.Read();
    }
}

关于多态可以讨论一整本书，这里只是简明扼要介绍一下，有意者可以参考其他专业资源，这里不再赘述。