栈中父类引用指向子类对象时，如何判断实际类型并转换？

嘿，这个问题在Java面向对象开发里太常见了！你需要的是**运行时类型识别（RTTI）**的技巧，我给你两种实用的实现方式，再聊聊更优雅的优化思路：

方法一：使用instanceof关键字 #

这是最常用的方式，它会检查对象是否是某个类（或其子类）的实例，非常适配你的场景：

Father newFather = myStack.pop();

if (newFather instanceof Son1) {
    Son1 newSon1 = (Son1) newFather;
    // 这里可以放心调用Son1独有的方法，比如 newSon1.son1ExclusiveMethod();
} else if (newFather instanceof Son2) {
    Son2 newSon2 = (Son2) newFather;
    // 调用Son2的专属方法，比如 newSon2.son2ExclusiveMethod();
} else {
    // 处理意外情况：比如栈里混入了其他Father子类对象
    throw new IllegalArgumentException("Unexpected object type in stack: " + newFather.getClass().getName());
}

instanceof的好处是兼容继承关系——如果未来你给Son1加了个子类，这个判断依然能生效；但如果你需要严格匹配精确类型，可以看下面的方法。

方法二：使用getClass()做精确类型匹配 #

如果你确定栈里只有Son1和Son2的直接实例，没有它们的子类，用getClass()+equals()能做严格的类型校验：

Father newFather = myStack.pop();
Class<?> actualClass = newFather.getClass();

if (actualClass.equals(Son1.class)) {
    Son1 newSon1 = (Son1) newFather;
    newSon1.son1ExclusiveMethod();
} else if (actualClass.equals(Son2.class)) {
    Son2 newSon2 = (Son2) newFather;
    newSon2.son2ExclusiveMethod();
} else {
    // 异常处理逻辑
    System.err.println("Unknown object type: " + actualClass);
}

这种方式不会匹配子类，比如如果有个GrandSon1 extends Son1的对象，getClass()返回的是GrandSon1.class，不会进入Son1的分支，适合类型严格可控的场景。

额外建议：优先用多态重构（更优雅的方案） #

虽然上面的类型判断能解决问题，但如果你的业务场景经常需要这么做，其实违背了面向对象的多态原则。可以考虑在父类里定义抽象方法，让子类各自实现：

// 父类定义抽象方法
abstract class Father {
    public abstract void executeSpecificLogic();
}

// Son1实现自己的逻辑
class Son1 extends Father {
    @Override
    public void executeSpecificLogic() {
        // Son1专属的业务逻辑
        this.son1ExclusiveMethod();
    }

    public void son1ExclusiveMethod() {
        // ...
    }
}

// Son2实现自己的逻辑
class Son2 extends Father {
    @Override
    public void executeSpecificLogic() {
        // Son2专属的业务逻辑
        this.son2ExclusiveMethod();
    }

    public void son2ExclusiveMethod() {
        // ...
    }
}

这样你pop之后根本不需要判断类型，直接调用方法就行：

Father newFather = myStack.pop();
newFather.executeSpecificLogic(); // 自动调用对应子类的实现

这种方式代码更简洁，也更符合面向对象的设计思想，只有当子类的方法实在无法统一抽象时，再用前面的类型判断方案。

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