C# 继承与多态关键字:virtual、override、new、abstract、sealed

1940 字
10 分钟
C# 继承与多态关键字:virtual、override、new、abstract、sealed

本文只讲继承和多态相关关键字的语法与行为。面向对象的设计层面(什么时候该用继承、组合与继承的取舍、设计原则)见 面向对象。

virtual 与 override:运行时多态#

class Animal
{
public virtual string Speak() => "...";
}
class Dog : Animal
{
public override string Speak() => "汪";
}
Animal a = new Dog();
Console.WriteLine(a.Speak()); // 汪

变量 a 声明的类型是 Animal,但调用的是 Dog 的实现。调用哪个方法,取决于对象的实际类型,而不是变量声明的类型,这就是运行时多态。

  • virtual:声明一个方法允许被子类重写。C# 中方法默认不是虚方法,这一点和 Java 不同。
  • override:重写父类的 virtual、abstract 或 override 方法。签名和访问级别必须一致。
  • 属性、索引器、事件也可以是 virtual 的。static 方法不能是 virtual 的。

实现原理:虚方法表#

每个类型都有一张虚方法表(vtable),记录每个虚方法实际对应的实现。子类 override 时,会把表中对应的位置替换成自己的实现。

调用虚方法时,运行时先找到对象的实际类型,再查它的虚方法表,跳转到对应的实现。所以虚方法调用比普通方法调用多一次查表,而且通常无法被内联。

override 与 new:最常考的区别#

new 修饰方法时,表示隐藏父类的同名成员,而不是重写:

class Base
{
public virtual string A() => "Base.A";
public string B() => "Base.B";
}
class Derived : Base
{
public override string A() => "Derived.A";
public new string B() => "Derived.B";
}
Base b = new Derived();
Derived d = (Derived)b;
b.A(); // Derived.A override:看对象的实际类型
d.A(); // Derived.A
b.B(); // Base.B new:看变量声明的类型
d.B(); // Derived.B
overridenew
含义重写,替换父类的实现隐藏,子类另外定义一个同名成员
虚方法表替换父类的那一项新增一项,父类的那一项不变
通过父类变量调用执行子类的实现执行父类的实现
要求父类方法必须是 virtual、abstract 或 override没有要求

子类定义了和父类同名的成员却不写 new 时,效果和写了 new 一样,只是编译器会给出警告(CS0108),提醒你确认是否真的要隐藏。new 的作用就是明确告诉编译器”我是有意隐藏的”。

实际项目中,new 隐藏很容易造成”通过父类调用时行为不对”的问题,应尽量避免。

abstract#

abstract class Weapon
{
protected Weapon(string name) { Name = name; } // 抽象类可以有构造函数
public string Name { get; }
public abstract void Attack(); // 没有实现
public void Equip() { /* 普通方法 */ }
}
class Sword : Weapon
{
public Sword() : base("剑") { }
public override void Attack() { }
}
  • 抽象类不能实例化,可以包含抽象成员、普通成员、字段和构造函数。构造函数一般写成 protected,供子类调用。
  • 抽象成员没有实现,隐式就是 virtual 的。非抽象的子类必须重写所有抽象成员。
  • 抽象成员只能出现在抽象类中。

抽象类和接口都能定义”子类必须实现什么”,它们的设计取舍见 面向对象。这里只记语法上的主要区别:类只能继承一个抽象类,但能实现多个接口;抽象类可以有字段和构造函数,接口不行。

sealed#

sealed class FinalConfig { } // 不能被继承
class Derived : Base
{
public sealed override string A() => ""; // 子类不能再重写 A
}
  • 修饰类:禁止继承。
  • 修饰方法:只能和 override 一起使用,禁止子类继续重写这个方法。

去虚拟化:对 sealed 类型调用虚方法时,编译器和运行时能确定实际调用的是哪个实现,可以跳过查虚方法表,直接调用,甚至内联。IL2CPP 也会做这个优化。所以确定不需要被继承的类,加上 sealed 有一定的性能收益。

base 与 this#

base:访问父类的成员。

public override void Attack()
{
base.Attack(); // 先执行父类的实现
PlayEffect();
}
public Sword() : base("剑") { } // 调用父类的构造函数

this:当前实例。

public Enemy(string name) : this(name, 100) { } // 调用本类的另一个构造函数
public Enemy(string name, int hp) { this.name = name; this.hp = hp; }

this 还用于定义扩展方法的第一个参数,见 C# 关键字速查。

构造函数的执行顺序#

class Base
{
int a = Log("Base 字段初始化");
public Base() { Log("Base 构造函数"); }
}
class Derived : Base
{
int b = Log("Derived 字段初始化");
public Derived() { Log("Derived 构造函数"); }
}
new Derived();

输出顺序:

Derived 字段初始化
Base 字段初始化
Base 构造函数
Derived 构造函数

字段初始化器先于父类构造函数执行,然后从父类到子类依次执行构造函数体。字段初始化的顺序是从子类到父类,这一点和 Java 不同,容易答错。

陷阱:在构造函数中调用虚方法#

class Base
{
public Base() { Init(); } // 调用虚方法
protected virtual void Init() { }
}
class Derived : Base
{
List<int> _list;
public Derived() { _list = new List<int>(); }
protected override void Init() { _list.Add(1); } // NullReferenceException
}

new Derived() 时,父类构造函数调用 Init(),由于多态,执行的是子类的 Init()。但此时子类构造函数体还没执行,_list 还是 null。

结论:不要在构造函数中调用虚方法。如果字段改用字段初始化器 List<int> _list = new List<int>();,它会在父类构造函数之前执行,就不会出错,但依赖这种顺序很脆弱。

Unity 中:消息方法的继承#

Awake、Start、Update、OnDestroy 这些方法不是虚方法,是 Unity 按名字找到并调用的。所以继承时有个坑:

class BaseEnemy : MonoBehaviour
{
void Awake() { /* 初始化通用组件 */ }
}
class Boss : BaseEnemy
{
void Awake() { /* Boss 的初始化 */ } // 父类的 Awake 不会再执行
}

子类定义了 Awake,Unity 就只调用子类的,父类的初始化被跳过,而且编译器不会报错。

推荐写法:父类用 protected virtual,子类 override 并调用 base:

class BaseEnemy : MonoBehaviour
{
protected virtual void Awake() { /* 通用初始化 */ }
}
class Boss : BaseEnemy
{
protected override void Awake()
{
base.Awake();
/* Boss 的初始化 */
}
}

常见追问#

override 和 new 有什么区别? override 重写父类的虚方法,通过父类变量调用时执行子类的实现;new 隐藏父类的成员,通过父类变量调用时执行的仍是父类的实现。

虚方法是怎么实现的? 每个类型有一张虚方法表,子类重写时替换表中对应的项。调用时根据对象的实际类型查表,找到要执行的实现。

静态方法能不能是虚方法?构造函数呢? 都不能。多态依赖对象的实际类型,静态方法和构造函数调用时还没有(或不需要)对象。

抽象类能有构造函数吗? 能,供子类通过 base(...) 调用,一般声明为 protected。

sealed 有什么用? 禁止继承或禁止继续重写;还能让编译器和运行时把虚调用优化成直接调用。

父类和子类的构造函数、字段初始化,执行顺序是怎样的? 先子类字段初始化,再父类字段初始化,然后父类构造函数,最后子类构造函数。

为什么不要在构造函数里调用虚方法? 会执行子类的重写版本,而此时子类的构造函数体还没执行,子类的状态还没初始化好。

Unity 中父类和子类都写了 Awake 会怎样? 只会执行子类的。应该在父类中写 protected virtual void Awake(),子类 override 并调用 base.Awake()。

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

C# 继承与多态关键字:virtual、override、new、abstract、sealed
https://xslab.cloud/posts/csharp/keywords/inheritance-polymorphism/
作者
LuxFire
发布于
2026-10-10
许可协议
CC BY-NC-SA 4.0
随机文章 随机推荐
Profile Image of the Author
LuxFire
Hello, I'm LuxFire.
公告
欢迎来到我的博客!这是一则示例公告。
音乐
封面

音乐

暂未播放

0:00 0:00
暂无歌词
分类
标签
站点统计
文章
60
分类
6
标签
164
总字数
171,869
运行时长
0 天
最后活动
0 天前

文章目录