C#中修饰符——abstract、virtual-EW帮帮网

一、多态简介

在面向对象编程的过程中，多态体现出来的是【一个接口，多个功能】；多态性体现在2个方面：

1、程序运行时，在方法参数、集合或数组等位置，派生类对象可以作为基类的对象处理；这样该对象声明的类型就与运行时的类型不同了；

2、基类可以定义并实现虚方法，派生类可以重写这些虚方法；在程序运行时，可以调用基类方法执行派生类的重写方法。

在C#中要实现多态，必须使用abstract、virtual这个两个修饰符来定义，使用override来重写方法。多态又可以分为：【静态多态性】、【动态多态性】；

二、静态多态性

静态多态性（即：使用static修饰；变量、函数的响应是在程序编译时就发生了）若一个方法被static声明，则该方法就是静态方法，那么编译器就会在编译时保留这个静态方法的实现；也就是说这个静态方法只属于类，而不属于任何实例，无论实例是否存在，都可以可直接调用这个静态方法。

C#中的静态多态性分为两种：【函数重载】、【运算符重载】

    //静态函数重载示例
    public class StaticReload
    {
        public static void Greet()
        {
            Console.WriteLine($"你好，欢迎访问");
        }
        public static void Greet(string greetMsg)
        {
            Console.WriteLine(greetMsg);
        }

    }//Class_end


    class Program
    {
        static async Task Main(string[] args)
        {
            StaticReload.Greet();
            StaticReload.Greet("Quartz定时任务测试");
        }
    }

运算符重载 - 定义一元运算符、算术运算符、相等运算符和比较运算符。 - C# reference | Microsoft Learnhttps://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/operators/operator-overloading

三、动态多态性

动态多态性（无static修饰；变量、函数的响应是在程序运行起来后发生的）。

3.1、abstract（抽象）

abstract 关键字 - C# reference | Microsoft Learnhttps://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/abstract 【abstract】关键字可用于修饰类（Class）、方法（Method）、属性（attribute）、索引（index）和事件（Event）；

3.1.1、抽象类

在类（class）前面放置修饰符【abstract】，则可以将类声明为抽象类；

**抽象类的特点**
序号	抽象类特点
1	抽象类不能实例化
2	抽象类可能包含抽象方法和访问器
3	无法使用 sealed 修饰符来修改抽象类因为两个修饰符的含义相反【 `sealed` 修饰符阻止类被继承；而 `abstract` 修饰符要求类被继承】
4	派生自抽象类的非抽象类，必须实际实现所继承抽象类的全部抽象内容（抽象方法、属性、索引、事件）

    public abstract class MyShape
    {
        public abstract float GetArea();
        public abstract string Name { get;}
        public abstract Action<float> GetAction();
        

    }//Class_end


    public class Circle : MyShape
    {
        private int _radius;
        
        public Circle(int r)
        {
            _radius = r;
                
        }

        public override string Name {get => "我是圆";}

        public override Action<float> GetAction()
        {
            throw new NotImplementedException();
        }

        public override float GetArea()
        {
            var tmp =Math.PI * (_radius * _radius);
            float result =(float)tmp;
            return result;
        }

    }//Class_end


    class Program
    {
        static async Task Main(string[] args)
        {
            MyShape myShape = new Circle(3);
            float shapeArea = myShape.GetArea();
           
            Console.WriteLine($"Name：{myShape.Name}  ShapeArea: {shapeArea}");
        }
    }

抽象类、密封类及类成员 - C# | Microsoft Learnhttps://learn.microsoft.com/zh-cn/dotnet/csharp/programming-guide/classes-and-structs/abstract-and-sealed-classes-and-class-members

3.1.2、抽象方法

在方法、属性、索引、事件前面放置修饰符【abstract】，则可以声明为抽象方法、属性、索引、事件；且表明方法、属性、索引、事件不包含实现。

**抽象方的法特点**
序号	抽象方法特点
1	只有抽象类中才允许声明抽象方法
2	抽象方法不提供实际实现，所以声明仅以分号结尾，没有大括号{}；具体实现由一般类继承抽象类使用 override重写 `public abstract float GetArea();`
3	抽象方法声明中使用 static 或 virtual 修饰符是错误的

3.1.3、abstract的使用场景

内容有通用的共性特征和行为，且必须要在不同的派生类实现（即：内容必须存在的时候用abstract）。

3.2、virtual（虚拟）

virtual 关键字 - C# reference | Microsoft Learnhttps://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/virtual 【virtual 】关键字用于修改方法、属性、索引器或事件声明，并使它们可以在派生类中被重写。

3.2.1、虚方法

    public class MyCar
    {
        public virtual string Name { get; set; }

        public virtual string Manufacturer { get; }

        public MyCar(string manufacturer)
        {
            this.Manufacturer = manufacturer;
        }
        public virtual void Function()
        {
            Console.WriteLine($"【{Manufacturer}】品牌车况运行状态良好");
        }

        public virtual Action<bool> Custom(bool start)
        {
            if (start)
            {
                Console.WriteLine($"【{Name}】仪表盘显示发动机转速");
            }

            return null;
        }

    }//Class


    public class SUVCar : MyCar
    {
        public SUVCar(string manufacturer) : base(manufacturer)
        {

        }

        public override void Function()
        {
            base.Function();
            Console.WriteLine($"【{Manufacturer}】品牌开始校验SUV的各个功能是否正常");
        }

        public override Action<bool> Custom(bool start)
        {
            Action<bool> action=new Action<bool>(Test);
            Console.WriteLine($"【{Name}】所有功能准备完毕，开始出发");

            return action;
        }

        private void Test(bool start)
        {
            if (start)
            {
                Console.WriteLine("启动智能驾驶功能");
            }
            
        }

    }//Class_end


    class Program
    {
        static async Task Main(string[] args)
        {
            MyCar car = new MyCar("自产");
            car.Name = "基础车";
            car.Function();
            car.Custom(true);

            Console.WriteLine("---------------------------\r\n");

            car = new SUVCar("问界");
            car.Name = "SUV越野";
            car.Function();
            car.Custom(true);
        }
    }

**虚方法的特点**
序号	虚方法特点
1	虚方法必须有实现
2	虚方法可以不在派生类中重写
虚方法的2中使用情况
1	基类定义了virtual方法，但是派生类没有重写基类virtual方法，则对派生类的实例调用中，使用的是基类定义的virtual方法内容
2	基类定义了virtual方法，且派生类重写了基类的virtual方法，则对派生类的实例调用中，使用的是派生类重写的virtual方法内容

3.2.2、virual的使用场景

virtual的核心是多态【即：同一个方法能用不同的方式来做】；如：

1、支付方法Pay()，既可使用微信支付、也可使用支付宝支付或者其他方法支付；

2、消息发送方法MSGSend()，既可使用邮件发送、也可使用企业微信发送、或钉钉发送；

3.3、抽象方法与虚方法的区别与联系

抽象方法与虚方法的相同点是：都使用override重写。

**抽象方法与虚方法的区别**
序号	抽象方法（abstract）	虚方法（virtual）
1	抽象方法必须在抽象类中	没有要求
2	抽象方法只是声明没有实际实现，必须在派生类中重写实现	虚方法有声明与实际实现，派生类可完全重写、部分重写或不重写直接使用基类实现
3	抽象类不能被实例化(new)，只能用实现了全部抽象方法的派生类来实例化	包含虚方法的类可以被实例化(new)

3.4、普通类、接口与抽象类

抽象类主要用于关系密切的对象；接口适合为不相关的类提供通用功能。

**普通类、接口、抽象类区别与联系**
序号	普通类	接口	抽象类
1	普通类可有成员变量、常量、构造函数，没有抽象方法	接口不能有常量、域、操作符、构造函数、析构函数及其任何静态成员【可包含属性、方法、索引和事件】	抽象类有抽象方法
2	普通类可继承一个基类，多个接口	接口可继承多个接口	抽象类也可继承一个基类和多个接口
3	普通类可以定义具体的方法和实际实现	接口只能定义方法，而没有具体实现	抽象类的抽象方法不能有具体实现
4	普通类成员没有限制	接口成员必须是公共的	抽象类不能对private抽象
5	普通类可以实例化	接口不能实例化	抽象类不能实例化，只能使用实现了全部抽象方法的派生类来实例化