在C#中该如何阻止虚方法的覆写

在开发过程中,我们为了让一个类更有生命力,有时会用virtual来修饰一个方法好让子类来覆写它。但是如果有更新的子子类来覆写时,我们又不想让其影响到上一层的覆写,这时候就要用到new virtual来阻断覆写了。

    public class Animal
    {
        public virtual void WhoAmI()
        {
            Console.WriteLine("I am Animal.");
        }
    }

    public class Dog : Animal
    {
        public override void WhoAmI()
        {
            Console.WriteLine("I am Dog.");
        }
    }

    public class Dog1 : Animal
    {
        public new void WhoAmI()
        {
            Console.WriteLine("I am Dog1.");
        }
    }

    public class HomeDog : Dog
    {
        /// <summary>
        /// 采用new virtual来修饰来阻断覆写
        /// </summary>
        public new virtual void WhoAmI()
        {
            Console.WriteLine("I am HomeDog.");
        }
    }

    public class HuskyDog : HomeDog
    {
        public override void WhoAmI()
        {
            Console.WriteLine("I am HuskyDog.");
        }
    }

    [TestFixture]
    public class RunTest
    {
        [Test]
        public void NewAndOverrideRun()
        {
            Dog1 x = new Dog1();
            x.WhoAmI(); //I am Dog1.

            ((Animal)x).WhoAmI();//I am Animal.

            //new修饰的方法调用,取决于类型。
        }

        [Test]
        public void OverrideRun()
        {
            Dog x = new Dog();
            x.WhoAmI();//I am Dog.

            var x1 = x as Animal;
            x1.WhoAmI();//I am Dog.

            //override修饰符的方法调用,取决于实例化对象的类型
        }

        [Test]
        public void NewVirtualRun()
        {
            var x = new HomeDog();
            x.WhoAmI();//I am HomeDog.

            ((Dog)x).WhoAmI();//I am Dog.

            ((Animal)x).WhoAmI();//I am Dog.

            //new virtual阻断了方法的向上覆写。并且,Dog的覆写不受影响
        }

        [Test]
        public void NewVirtualThenOverrideRun()
        {
            var x = new HuskyDog();
            x.WhoAmI();//I am HuskyDog.

            ((HomeDog)x).WhoAmI();//I am HuskyDog.

            ((Dog)x).WhoAmI();//I am Dog.

            ((Animal)x).WhoAmI();//I am Dog.

            //new virtual 阻断向上的覆写,但是新的子类覆写它时不和原来覆写结果一样。
        }

    }
时间: 07-05

在C#中该如何阻止虚方法的覆写的相关文章

C#使用基类的引用 and 虚方法和覆写方法

结论:使用基类的引用,访问派生类对象时,得到的是基类的成员. 虚方法和覆写方法

review——C# (6)虚方法和覆写方法

FROM P125 在上一节中看到,当使用基类引用访问派生类对象时,得到的是基类的成员.虚方法可以使基类的引用访问"升至"派生类内. 可以使用基类引用调用派生类(derived class)的方法,只需满足下列条件: □派生类的方法和基类的方法有相同的签名和返回类型 □基类的方法使用virtual标注 □派生类的方法使用override标注 使用方法如下例: 1 class MyBaseClass //基类 2 { 3 virtual public void Print(); 4 }

虚方法和覆写方法

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace nange_1 { class A { public void f() { Console.WriteLine("在基类中"); } } class B : A { public void f() { Console.WriteLine("在子类中"); } } class P

Java中方法的覆写

所谓方法的覆写override就是子类定义了与父类中同名的方法,但是在方法覆写时必须考虑权限,即被子类覆写的方法不能拥有比父类方法更加严格的访问权限. 修饰符分别为public.protected.default.private.他们的访问权限如下图所示. 用public修饰的类在本类.同包.子类.其他包中互相访问都是可以的. 用protected修饰的类在本类.同包.子类中互相访问都是可以的,protected不可以在包外没有继承关系的类中互相访问. 就说明用default修饰的类在本类.同包

方法的覆写

方法的覆写 类和父类有相同的方法,那么类中方法的访问权限不能比父类中对应方法的访问权限严格,这就叫方法的覆写,一般称之为类覆写了父类中的某个方法 覆写方法的作用:对于一个类,向上转换后(把类的实例化对象赋值给类的父类的对象),通过该父类的对象直接访问该父类的对象的本类部分中被类所覆写的方法时,将自动访问跳转到类中对应的覆写的方法 static方法的覆写不起覆写作用,原因现阶段只能解释为Java就是这样设计的 package test1; public class Test1 { public s

C#中的抽象方法,虚方法,接口之间的对比

1.首先来看一看抽象类 抽象类是特殊的类,不能够被实例化:具有类的其他特性:抽象方法只能声明于抽象类中,且不包含任何实现 (就是不能有方法体),派生类也就是子类必须对其进行重写.另外,抽象类可以派生自一个抽象类,可以覆盖基类的抽象方法也可以不覆盖,如果不覆盖,则其派生类必须覆盖它们.关键字就是 abstract /* * 抽象方法必须写在,抽象类中 * */ public abstract class Animal { public abstract void Sleep(); public a

Java中的overload(方法的覆写)

方法覆写(overload)与方法的重载非常相似,它在 Java的继承中也有很重要的应用. 写程序可能会碰到下面的情况,在父类中已经实现的方法可能不够精确,不能满足子类 的需求.例如在前面的 Animal类中,breath方法就过于简单,对于鱼类动物是用腮呼吸的, 而对于哺乳动物则是用肺呼吸的,如何实现呢,Java提供的方法覆写就是解决这方面的问题. 在下面的程序中首先定义了一个父类 Animal,然后定义 Animal的  3个子类  Tiger.Fish 和 Dog,在父类中提供了 3个方法

C#中virtual(虚方法)的理解以及和abstract(抽象方法)的区别

Virtual方法(虚方法) virtual 关键字用于在基类中修饰方法.virtual的使用会有两种情况: 情况1:在基类中定义了virtual方法,但在派生类中没有重写该虚方法.那么在对派生类实例的调用中,该虚方法使用的是基类定义的方法. 情况2:在基类中定义了virtual方法,然后在派生类中使用override重写该方法.那么在对派生类实例的调用中,该虚方法使用的是派生重写的方法. 代码如下: namespace VirtualTestApplication{ public class

C#中抽象方法与虚方法的区别

一.抽象方法:只在抽象类中定义,方法修饰符不能使用private,virtual,static. 抽象方法如下示: public abstract class People   //声明一个抽象类 { public abstract void study();  //抽象方法只能定义在抽象类中. } public class Student:People   //继承抽象类 { public  override void study()     //重写抽象类的抽象方法 { Console.Wr