总结virtual override sealed new在方法上的应用

对于方法（属性、事件）

1.如想重写（扩展和修改继承）方法要求有两个

a.基类必须是virtual

b.继承类型的同签名方法必须override

也就是说基类和继承类都必须同意，重写才能实现

2.刚才只是说了只继承了一层的情况，但如果有多层集成，比如CClass:BClass:AClass

a.B中的某个方法M1是override A中的M1来的，这时如果C再重写M1的时候，就不要求B的M1有virtual关键字修饰了。重写(override)来的方法，默认也同意被其子类override(即便没有virtual其实也不能有virtual)。

b.当然如果不同意其子类重写这个方法也可以，override的时候加上sealed。

3.如果子类主动不想跟父类的同名方法有什么瓜葛，不带override就可以了，但是这样编译器会给个警告，如果不想看警告可以new一下，主动声明跟父类没啥瓜葛。

a)new的方法默认是不能被其子类重写的

b)new可以跟virtual合伙，表明欢迎子类重写这个方法（只有virtual也可以，多个编译警告）

c)只要跟父类有同签名方法new就可以存在，不论父类是否允许他的方法被重载

d) 跳跃重写(覆盖),如BClass没有重写M1,但是可以在其派生类CClass中重写.

e) 重写时有这样几种组合new/override/override sealed/new virtual/virtual(警告)

f) 派生类中无任何修饰的(空)同名虚拟方法,在其派生类中再重写时,产生错误;

如BClass中的M2无任何修饰(public void M2(){}),此时产生警告,在CClass中再重写(public override void M2(){}),这里产生错误,

就是说,跳跃重写的情况下,位于多层继承中间的派生类的方法必须有修饰,且只能有这三种修饰方式: override/new virtual/virtual(警告)

4.除了virtual还有abstract关键字，abstract比virtual还彻底，基类干脆就不实现任何功能了，就等着子类来override，所以abstract肯定也是同意做被派生类重载的。

5. 派生类中函数名与基类相同时,有四种情况,override,new,virtual,空,后两种编译器会产生警告.

总结几种方法的修饰组合及其结果

virtual：同意被重载

abstract：本方法没内容，派生类一定要记得重载我哦，除非派生类也是抽象的

override：同意重载父类的同名方法也同意被自己的子类重载

override sealed：同意重载父类但不同意被自己的子类重载（sealed只是配合override的，自己不会单独跑出来）

什么修饰都没有：不同意重载父类也不同意子类重载自己

new：特此声明，父类的同名方法跟我无关

virtual new：父类同名方法跟我无关，不过欢迎子类重载我

样例

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;

namespaceExample03
{
classProgram
{
staticvoidMain(string[]args)
{
AClassa=newCClass();
a.M1();
a.M2();
a.M3();
a.M4();
a.M5();
a.M6();
a.M7();
a.M8();
Console.WriteLine("-");
BClassb=newCClass();
b.M1();
b.M2();
b.M3();
b.M4();
b.M5();
b.M6();
b.M7();
b.M8();
Console.ReadLine();
}
}
publicclassCClass:BClass
{
publicoverridevoidM1()
{
Console.WriteLine("C.M1");
}
publicnewvoidM2()
{
Console.WriteLine("C.M2");
}
publicvoidM3()//(有编译警告)
{
Console.WriteLine("C.M3");
}
publicnewvoidM4()
{
Console.WriteLine("C.M4");
}
publicoverridevoidM5()
{
Console.WriteLine("C.M5");
}
publicnewvoidM6()
{
Console.WriteLine("C.M6");
}
publicnewvoidM7()
{
Console.WriteLine("C.M7");
}
publicnewvoidM8()
{
Console.WriteLine("C.M7");
}
}
publicabstractclassBClass:AClass
{
publicoverridevoidM1()//重写父类允许子类重写自己
{
Console.WriteLine("B.M1");
}
publicoverridevoidM2()//重写父类允许子类重写自己
{
Console.WriteLine("B.M2");
}
publicoverridevoidM3()//重写父类允许子类重写自己
{
Console.WriteLine("B.M3");
}
publicnewvoidM4()//不重写父类不允许子类重写自己
{
Console.WriteLine("B.M4");
}
publicnewvirtualvoidM5()//不重写父类允许子类重写自己
{
Console.WriteLine("B.M5");
}
publicnewvirtualvoidM6()//不重写父类允许子类重写自己
{
Console.WriteLine("B.M6");
}
publicoverridesealedvoidM7()//重写父类不允许子类重写自己
{
Console.WriteLine("B.M7");
}
publicvirtualvoidM8()//不重写父类允许子类重写自己(有编译警告)
{
Console.WriteLine("B.M8");
}
}
publicclassAClass
{
publicvirtualvoidM1()
{
Console.WriteLine("A.M1");
}
publicvirtualvoidM2()
{
Console.WriteLine("A.M2");
}
publicvirtualvoidM3()
{
Console.WriteLine("A.M3");
}
publicvirtualvoidM4()
{
Console.WriteLine("A.M4");
}
publicvirtualvoidM5()
{
Console.WriteLine("A.M5");
}
publicvirtualvoidM6()
{
Console.WriteLine("A.M6");
}
publicvirtualvoidM7()
{
Console.WriteLine("A.M7");
}
publicvirtualvoidM8()
{
Console.WriteLine("A.M8");
}
}
}

C.M1
B.M2
B.M3
A.M4
A.M5
A.M6
B.M7
A.M8
-
C.M1
B.M2
B.M3
B.M4
C.M5
B.M6
B.M7
B.M8