类的关系（多态转载）

我是这样理解多态的，一个人，在不同的场合下，有不同的身份，不同的状态。比如在家里，你是你父母的孩子，在学校，你就是学生，在公司你就是老板的职员。这就是多态。

多态的定义：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。

C#支持两种类型的多态性：
1.编译时的多态性
　　编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、

返回的类型等信息决定实现何种操作。

2.运行时的多态性
　　运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C#中，运行时的多

态性通过虚成员实现。

　　编译时的多态性为我们提供了运行速度快的特点，而运行时的多态性则带来了高度灵活和抽象的

特点。

B.实现多态(多态性允许对类的某个方法(同名方法)进行调用而无需考虑该方法所提供的特定实现。)
1.抽象类实现
2.继承实现
3.接口实现

/*抽象类实现多态，相当与接口*/
using System;
using System.Collections.Generic;
using System.Text;

namespace Video
{
    class Program
    {
        static void Main(string[] args)
        {
            Program p = new Program();
            p.PlayVideo();
           
        }
        public void PlayVideo()
        {
            VideoShow vw;
            vw = new DVD();
            Console.WriteLine(vw.playVideo());
            vw = new VCD();
            Console.WriteLine(vw.playVideo());
        }
    }
    public abstract class VideoShow //不能被实例化
    {
        public abstract string playVideo();
    }
    public class VCD:VideoShow
    {
        public override string playVideo()
        {
            return "正在播放VCD";
        }

    }
    public class DVD : VideoShow
    {
        public override string playVideo()
        {
            return "正在播放DVD";
        }
    }
}

/*
* 接口实现多态
* 一个公司有很多的门，但是不管什么门，都有开和关两种的状态。定义一个接口
* 定义两种类型的门door1,door2
* 公司为了验证其保安系统是否完好，检查公司100个门是否正常开和关。
*/

using System;
using System.Collections.Generic;
using System.Text;

namespace DoorApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            IDoor[] door = new IDoor[100];//定义一个接口数组
            for(int i=0;i<100;i++)
            {
                if (i % 2==0)
                    door[i]=new door1();
                else
                    door[i]=new door2();
                door[i].Close();//接口实现方法的访问
                door[i].Open();
            }
           
        }
    }
    interface IDoor
    {
        void Open();
        void Close();
    }
    class door1:IDoor
    {
        private bool HavePerson=false;
        #region IDoor 成员

        public void Open()
        {
            if(HavePerson)
            Console.WriteLine("door1门打开了");
        }

        public void Close()
        {
            if(!HavePerson)
            Console.WriteLine("door1门关上了");
        }

        #endregion
    }
    class door2:IDoor
    {
        private bool isPassWord = false;
        #region IDoor 成员

        public void Open()
        {
            if (isPassWord)
                Console.WriteLine("door2门打开了");
        }

        public void Close()
        {
            if (!isPassWord)
                Console.WriteLine("door2门关上了");
        }

        #endregion
    }
}

继承多态性：继承多态性是最常见的形式。通过virtual关键字的使用，继承多态性提供了方法的不同实现。 在继承一个类时，会继承该类的所有方法，属性，事件以及特性。另外还会继承所有这些成员的实现。但有时候并不想继承某个或某些功能，或者需要稍作变化。现在只要在基类中把方法或属性标记为virtual，就可以在子类中重写功能

将方法标记为virtual：
当方法用关键字virtual修饰时，表明子类可以重写该方法的实现。这是所有面向对象语言的根本。定义一个虚方法后，表明希望在子类中重写该方法。如果并不想重写方法，就不要将方法声明为虚拟的，这样会导致额外的系统开销。这种额外系统开销的来源，是因为要为重写方法检查对象的运行时类型。然后调用派生程度最大的类中的重写方法。如果这个类为基类，哪么就调用该基类中的虚方法，因此，所有在检查类型并查找重写方法时耗去的资源都浪费了。
由于派生类中的方法重写了基类中的方法，因此在声明派生类方法时，使用的标记应该与将要重写的虚方法相同。