子类含基类无的额外字段时，如何实现多态行为？

你的问题本质是混淆了“父类契约”和“子类特有细节”——里氏替换原则要求父类能被子类无缝替换，而直接访问子类字段的行为，本质是调用方依赖了父类未定义的细节，这才是问题根源，不是子类有额外属性的错。下面给几个实用的重构方案：

1. 用抽象方法封装子类特有信息的展示 #

最直接的方式是在父类里定义抽象方法，让子类自己负责展示或处理特有属性，调用方只需要调用父类定义的方法：

abstract class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public abstract void SayHello();
    // 父类定义契约：展示个人详情
    public abstract void ShowDetails();
}

class Student : Person
{
    public double Grade { get; set; }
    public string SchoolName { get; set; }

    public override void SayHello()
    {
        Console.WriteLine("Hi! I'm a student.");
    }

    public override void ShowDetails()
    {
        // 子类自己实现包含特有属性的逻辑
        Console.WriteLine($"我叫{Name}，今年{Age}岁，在{SchoolName}上学，成绩是{Grade}");
    }
}

// 调用时完全不需要关心子类类型
Person someone = new Student();
someone.SayHello();
someone.ShowDetails();

这种方式完全符合里氏替换原则：不管是Student还是其他Person子类，替换后调用ShowDetails都能正常输出对应信息，调用方不需要做任何类型判断。

2. 用接口拆分不同职责 #

如果Person的子类差异极大（比如还有Teacher、Doctor等，各自有完全不同的特有属性），继承可能会让父类变得臃肿，这时可以用接口拆分职责：

// 基础个人信息接口
interface IPerson
{
    string Name { get; set; }
    int Age { get; set; }
    void Greet();
}

// 学生特有行为接口
interface IStudent
{
    double Grade { get; set; }
    string SchoolName { get; set; }
    void ShowStudentProfile();
}

class Student : IPerson, IStudent
{
    public string Name { get; set; }
    public int Age { get; set; }
    public double Grade { get; set; }
    public string SchoolName { get; set; }

    public void Greet()
    {
        Console.WriteLine("Hi! I'm a student.");
    }

    public void ShowStudentProfile()
    {
        Console.WriteLine($"姓名：{Name}，年龄：{Age}，学校：{SchoolName}，成绩：{Grade}");
    }
}

调用时，在需要基础个人行为的地方用IPerson，需要学生特有行为的地方直接用IStudent，避免了不必要的类型转换。如果必须从IPerson转成IStudent，用接口转换比转具体类更灵活（比如以后有GraduateStudent也实现IStudent，同样能处理）。

3. 用访问者模式处理差异化逻辑 #

如果需要对不同Person子类做统一的差异化处理（比如导出不同格式的信息、存入不同数据库表），访问者模式可以彻底避免大量if-else或类型转换：

abstract class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public abstract void SayHello();
    // 接受访问者的方法
    public abstract void Accept(IPersonHandler handler);
}

class Student : Person
{
    public double Grade { get; set; }
    public string SchoolName { get; set; }

    public override void SayHello()
    {
        Console.WriteLine("Hi! I'm a student.");
    }

    public override void Accept(IPersonHandler handler)
    {
        // 把自己传递给访问者
        handler.HandleStudent(this);
    }
}

// 访问者接口：定义处理不同Person子类的方法
interface IPersonHandler
{
    void HandleStudent(Student student);
    // 新增子类时，只需要加对应的Handle方法，比如HandleTeacher(Teacher teacher)
}

// 具体处理类：展示详情
class ProfileDisplayer : IPersonHandler
{
    public void HandleStudent(Student student)
    {
        Console.WriteLine($"姓名：{student.Name}，年龄：{student.Age}，学校：{student.SchoolName}，成绩：{student.Grade}");
    }
}

// 调用示例
Person someone = new Student();
someone.Accept(new ProfileDisplayer());

这种方式把子类特有逻辑从Person类中抽离出来，集中到处理类里，新增子类时不需要修改原有代码，符合开闭原则。

核心要点 #

• 里氏替换原则不是不让子类有额外属性，而是调用方不能依赖父类未定义的属性/方法，直接访问子类字段是调用方的问题，不是子类的问题。
• 面向对象的核心是封装和抽象：永远通过方法（行为）操作对象，而不是直接扒字段。
• 避免向下转型的关键是：让调用方只依赖抽象（父类或接口），把子类特有逻辑交给子类自己或专门的处理类来实现。

内容的提问来源于stack exchange，提问作者oopEnthusiast