虚方法【仅仅有虚方法或者抽象方法才干被子类方法重写】

<1>

当子类重写了父类的同名虚方法后。当我们让父类变量运行这个子类对象的时候。通过这个父类变量调用这个虚方法。调用的仍然是父类的。仅仅只是父类的虚方法被子类覆盖带哦了。

所以实际上调用的是子类的

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

namespace Test
{

    public class person
    {
        public virtual void Sing()
        {
            Console.Write("我是父类方法！
");
        }

    }
    public class Student:person
    {
        public override void Sing()
        {
            Console.Write("我是子类方法。我覆盖了父类同名方法！");
        }   

    }

    class Program
    {
        static void Main(string[] args)
        {
            person p1 = new person();
            p1.Sing(); //输出：我是父类方法。

            Student s1 = new Student();
            s1.Sing();//输出：我是子类方法，我覆盖了父类同名方法。


            //当子类重写了父类的同名虚方法后。当我们让父类变量运行这个子类对象的时候，通过这个父类变量调用这个虚方法。调用的仍然是父类的。
仅仅只是父类的虚方法被子类覆盖带哦了。所以实际上调用的是子类的

            person p2 = new Student();
            p2.Sing();//输出：我是子类方法，我覆盖了父类同名方法。         

            Console.ReadKey();
        }
    }
}

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

namespace Test
{

    //从设计角度考量，通常将子类中共同拥有的但却easy变化的特征抽取为虚函数在父类中定义，而在子类中通过覆写来又一次实现其操作。
    class A
    {
        public virtual void MyMthod() //虚方法能够有方法体，而抽象方法不能够有。
        {
            Console.WriteLine("我是一个虚方法");
        }
    }

    class B : A
    {
        public override void MyMthod() //重写父类中的虚方法
        {
            Console.WriteLine("我重写了父类的虚方法");
        }
    }

    class C : A  //C类继承了A类。它能够override重写父类中的虚方法也能够不重写
    {
        public void Sum(int a, int b) 
        {
            Console.WriteLine(a + b);
        }
    }

    class InheritanceTest1
    {
        static void Main(string[] args)
        {

            B b = new B();
            b.MyMthod(); //输出：我重写在父类的虚方法

            A a = new A();
            a = b; //将变量a指向变量b指向的对象
            a.MyMthod(); //所以这里相同调用的也是B类里的MyMthod()方法。所以输出：我重写在父类的虚方法


            C c = new C();
            c.MyMthod(); //由于C类没有重写父类的虚方法。所以这里调用的是父类的MyMthod()方法。所以这里输出：我是一个虚方法



            Console.ReadKey();
        }
    }
}

<2>虚方法实例

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

namespace Test
{

    //从设计角度考量。通常将子类中共同拥有的但却easy变化的特征抽取为虚函数在父类中定义，而在子类中通过覆写来又一次实现其操作。
    class Person
    {
        public virtual void SayHello() //虚方法能够有方法体。而抽象方法不能够有。

        {
            Console.WriteLine("我是一个人，我会说话");
        }
    }

    class Boy : Person
    {
        public void Features()
        {
            Console.WriteLine("我有JJ");
        }
    }

    class Girl : Person  //Girl类继承了Person类。它能够override重写父类中的虚方法也能够不重写
    {
        public void Features()
        {
            Console.WriteLine("我有胸部");
        }
    }

    class 残疾人 : Person
    {
        public override void SayHello()  //由于这里子类有特殊需求。
所以这里重写了父类的虚方法。
        {
            Console.WriteLine("我嗓子哑了，不会说话了");
        }
    }

    class InheritanceTest1
    {
        static void Main(string[] args)
        {

            Boy boy = new Boy ();
            boy.SayHello();  //由于我是人。所以我有人共同拥有的说话的能力
            boy.Features();  //由于我是男的，我的特征是长了JJ

            Girl girl = new Girl();
            girl.SayHello(); //由于我是人，所以我有人共同拥有的说话的能力
            girl.Features(); //由于是我女的，我的特征是长了胸部

            残疾人 c = new 残疾人();
            c.SayHello(); //由于我如今嗓子哑了，所以我不能说话了。



            Console.ReadKey();
        }
    }
}