C#关键字 abstract,override,virtual的用法

什么是抽象类：abstract关键字修饰的类称为抽象类，抽象类不能被实例化，抽象类是派生类的基类。
关键字：abstract
语法：
public abstract class 类名
{
…………
}
1、一个抽象类可以同时包含抽象方法和非抽象方法，但不能实例化。
2、抽象方法只是在派生类中真正实现，这表明抽象方法只存放函数原型，斌不涉及主体代码，
3、派生自抽象类的类需要实现其基类的抽象方法，才能实例化对象。
4、使用override关键子可在派生类中实现抽象方法，经override声明重写的方法称为重写基类方法，其签名必须与override方法的签名相同。

注意:派生类继承抽象类，需要override抽象类中的抽象属性和抽象方法，如果有未override的，则派生类也必须为抽象类

using System;
namespace Example_5
{
//抽象类
public abstract class Person
{
 
  public abstract void Say(); //抽象方法必须是公有的
  public string  vendor { get; set; } //普通属性     
  public abstract float Price { get; } //抽象属性必须是公有的


public virtual bool SectionExists()
        {
           return true;
        }


}
//派生类
public class Son:Person
{
    public override float Price
          {
              get
             {
                  if (vendor == "红富士")
                     return 100;
                 else                    
                      return 0;
 
             }
        }

  //实现抽象类中的抽象方法
  public override void Say()
{
   Console.WriteLine(“实现抽象方法”);
  }
}

public class Test
{
  static void Main(string[] args)
  {
   Son obj=new Son();
   obj.Say();
  }
}
}

既然讨论了抽象类，必须谈一下C#中的方法重写，

关键字：override
override关键字用于修改方法，具有override关键字修饰符的方法是对基类中同名方法的新实现，基类中的同名方法必须声明为virtual或abstract类型。给基类中的方法添加virtual关键字表示可以在派生类中重写它的实现。
1、默认的C#方法并非virtual，因此不能重写。
2、基类方法的可访问级别并不因重写它的方法而改变，他们的访问修饰符相同。
3、new、static和virtual关键字不能与override访问修饰符一同使用

//抽象类
abstract class Bird{  //含有抽象方法，就一定是抽象类
    private float speed;

    public abstract void Fly();   //抽象方法
    }

//派生类
class Crow : Bird{  //继承了抽象类，此时必须要求实现抽象方法
    public override void Fly()
    {
        Console.WriteLine("Crow is flying!");
    }

//用派生类构造和声明
Crow crow = new Crow;
crow.Fly();

//用抽象类声明，用派生类构造
Bird bird = new Crow();
bird.Fly();

关键字：virtual
C#中提供virtual关键字，用于将方法定义为支持多态，用于对一个类中可修改的方法的声明，这种方法称为虚拟方法，字类可以使用override关键字自由实现它们各自版本的虚拟方法
语法：
[访问修饰符] virtual [返回值类型] 方法名称（[参数列表]）
{
  //虚拟方法的实现
}
1、virtual访问修饰符不能与static和override等访问修饰符一同使用
2、调用虚拟方法，在运行时系统会自动检查，以确定调调用了哪一个实现方法。

class TestClass
{
    public class Shape
    {
        public const double PI = Math.PI;
        protected double x, y;
        public Shape()
        {
        }
        public Shape(double x, double y)
        {
            this.x = x;
            this.y = y;
        }

        public virtual double Area()
        {
            return x * y;
        }
    }

    public class Circle : Shape
    {
        public Circle(double r) : base(r, 0)
        {
        }

        public override double Area()
        {
            return PI * x * x;
        }
    }

    class Sphere : Shape
    {
        public Sphere(double r) : base(r, 0)
        {
        }

        public override double Area()
        {
            return 4 * PI * x * x;
        }
    }

    class Cylinder : Shape
    {
        public Cylinder(double r, double h) : base(r, h)
        {
        }

        public override double Area()
        {
            return 2 * PI * x * x + 2 * PI * x * y;
        }
    }

    static void Main()
    {
        double r = 3.0, h = 5.0;
        Shape c = new Circle(r);
        Shape s = new Sphere(r);
        Shape l = new Cylinder(r, h);
        // Display results:
        Console.WriteLine("Area of Circle   = {0:F2}", c.Area());
        Console.WriteLine("Area of Sphere   = {0:F2}", s.Area());
        Console.WriteLine("Area of Cylinder = {0:F2}", l.Area());
        }
    }

参考：

https://blog.csdn.net/mingrushuoyan/article/details/91856897

https://www.cnblogs.com/LagoOrLY/p/10318214.html