C#中abstract和vitrual,override keyword.

1.抽象类与抽象方法

a.抽象类不能被实列化，抽象方法必须在抽象类中声明，抽象方法不能声明主体。

代码 namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Person p = new person(); //无法实例化抽象类
            Console.ReadKey();
        }
    }

    abstract class Person
    {
        protected abstract void sayHello()
        {
             //Error:无法声明主体
        }
    }

    class Animal
    {
        //Error:sayAnimal是抽象方法，但它被包含在非抽象类中
        protected abstract void sayAnimal();
    }
}

b.继承抽象类的派生类必须实现基类中定义的抽象方法。

代码 namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Male m = new Male();
            Console.ReadKey();
        }
    }

    abstract class Person
    {
        protected abstract void sayHello();
        
    }

    class Male : Person
    {
        //Error:派生类必须实现其抽象父类的抽象成员
        
    } 
}

2.vitrual,abstract与override

a.当重写基类中的成员时，不能修改访问修饰符

代码 namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Male m = new Male();
            m.sayVirtual();
            Console.ReadKey();
        }
    }

    abstract class Person
    {
        protected abstract void sayHello();

        protected virtual void sayVirtual()
        {
            Console.WriteLine("Virtual");
        }
    }

    class Male : Person
    {
        //Error：不能修改访问修饰符
        public override void sayVirtual()
        {
            base.sayVirtual();
        }
    } 
}

b.可以在抽象方法中定义虚方法并提供实现，且允许子类访问抽象基类中定义的虚方法

代码 namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Male m = new Male();
            m.sayVirtual();
            m.sayHello();
            Console.ReadKey();
        }
    }

    abstract class Person
    {
        public abstract void sayHello();

        public virtual void sayVirtual()
        {
            Console.WriteLine("Father virtual");
        }
    }
 
    class Male : Person
    {
         public override void sayVirtual()
        {
            base.sayVirtual();
            Console.WriteLine("Child virtual");
        }

        public override void sayHello()
        {
            Console.WriteLine("hellow world!");
        }
        
    } 
} //:输出Father virtual ,Child virtual, hellow world!.

c.在父类中定义的虚方法不要求他的派生类强制重写

代码 namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Male m = new Male();
            m.sayVirtual();  //可以不重写基类中的虚方法
            m.sayHello();
            Console.ReadKey();
        }
    }

    abstract class Person
    {
        public abstract void sayHello();

        public virtual void sayVirtual()
        {
            Console.WriteLine("Father virtual");
        }
    }
 
    class Male : Person
    {
        //必须重写抽象基类中抽象方法
        public override void sayHello()
        {
            Console.WriteLine("hellow world!");
        }
        
    } 
} //Outputs: Father virtual,hellow world!.