review——C# （6）虚方法和覆写方法

FROM P125

　　在上一节中看到，当使用基类引用访问派生类对象时，得到的是基类的成员。虚方法可以使基类的引用访问“升至”派生类内。

　　可以使用基类引用调用派生类（derived class）的方法，只需满足下列条件：

　　□派生类的方法和基类的方法有相同的签名和返回类型

　　□基类的方法使用virtual标注

　　□派生类的方法使用override标注

使用方法如下例：

    class MyBaseClass                                   //基类
    {
        virtual public void Print();
    }
    class MyDerivedClass : MyBaseClass          //派生类
    {
        override public void Print()
    }    

与上一节中不同，使用基类引用调用Print方法时，方法调用被传递到派生类并执行，因为：

□基类的方法被标记为virtual

□派生类中有匹配的override方法

如下图所示，显示了一个从virtual Print方法后面开始，并指向override Print方法的箭头

具体示例如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace review
{
    class MyBaseClass                           //基类
    {
        virtual public void Print()
        {
            Console.WriteLine("This is the base class.");
        }
    }
    class MyDerivedClass : MyBaseClass          //派生类
    {
        override public void Print()
        {
            Console.WriteLine("This is the derived class.");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyDerivedClass derived = new MyDerivedClass();
            MyBaseClass mybc = (MyBaseClass)derived;        //强制转换成基类
            derived.Print();
            mybc.Print();
            Console.Read();
        }
    }
}
/*
 * 输出如下：
 * This is the derived class.
 * This is the derived class.
 * */

其他的一些关于virtual和override的信息有：

□覆写和被覆写的方法必须有相同的可访问性。e.g.不能是 被覆写是private 而覆写的是public

□不能覆写static方法或非虚方法

□方法、属性、索引器，以及另一种成员类型事件，都可以被声明为virtual和override

Part2 覆写标记为override的方法：

覆写方法可以在继承的任何层次中出现

□当使用对象基类部分的引用调用一个覆写的方法时，方法的调用被沿派生层次上溯执行，一直到标记为override的方法的最高派生（most-derived）版本。

□如果在更高的派生级别有该方法的其他声明，但没有被标记为override，那么它们不会被调用

以以下实例来说明，其中三个类构成一个继承的层次：

MyBaseClass、MyDerivedClass和SecondDerived。其均包含名称为Print的方法，并带有相同的签名。且分别被标记为virtual、override、 override/new 分别看一下第三个类标记为这两个的结果。

    class MyBaseClass                           //基类
    {
        virtual public void Print()
        {
            Console.WriteLine("This is the base class.");
        }
    }
    class MyDerivedClass : MyBaseClass          //派生类
    {
        override public void Print()
        {
            Console.WriteLine("This is the derived class.");
        }
    }
    class SecondDerived : MyDerivedClass        //最高派生类
    {
        ...// Given in the following pages
    }

1.情况1：使用override声明Print

如果把SecondDerived的Print方法声明为override，那么它会覆写方法的全部两个低派生级别的版本，如下图所示，如果一个基类的引用被用于调用Print，它会向上传递通过整个链达到类SecondDerived中的实现。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace review
{
    class MyBaseClass                           //基类
    {
        virtual public void Print()
        {
            Console.WriteLine("This is the base class.");
        }
    }
    class MyDerivedClass : MyBaseClass          //派生类
    {
        override public void Print()
        {
            Console.WriteLine("This is the derived class.");
        }
    }
    class SecondDerived : MyDerivedClass        //最高派生类
    {
        public override void Print()
        {
            Console.WriteLine("This is the second derived class.");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            SecondDerived derived = new SecondDerived();
            MyBaseClass mybc = (MyBaseClass)derived;        //强制转换成基类

            derived.Print();
            mybc.Print();
            Console.Read();
        }
    }
}
/*
 * 输出如下：
 * This is the second derived class.
 * This is the second derived class.
 * */

结果是：无论Print是通过派生类调用还是通过基类调用，都会调用最高派生类中的方法。当通过基类调用时，调用被沿着继承层次向上传递。

2.情况2：使用new声明Print

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace review
{
    class MyBaseClass                           //基类
    {
        virtual public void Print()
        {
            Console.WriteLine("This is the base class.");
        }
    }
    class MyDerivedClass : MyBaseClass          //派生类
    {
        override public void Print()
        {
            Console.WriteLine("This is the derived class.");
        }
    }
    class SecondDerived : MyDerivedClass        //最高派生类
    {
        new public void Print()
        {
            Console.WriteLine("This is the second derived class.");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            SecondDerived derived = new SecondDerived();
            MyBaseClass mybc = (MyBaseClass)derived;        //强制转换成基类

            derived.Print();
            mybc.Print();
            Console.Read();
        }
    }
}
/*
 * 输出如下：
 * This is the second derived class.
 * This is the derived class.
 * */

结果是：当方法Print通过SecondDerived的引用调用时，SecondDerived中的方法被执行，正如所期待的那样。然而，当方法通过MyBaseClass的引用调用时，方法调用只向上传递了一级，到达类MyDerived，在那里它被执行。

本来想使用下列代码进行 virtual -> override -> new ->override 的检验

class ThirdDerived : SecondDerived
    {
        override public void Print()
        {
            Console.WriteLine("This is the third derived class.");
        }
    }

然而编译器报错为“ThirdDerived.Print()”: 继承成员“SecondDerived.Print()”未标记为 virtual、abstract 或 override，无法进行重写。

不过，当试验virtual-> override->new ->virtual ->override 时却是可以的，而实际上，这个中间多出的virtual是在对之前的一系列方法进行隐藏，即这个virtual其实应该写作 new virtual。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace review
{
    class MyBaseClass                           //基类
    {
        virtual public void Print()
        {
            Console.WriteLine("This is the base class.");
        }
    }
    class MyDerivedClass : MyBaseClass          //派生类
    {
        override public void Print()
        {
            Console.WriteLine("This is the derived class.");
        }
    }
    class SecondDerived : MyDerivedClass        //最高派生类
    {
        new public void Print()
        {
            Console.WriteLine("This is the second derived class.");
        }
    }
    class ThirdDerived : SecondDerived
    {
        new virtual public void Print()
        {
        }
    }
    class FourthDerived : ThirdDerived
    {
        override public void Print()
        {
            Console.WriteLine("This is the fourth derived class.");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            FourthDerived derived = new FourthDerived();
            MyBaseClass mybc = (MyBaseClass)derived;        //强制转换成基类

            derived.Print();
            mybc.Print();
            Console.Read();
        }
    }
}
/*
 * 输出如下：
 * This is the fourth derived class.
 * This is the derived class.
 * */

综上，对覆写方法的总结为：

通过某个引用对方法进行调用时，实际执行的是从这里出发，连续的一段override覆写中的最后一个的方法。（中间不可以用virtual隔开）。

Part3 覆盖其他成员类型

以上已经描述了如何在方法上使用virtual/override，事实上，在属性事件以及索引器上也是一样的。e.g.下面的代码演示了名为MyProperty的只读属性，其中使用了virtual/override

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace review
{
    class MyBaseClass                           //基类
    {
        private int _mInt = 5;
        virtual public int MyProperty
        {
            get { return _mInt; }
        }
    }
    class MyDerivedClass : MyBaseClass          //派生类
    {
        private int _mInt = 10;
        public override int MyProperty
        {
            get
            {
                return _mInt;
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyDerivedClass derived = new MyDerivedClass();
            MyBaseClass mybc = (MyBaseClass)derived;        //强制转换成基类

            Console.WriteLine(derived.MyProperty);
            Console.WriteLine(mybc.MyProperty);
            Console.Read();
        }
    }
}
/*
 * 输出如下：
 * 10
 * 10
 * */

这里需要注意的是，最终执行下去返回的属性就是派生类的属性。

p.s. 使用virtual声明，并不影响方法or属性or事件or索引的执行（字段无法被virtual修饰）。virtual修饰的方法or属性or事件or索引仍可以有函数体。

如下例所示

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace review
{
    class MyBaseClass                           //基类
    {
        private int _mInt = 5;
        virtual public int MyProperty
        {
            get { return _mInt; }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyBaseClass mybc = new MyBaseClass();
            Console.WriteLine(mybc.MyProperty);
            Console.Read();
        }
    }
}
/*
 * 输出如下：
 * 5
 * */