C#继承中abstract、virtual、override和new

abstract

详细参考:https://msdn.microsoft.com/zh-cn/library/sf985hc5.aspx

abstract 修饰符指示所修饰的内容缺少实现或未完全实现。 abstract
修饰符可用于类、方法、属性、索引器和事件。 在类声明中使用 abstract 修饰符以指示某个类只能是其他类的基类。 标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。

抽象类具有以下特性:

- 抽象类不能实例化。

- 抽象类可以包含抽象方法和抽象访问器。

- 不能用 sealed(C# 参考) 修饰符修饰抽象类,因为这两个修饰符的含义是相反的。 采用 sealed 修饰符的类无法继承,而 abstract 修饰符要求对类进行继承。

- 从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实际实现。

抽象方法具有以下特性:

- 抽象方法是隐式的虚方法。

- 只允许在抽象类中使用抽象方法声明。

- 因为抽象方法声明不提供实际的实现,所以没有方法体;方法声明只是以一个分号结束,并且在签名后没有大括号 ({ })。

- 实现由一个重写方法override(C# 参考)提供,此重写方法是非抽象类的一个成员。

- 在抽象方法声明中使用 static 或 virtual 修饰符是错误的。

virtual

详细参考:https://msdn.microsoft.com/zh-cn/library/9fkccyh4.aspx

virtual 关键字用于修饰方法、属性、索引器或事件声明,并使它们可以在派生类中被重写。 例如,此方法可被任何继承它的类重写。调用虚方法时,将为重写成员检查该对象的运行时类型。 将调用大部分派生类中的该重写成员,如果没有派生类重写该成员,则它可能是原始成员。默认情况下,方法是非虚拟的。 不能重写非虚方法。virtual 修饰符不能与 static、abstract,
private 或 override 修饰符一起使用。


C# 中,派生类中方法的名称可与基类中方法的名称相同。 可通过使用 new 和 override 关键字指定方法互动的方式。 override 修饰符 extends 基类方法,且 new 修饰符将其“隐藏”起来。参考:https://msdn.microsoft.com/zh-cn/library/ms173153.aspx

override

详细参考:https://msdn.microsoft.com/zh-cn/library/ebca9ah3.aspx

要扩展或修改继承的方法、属性、索引器或事件的抽象实现或虚实现,必须使用 override 修饰符。override 方法提供从基类继承的成员的新实现。 由 override 声明重写的方法称为重写基方法。 重写的基方法必须与 override 方法具有相同的签名。

- 不能重写非虚方法或静态方法。 重写的基方法必须是 virtual、abstract 或 override 的。

- override 声明不能更改 virtual 方法的可访问性。 override 方法和 virtual 方法必须具有相同的访问级别修饰符

- 您不能使用 new、static 或 virtual 修饰符来修改 override 方法。

new

参考:https://msdn.microsoft.com/zh-cn/library/435f1dw2.aspx

在用作声明修饰符时,new 关键字可以显式隐藏从基类继承的成员。 隐藏继承的成员时,该成员的派生版本将替换基类版本。 虽然可以不使用 new 修饰符来隐藏成员,但将收到编译器警告。 如果使用 new 来显式隐藏成员,将禁止此警告。基类中的成员不管是否有virtual声明,子类都可以用new替换。

    public class Class1
    {
        public Class1()
        {
            Console.WriteLine("This is Class 1");
        }

        public virtual void run()
        {
            Console.WriteLine("Class 1 is running");
        }

        public void test()
        {
            Console.WriteLine("Class 1 test");
        }
    }

    public class Class2 : Class1
    {
        public Class2():base()
        {
            Console.WriteLine("This is class2");
        }

        public new void run()  //父类的virtual函数和非virtual函数都可以用new替换掉
        {
            Console.WriteLine("Class 2 is running");
        }

        public void test()   //没有加上new有警告
        {
            Console.WriteLine("Class 2 test");
        }

    }

new和override的区别

参考: 使用
Override 和 New 关键字进行版本控制(C# 编程指南)
以及 了解何时使用
Override 和 New 关键字(C# 编程指南)

当派生类与基类的方法同名时,可以基类方法定义为virtual并且派生类中用override重写,或者直接派生类中用new关键字或者不用(默认还是new但是会有警告)来替换基类的方法。那么在这两种情况下,它们会有什么不一样的效果吗?

下面这个例子诠释了它们的重要区别。对于基类的实例指向基类或者派生类的实例指向派生类,它们的结果是一样的。但是对于基类的实例指向派生类,new将调用基类的方法,而override将调用派生类的方法。

    public class Class1
    {
        public virtual void run()
        {
            Console.WriteLine("Class 1 is running");
        }

        public void test()
        {
            Console.WriteLine("Class 1 test");
        }
    }

    public class Class2 : Class1
    {
        public override void run()
        {
            Console.WriteLine("Class 2 is running - override");
        }

        public new void test()
        {
            Console.WriteLine("Class 2 test - new");
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Condition 1: ");
            Class1 c1 = new Class1();
            c1.run();
            c1.test();

            Console.WriteLine("Condition 2: ");
            Class2 c2 = new Class2();
            c2.run();
            c2.test();

            Console.WriteLine("Condition 3: ");
            Class1 c0 = new Class2();
            c0.run();                          //derived override run - Class2
            c0.test();                         //base - Class1

            Console.ReadKey();
        }
    }
时间: 01-25

C#继承中abstract、virtual、override和new的相关文章

c#中abstract、override、new、virtual、sealed使用和示例

原文地址:http://blog.csdn.net/richerg85/article/details/7407544 abstract      修饰类名为抽象类,修饰方法为抽象方法.如果一个类为抽象类,则这个类智能是其他某个类的基类.抽象方法在抽象类中没有函数体.抽象类中的抽象方法是没有方法体的,继承其的子类必须实现抽象类的抽象方法. 抽象类有如下特征: 抽象类不能实例化 抽象类的派生类必须实现所有抽象方法 抽象类中的抽象方法是没有方法体的,继承其的子类必须实现抽象类的抽象方法 抽象方法:

abstract,virtual,override个人

1.abstract 可以修饰类和方法,修饰方法时只声明不实现: 2.继承实现abstract类必须通过override实现abstract声明的方法,而virtual方法可选择override(重写)实现: 3.

abstract,virtual,override

1.abstract 可以修饰类和方法,修饰方法时只声明不实现: 2.继承实现abstract类必须通过override实现abstract声明的方法,而virtual方法可选择override(重写)实现: 3.

c#中的 virtual override 和abstract 以及sealed

1.如果父类方法没有加virtual关键字,即不是一个虚方法,则在子类中只能隐藏基类方法,而不能覆盖. 2.如果父类方法加了virtual关键字,即它是一个虚方法,在子类中一样可以隐藏. 3.如果子类实现了父类相同的方法(相同的方法名称及签名),而没有new,在编译时会报警,但编译仍然能够通过! 4.调用父类方法:base.方法名() 5.abstract类是一个抽象类,不能被实例化 new 和override的区别 1.override重写虚方法,那么就只剩下重写以后的方法; 2.new隐藏基

C++ 在继承中使用virtual

使用virtual:如果方法是通过引用类型或指针而不是对象调用的,它将确定使用哪一种方法.如果没有使用关键字irtual,程序将根据引用类型或指针类型选择方法:如果使用了irtual,程序将根据引用或指针指向的对象的类型来选择方法.对于一个函数ViewAcct()来说,如果ViewAcct()不是虚的,则程序的行为如下:// behavior with non-virtual ViewAcct()// method chosen according to reference typeBrass

C#中Abstract和Virtual[转载]

原文:http://www.cnblogs.com/blsong/archive/2010/08/12/1798064.html 在C#的学习中,容易混淆virtual方法和abstract方法的使用,现在来讨论一下二者的区别.二者都牵涉到在派生类中与override的配合使用. 一.Virtual方法(虚方法) virtual 关键字用于在基类中修饰方法.virtual的使用会有两种情况: 情况1:在基类中定义了virtual方法,但在派生类中没有重写该虚方法.那么在对派生类实例的调用中,该虚

Modifiers: virtual, override, new, abstract, sealed, internal

internal 声明类.类成员.接口或接口成员具有内部可见性. internal 修饰符使类.接口或成员仅在当前包中可见. 当前包之外的代码不能访问 internal 成员.只有在同一程序集的文件中,内部类型或成员才是可访问的 在全局范围内,internal 修饰符与 public 修饰符相同. 不能将 internal 修饰符与其他任何可见性修饰符(public.private 或 protected)组合. 可见性修饰符相对于它们的定义范围. sealed 当对一个类应用 sealed 修

浅谈C#中new、override、virtual关键字的区别

OO思想现在已经在软件开发项目中广泛应用,其中最重要的一个特性就是继承,最近偶简单的学习了下在设计模式中涉及到继承这个特性时,所需要用到的关键字,其中有一些关键点,特地整理出来. 一.New 在C#中,new这个关键字使用频率非常高,主要有3个功能: a)   作为运算符用来创建一个对象和调用构造函数. b)   作为修饰符. c)   用于在泛型声明中约束可能用作类型参数的参数的类型. 在本文中,只具体介绍new作为修饰符的作用,在用作修饰符时,new关键字可以在派生类中隐藏基类的方法,也就说

C#中Abstract和Virtual的区别

c# 中 Abstract和Virtual比较容易混淆,都与继承有关,并且涉及override的使用.下面讨论一下二者的区别: 一.Virtual方法(虚方法) virtual 关键字用于在基类中修饰方法.virtual的使用会有两种情况: 情况1:在基类中定义了virtual方法,但在派生类中没有重写该虚方法.那么在对派生类实例的调用中,该虚方法使用的是基类定义的方法. 情况2:在基类中定义了virtual方法,然后在派生类中使用override重写该方法.那么在对派生类实例的调用中,该虚方法