【Unity 11】C# 中的Abstract、 Virtual、Override的使用

PS:本系列笔记将会记录我此次在北京学习Unity开发的总体过程，方便后期写总结，笔记为日更。
笔记内容均为 自己理解，不保证每个都对。
C#笔记未按照难度排列

Part 1 Abstract：

1、简介及特点：
Abstract表示抽象类
利用Abstract修饰的内容代表方法的内容未完全实现
Abstract可以修饰 类，方法，属性索引
标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。
特点：
1、不能被实例化 即不能使用 new方法
2、抽象类可以包含抽象方法和抽象访问器
3、在方法或属性中声明
4、抽象方法是隐式的虚方法

2、声明：

public abstract class FunA  //抽象类
{
    public int NumberA = 100;
    public int NumberB = 200;

    public abstract void Swap();    //抽象方法

    public abstract int getNumberA { get; } //抽象方法
    public abstract int getNumberB { get; } //抽象方法

}

3、派生类的定义：
标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现
派生类要实现基类用Abstract修饰的方法

public class FunB: FunA
{
    public override void Swap() //实现基类的SWAP方法
    {
        int temp = NumberA;
        NumberA = NumberB;
        NumberB = temp;
    }

    public override int getNumberA  //实现基类的getNumberA方法
    {
        get { return NumberA; }
    }

    public override int getNumberB  //实现基类的getNumberB方法
    {
        get { return NumberB; }
    }
}

4、使用：

    FunB funB = new FunB();
    Console.WriteLine("SWAP前 NumberA == {0}   NumberB == {1}", funB.NumberA, funB.NumberB);
    funB.Swap();
    Console.WriteLine("SWAP后 NumberA == {0}   NumberB == {1}", funB.getNumberA, funB.getNumberB);

输出结果：

Part 2 Virtual：

1、简介及特点：
*virtual关键字用于修饰方法、属性、索引器或事件声明，
*并使它们可以在派生类中被重写。虚拟成员的实现可由派生类中的重写成员更改。
*调用虚方法时，将为重写成员检查该对象的运行时类型。将调用大部分派生类中的该重写成员，
*如果没有派生类重写该成员，则它可能是原始成员。默认情况下，方法是非虚拟的。不能重写非虚方法。
*virtual 修饰符不能与 static、abstract, private 或 override 修饰符一起使用。
*和抽象方法的相同点是都用了override关键字进行重写方法，
*不同点是抽象方法必须存在于抽象类中，而子类必须重写，除非子类也是抽象的。

2、定义及声明：

        public class Dimensions
        {
            public const double PI = Math.PI;
            public double NumberA;
            public double NumberB;

            public Dimensions(double NumberA, double NumberB)
            {
                this.NumberA = NumberA;
                this.NumberB = NumberB;
            }

            public virtual double Area()
            {
                return NumberA * NumberB;
            }

        }


        public class Circle : Dimensions
        {

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

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

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

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

        public class Cylinder: Dimensions
        {
            public Cylinder(double r, double h) : base(r, h) { }
            public override double Area()
            {
                return 2 * PI * NumberA * NumberA + 2 * PI * NumberA * NumberB;
            }
        }

3、使用：

            Dimensions P = new Circle(5.0);
            Console.WriteLine("Dimensions Area :" + P.Area());

            Sphere sphere = new Sphere(10);
            Console.WriteLine("Sphere Area :" + sphere.Area());

            Cylinder cylinder = new Cylinder(10, 10);
            Console.WriteLine("Cylinder Area :" + cylinder.Area());

输出结果为：