Java面向对象编程多态场景下子类特殊属性存储方案问询

针对多态传参无法访问子类特有属性、又不想写大量instanceof分支的问题，以下是几种可落地的解决方案：

方案一：将持久化逻辑下沉到子类（利用多态特性） #

核心思路是把每个子类特有属性的保存逻辑交给子类自己实现，父类定义统一的抽象方法，PersonManager只需调用这个统一方法，完全规避类型判断。

修改后代码示例： #

// 抽象父类Person
public abstract class Person {
    private int id;
    private String name;

    // 省略getter/setter

    // 定义抽象持久化方法
    public abstract void save();
}

// Student子类实现save方法
public class Student extends Person {
    private int studentNo;

    // 省略getter/setter

    @Override
    public void save() {
        System.out.println("saved: " + getName());
        System.out.println("saved: " + getId());
        System.out.println("saved: " + getStudentNo());
    }
}

// 简化后的PersonManager
public class PersonManager {
    public void add(Person person) {
        person.save();
    }
}

优点：完全符合开闭原则，新增子类只需实现save方法，无需修改PersonManager；代码简洁无冗余判断。
缺点：实体类与持久化逻辑耦合，若项目要求实体类为纯POJO，该方案不适用。

方案二：使用访问者模式（解耦实体与持久化逻辑） #

如果不想让实体类承担持久化职责，可通过访问者模式将不同子类的处理逻辑抽离到独立类中，避免大量instanceof判断。

代码示例： #

// 定义访问者接口
public interface PersonVisitor {
    void visitStudent(Student student);
    void visitTeacher(Teacher teacher);
    // 为每个Person子类添加对应visit方法
}

// 修改Person类，添加accept方法
public abstract class Person {
    private int id;
    private String name;

    // 省略getter/setter

    public abstract void accept(PersonVisitor visitor);
}

// Student实现accept方法
public class Student extends Person {
    private int studentNo;

    // 省略getter/setter

    @Override
    public void accept(PersonVisitor visitor) {
        visitor.visitStudent(this);
    }
}

// 实现持久化访问者
public class SavePersonVisitor implements PersonVisitor {
    @Override
    public void visitStudent(Student student) {
        System.out.println("saved: " + student.getName());
        System.out.println("saved: " + student.getId());
        System.out.println("saved: " + student.getStudentNo());
    }

    @Override
    public void visitTeacher(Teacher teacher) {
        // 处理Teacher特有属性的保存逻辑
    }
}

// PersonManager使用访问者
public class PersonManager {
    public void add(Person person) {
        PersonVisitor saveVisitor = new SavePersonVisitor();
        person.accept(saveVisitor);
    }
}

优点：实体类保持纯净，持久化逻辑集中在访问者类中，职责分离；新增子类只需扩展访问者接口和实现类，比大量instanceof更易维护。
缺点：新增子类时需修改访问者接口及所有实现类，有一定的扩展成本。

方案三：基于反射的通用处理（仅作备选） #

如果使用ORM框架（如MyBatis、Hibernate），框架本身已通过反射处理子类特有属性的持久化。若自定义持久化，可通过反射获取对象所有字段统一处理：

public class PersonManager {
    public void add(Person person) {
        Field[] fields = person.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            try {
                System.out.println("saved: " + field.getName() + " = " + field.get(person));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }
}

优点：无需修改实体类，新增子类无需额外代码。
缺点：</think_never_used_51bce0c785ca2f68081bfa7d91973934>反射性能较低，无法处理复杂字段逻辑（如加密、字段转换），仅适合简单场景。

内容的提问来源于stack exchange，提问作者Davut Boztaş