使用instanceof通过父类引用访问子类变量是否不妥？如何优化重构？

用instanceof配合强制类型转换来访问子类特有的变量/方法确实是不推荐的写法——这种代码会紧耦合具体子类类型，违反开闭原则，新增子类时必须修改判断逻辑，大量的if-else也会让代码变得臃肿、难以维护。

针对你的场景（复用Person类的通用代码，同时在特定模式下访问Employee的特有属性），可以试试以下几种重构方案：

方案1：利用多态抽象子类特有行为 #

在父类Person中定义一个默认实现的方法，子类Employee重写该方法返回特有属性，其他子类（如果有的话）保持默认实现。这样无需判断类型，直接调用方法即可。

示例代码：

class Person {
    String name;
    int age;

    // 父类定义默认方法，返回null或抛出异常（根据业务场景选择）
    public String getEmploymentInfo() {
        return null;
    }
}

class Employee extends Person {
    String employment;

    @Override
    public String getEmploymentInfo() {
        return this.employment;
    }
}

使用时直接调用：

Person p = new Employee();
String employment = p.getEmploymentInfo();
// 根据返回值是否为null判断是否是Employee类型，或直接处理

这种方案改动最小，完全符合面向对象的多态设计，后续新增子类只需重写方法，无需修改调用逻辑。

方案2：使用访问者模式集中类型判断 #

如果需要对不同子类执行多种差异化操作，访问者模式可以把类型判断逻辑集中到访问者类中，避免在业务代码里散落大量if-else。

示例代码：

// 定义访问者接口
interface PersonVisitor {
    void visit(Person person);
    void visit(Employee employee);
}

class Person {
    String name;
    int age;

    // 父类实现接受访问者的方法
    public void accept(PersonVisitor visitor) {
        visitor.visit(this);
    }
}

class Employee extends Person {
    String employment;

    @Override
    public void accept(PersonVisitor visitor) {
        visitor.visit(this); // 让访问者处理Employee类型
    }
}

// 具体访问者：获取就业信息
class EmploymentInfoVisitor implements PersonVisitor {
    private String employmentInfo;

    @Override
    public void visit(Person person) {
        employmentInfo = null; // 非Employee类型返回null
    }

    @Override
    public void visit(Employee employee) {
        employmentInfo = employee.employment;
    }

    public String getEmploymentInfo() {
        return employmentInfo;
    }
}

使用时：

Person p = new Employee();
EmploymentInfoVisitor visitor = new EmploymentInfoVisitor();
p.accept(visitor);
String info = visitor.getEmploymentInfo();

这种方式适合有多种子类操作的场景，新增子类时只需扩展访问者接口和实现，业务代码无需修改。

方案3：用组合替代继承（调整类关系） #

如果Employee和Person的关系并非严格的"is-a"（比如就业信息只是某模式下的附加属性），可以用组合代替继承：让Employee持有Person实例，通过委托复用Person的通用代码，同时扩展自己的属性。

示例代码：

class Person {
    String name;
    int age;

    // 通用方法
    public void printBasicInfo() {
        System.out.println(name + ", " + age);
    }
}

class Employee {
    private Person person;
    String employment;

    public Employee(Person person) {
        this.person = person;
    }

    // 委托调用Person的通用方法
    public void printBasicInfo() {
        person.printBasicInfo();
    }

    // 特有属性的访问方法
    public String getEmployment() {
        return employment;
    }
}

这种方式避免了继承带来的类型耦合，但如果之前已经大量使用Person引用，重构成本会较高，适合还未形成大量依赖的场景。

方案4：封装类型转换工具（过渡方案） #

如果暂时无法大规模重构，又想简化instanceof的丑陋写法，可以封装一个工具方法，用Optional处理类型转换：

示例代码：

public class TypeCastUtil {
    public static <T> Optional<T> safeCast(Object obj, Class<T> clazz) {
        if (clazz.isInstance(obj)) {
            return Optional.of(clazz.cast(obj));
        }
        return Optional.empty();
    }
}

使用时：

Person p = new Employee();
TypeCastUtil.safeCast(p, Employee.class).ifPresent(employee -> {
    // 处理Employee的特有属性
    System.out.println(employee.employment);
});

这种方式只是优化了代码写法，本质还是类型判断，但比一堆if-else要清爽，适合过渡阶段使用。

最后总结下：
优先推荐多态方案，它最贴合面向对象设计，改动最小且扩展性最好；如果需要对不同子类执行多种差异化操作，选择访问者模式；如果继承关系不合理，考虑组合替代继承；过渡阶段可以用工具类简化类型转换。

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