C#中的多态

继承是子类使用了父类的方法，多态是父类使用了子类的方法。

A.多态性定义：

同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。多态性通过派生类重载基类中的虚函数型方法来实现。

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、Abstruct

virtual关键字只能修饰方法和属性，却不能修饰类

abstruct可以修饰类、方法、属性、索引及事件等

abstruct类：

如果在类声明中使用 abstract 修饰符则：

（1）以指示类只能是其他类的基类

（2）不能被实例化

（3）可以包含抽象方法和抽象访问器

（4）不能用 sealed 修饰符修改抽象类，意味着该类不能被继承

（5）从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实现

（6）在方法或属性声明中使用 abstract 修饰符以指示此方法或属性不包含实现等等

 

virtual 用于修饰一个实现的类方法（待重写，可以不重写，override）

abstract 修饰的方法没有实现（待实现，必须实现，override）