在C#的面向对象编程体系里，抽象类、密封类与类成员是控制类继承关系、规范代码结构的核心特性，合理运用这些特性可以让类的设计更符合业务逻辑需求，同时提升代码的复用性和安全性。
抽象类的定义与使用
抽象类是使用abstract关键字修饰的类，它不能被实例化，只能作为其他类的基类存在。抽象类可以包含抽象成员，也可以包含已经实现的具体成员，抽象成员没有具体的方法体，需要子类必须重写实现。
抽象类的常见使用场景是定义一组具有共性的基类，把通用的逻辑放在抽象类中实现，把需要子类差异化实现的逻辑定义为抽象成员。
抽象类的语法示例
下面是一个定义抽象类及其子类的示例：
// 定义抽象类Shape
public abstract class Shape
{
// 具体成员：所有形状都有的属性
public string Name { get; set; }
// 具体方法：通用逻辑
public void PrintName()
{
Console.WriteLine($"形状名称：{Name}");
}
// 抽象方法：计算面积，子类必须实现
public abstract double CalculateArea();
// 抽象属性：获取形状类型，子类必须实现
public abstract string ShapeType { get; }
}
// 定义圆形类继承Shape
public class Circle : Shape
{
// 圆形的特有属性
public double Radius { get; set; }
public Circle(string name, double radius)
{
Name = name;
Radius = radius;
}
// 重写抽象方法
public override double CalculateArea()
{
return Math.PI * Radius * Radius;
}
// 重写抽象属性
public override string ShapeType
{
get { return "圆形"; }
}
}
// 使用示例
class Program
{
static void Main()
{
// 错误：不能实例化抽象类
// Shape shape = new Shape();
Circle circle = new Circle("圆形A", 5);
circle.PrintName();
Console.WriteLine($"面积：{circle.CalculateArea()}");
Console.WriteLine($"类型：{circle.ShapeType}");
}
}
密封类的定义与使用
密封类是使用sealed关键字修饰的类，它的核心作用是禁止其他类继承该类，避免类被意外派生，常用于一些功能已经完整、不需要扩展的类，或者出于安全、性能考虑不希望被继承的类。
除了密封类之外，还可以使用sealed修饰重写的方法，防止该方法在更下层的子类中被再次重写。
密封类的语法示例
// 定义密封类，不允许被继承
public sealed class Logger
{
public void Log(string message)
{
Console.WriteLine($"[日志] {DateTime.Now}: {message}");
}
}
// 错误：不能继承密封类
// public class FileLogger : Logger { }
// 基类
public class BaseClass
{
public virtual void Show()
{
Console.WriteLine("基类方法");
}
}
// 派生类
public class DerivedClass : BaseClass
{
// 密封重写的方法，子类不能再重写Show方法
public sealed override void Show()
{
Console.WriteLine("派生类重写的方法");
}
}
// 子派生类
public class SubDerivedClass : DerivedClass
{
// 错误：不能重写密封的方法
// public override void Show() { }
}
C#类成员的常用修饰符
类的成员包括字段、属性、方法、构造函数等，不同的修饰符可以控制类成员的访问权限、继承行为等，以下是常用的类成员修饰符说明：
| 修饰符 | 作用说明 |
|---|---|
public | 成员可以被任何代码访问 |
private | 成员只能被当前类内部访问，默认修饰符 |
protected | 成员可以被当前类及其子类访问 |
internal | 成员可以被同一个程序集内的代码访问 |
virtual | 标记方法或属性可以被子类重写 |
override | 标记子类重写了基类的虚成员或抽象成员 |
abstract | 标记成员为抽象成员，只能在抽象类中定义，子类必须实现 |
sealed | 修饰重写的方法，防止该方法被更下层的子类再次重写 |
static | 标记成员为静态成员，属于类本身，不属于实例 |
类成员使用示例
public class Person
{
// 私有字段，只能在类内部访问
private int age;
// 公共属性，控制年龄的访问逻辑
public int Age
{
get { return age; }
set
{
if (value >= 0 && value <= 150)
{
age = value;
}
}
}
// 受保护的方法，子类可以调用
protected void PrintBaseInfo()
{
Console.WriteLine("这是Person类的基础信息");
}
// 虚方法，子类可以重写
public virtual void SayHello()
{
Console.WriteLine("你好，我是人类");
}
// 静态成员，属于类本身
public static int TotalCount { get; set; }
public Person()
{
TotalCount++;
}
}
public class Student : Person
{
// 重写基类的虚方法
public override void SayHello()
{
Console.WriteLine($"你好，我是学生，年龄{age}"); // 错误：age是private，不能直接访问
Console.WriteLine($"你好，我是学生，年龄{Age}");
PrintBaseInfo(); // 可以调用基类的protected方法
}
}
三者的使用注意事项
- 抽象类不能实例化，也不能被
sealed修饰，因为抽象类本身需要被继承才能实现其抽象成员，而密封类禁止继承，两者语义冲突。 - 抽象成员只能定义在抽象类中，不能定义在普通类或密封类中。
- 密封类的设计要谨慎，一旦标记为密封，后续如果需要扩展就必须修改原有类的代码，可能违反开闭原则。
- 类成员的修饰符要根据实际需求选择，尽量缩小成员的访问范围，符合封装的设计原则，比如不需要对外暴露的成员优先使用
private或protected。
合理搭配抽象类、密封类与类成员修饰符，可以让类的继承结构更清晰，既保证代码的扩展性，也避免不必要的继承带来的维护成本。