My-Notes/笔记/CSharp/核心/密封函数.md

# 密封函数
概念：
	密封函数指的是使用 `sealed` 修饰的==重写成员==
	在 C# 里常见写法是 `sealed override`

准确一点说：
	C# 里通常叫“密封方法”或“密封重写成员”
	有些教程会说“密封函数”，初学阶段可以理解成：==不允许下一级子类继续重写的方法==

通常用法：
1. 父类允许子类重写某个方法
2. 某个子类重写后，认为这个实现已经定死
3. 允许这个子类继续被继承
4. 但不允许更下一级子类再改这个方法

----
# 语法
```csharp
class 子类名 : 父类名
{
	public sealed override void 方法名()
	{

	}
}
```

注意：
	`sealed` 修饰方法时，必须和 `override` 一起使用

----
# 基础案例
```csharp
class Animal
{
	public virtual void Speak()
	{
		Console.WriteLine("动物叫");
	}
}

class Dog : Animal
{
	public sealed override void Speak()
	{
		Console.WriteLine("狗叫");
	}
}

class Husky : Dog
{
	// 这里不能再 override Speak()
}
```

理解：
1. `Animal.Speak()` 是虚方法，允许被重写
2. `Dog.Speak()` 重写了父类方法
3. `Dog.Speak()` 又被 `sealed` 密封
4. `Husky` 可以继承 `Dog`
5. 但 `Husky` 不能继续重写 `Speak()`

----
# sealed class 和 sealed override 的区别
密封类：
```csharp
sealed class Dog : Animal
{

}
```

含义：
	整个 `Dog` 类不能再被继承

密封函数：
```csharp
class Dog : Animal
{
	public sealed override void Speak()
	{
		Console.WriteLine("狗叫");
	}
}
```

含义：
	`Dog` 类仍然可以被继承
	但是 `Speak()` 不能再被下一级子类重写

对比：
1. `sealed class`：封住整个类
2. `sealed override`：只封住某个已经重写的成员

这个点可以和[[密封类]]一起记。

----
# 为什么密封函数必须是 override
错误写法：
```csharp
class Dog
{
	public sealed void Speak()
	{
	}
}
```

原因：
	普通方法本来就不能被 `override`
	没有必要再用 `sealed` 封住

正确理解：
	`sealed` 修饰方法时，是在说：
	“这个方法原本处在可重写链条上，但从我这里开始不准继续重写”

所以它必须修饰已经重写的成员，也就是 `sealed override`。

----
# 多级继承案例
```csharp
class A
{
	public virtual void Test()
	{
		Console.WriteLine("A");
	}
}

class B : A
{
	public override void Test()
	{
		Console.WriteLine("B");
	}
}

class C : B
{
	public sealed override void Test()
	{
		Console.WriteLine("C");
	}
}

class D : C
{
	// public override void Test()
	// {
	//     Console.WriteLine("D");
	// }
}
```

调用：
```csharp
A a = new C();
a.Test(); // C
```

理解：
1. `A.Test()` 开启虚方法
2. `B.Test()` 继续重写
3. `C.Test()` 重写并密封
4. `D` 仍然可以继承 `C`
5. 但 `D` 不能再重写 `Test()`

----
# 密封属性
`sealed override` 不只可以用于方法，也可以用于属性。

```csharp
class Character
{
	public virtual int MaxHp
	{
		get { return 100; }
	}
}

class Boss : Character
{
	public sealed override int MaxHp
	{
		get { return 1000; }
	}
}
```

后续子类不能再重写 `MaxHp`。

----
# 和多态的关系
密封函数不会取消已有多态效果。

```csharp
Animal animal = new Dog();
animal.Speak(); // 狗叫
```

`Dog.Speak()` 仍然会通过多态被调用。

`sealed override` 只是限制：
	后续子类不能继续改这个方法

也就是说：
1. 对上层父类来说，它仍然是重写后的多态方法
2. 对下层子类来说，它已经不能再被重写

----
# 常见错误
错误1：普通方法前写 `sealed`
```csharp
class A
{
	public sealed void Test()
	{
	}
}
```

`sealed` 不能这样修饰普通方法。

----
错误2：只写 `sealed` 不写 `override`
```csharp
class B : A
{
	public sealed void Test()
	{
	}
}
```

密封重写成员必须写成 `sealed override`。

----
错误3：父类方法不是虚方法
```csharp
class A
{
	public void Test()
	{
	}
}

class B : A
{
	public sealed override void Test()
	{
	}
}
```

父类方法不是 `virtual` / `abstract` / `override`，子类不能 `override`，也就不能 `sealed override`。

----
# 什么时候用密封函数
适合用的情况：
1. 某个重写逻辑非常关键，不希望后续子类改掉
2. 父类设计允许多态，但某一层子类希望终止这个方法的重写链
3. 框架或基础类库中需要保证关键行为稳定

初学阶段：
	先知道这个语法和作用即可
	自己写练习代码时用得不多

----
# 注意
1. 密封函数常见写法是 `sealed override`
2. 它只能用于已经重写的成员
3. 它阻止下一级子类继续重写这个成员
4. 它不会阻止当前类被继承
5. 如果想阻止整个类被继承，用 `sealed class`
6. 方法、属性、索引器、事件等重写成员都可以理解这个规则

----
# 一句话记忆
==sealed override 表示这个重写到我这里为止，后面的子类不能再改。==

----
# 面试/复习时怎么说
可以这样答：

“密封函数通常指 `sealed override` 修饰的重写方法。  
它表示当前类重写了父类的虚方法，但不允许更下一级子类继续重写。  
它和密封类不同，密封类是不允许整个类被继承，而密封函数只是禁止某个重写成员继续被重写。”

----
引用：
1. Microsoft Learn: [sealed (C# Reference)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/sealed)
2. Microsoft Learn: [override (C# Reference)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/override)

#密封函数
#密封方法
#核心