Java中instanceof能否检查外围类？如何区分子类静态内部类实例

问题本质 #

首先得明确：静态内部类不会跟着外围类的继承产生新的类。你代码里的CarA.Wheel和CarB.Wheel其实都是Car.Wheel的别名，所有Wheel实例的实际类型完全一样——这就是为什么所有instanceof检查都返回true，因为instanceof只能判断实例的实际类型，没法关联到它的外围类引用。

可行解决方案（不用重复写Wheel类） #

1. 给Wheel加个外围类标记字段 #

最直接的方式是让每个Wheel实例记住自己关联的外围类类型，通过构造方法传入，然后自定义检查方法替代instanceof：

public class Car {
    public static class Wheel {
        // 存储关联的外围类类型
        private final Class<?> outerType;

        public Wheel(Class<?> outerType) {
            this.outerType = outerType;
        }

        // 自定义检查方法
        public boolean belongsTo(Class<?> outerClass) {
            return this.outerType == outerClass;
        }
    }
}

class CarA extends Car {}
class CarB extends Car {}

使用时创建Wheel就传入对应外围类：

public class x {
    public static void main(String[] args) {
        Car.Wheel caw = new Car.Wheel(CarA.class);
        Car.Wheel cbw = new Car.Wheel(CarB.class);
        
        System.out.println(caw.belongsTo(CarA.class)); // true
        System.out.println(caw.belongsTo(CarB.class)); // false
        System.out.println(cbw.belongsTo(CarA.class)); // false
        System.out.println(cbw.belongsTo(CarB.class)); // true
    }
}

2. 用泛型做编译期约束+运行时标记 #

如果想在编译期就避免关联错误的外围类，可以用泛型绑定：

public class Car<T extends Car<T>> {
    public static class Wheel<U extends Car<U>> {
        private final Class<U> outerType;

        public Wheel(Class<U> outerType) {
            this.outerType = outerType;
        }

        public boolean belongsTo(Class<U> outerClass) {
            return this.outerType == outerClass;
        }
    }
}

// 子类继承时指定泛型参数
class CarA extends Car<CarA> {}
class CarB extends Car<CarB> {}

使用时能得到编译期类型提示：

public class x {
    public static void main(String[] args) {
        Car.Wheel<CarA> caw = new Car.Wheel<>(CarA.class);
        Car.Wheel<CarB> cbw = new Car.Wheel<>(CarB.class);
        
        System.out.println(caw.belongsTo(CarA.class)); // true
        System.out.println(caw.belongsTo(CarB.class)); // false
        System.out.println(cbw.belongsTo(CarA.class)); // false
        System.out.println(cbw.belongsTo(CarB.class)); // true
    }
}

3. 用工厂方法封装创建逻辑 #

不想让外部直接处理Wheel的构造？可以在每个外围子类里加静态工厂方法，把关联逻辑藏起来：

public class Car {
    public static class Wheel {
        private final Class<?> outerType;

        // 把构造方法设为私有，只能通过工厂创建
        private Wheel(Class<?> outerType) {
            this.outerType = outerType;
        }

        public boolean belongsTo(Class<?> outerClass) {
            return this.outerType == outerClass;
        }
    }
}

class CarA extends Car {
    public static Wheel createWheel() {
        return new Wheel(CarA.class);
    }
}

class CarB extends Car {
    public static Wheel createWheel() {
        return new Wheel(CarB.class);
    }
}

使用时更简洁：

public class x {
    public static void main(String[] args) {
        Car.Wheel caw = CarA.createWheel();
        Car.Wheel cbw = CarB.createWheel();
        
        System.out.println(caw.belongsTo(CarA.class)); // true
        System.out.println(caw.belongsTo(CarB.class)); // false
        System.out.println(cbw.belongsTo(CarA.class)); // false
        System.out.println(cbw.belongsTo(CarB.class)); // true
    }
}

总结 #

直接用instanceof做不到区分，因为所有Wheel实例都是同一个类的对象。但上面几种方法都不用重复实现Wheel类，只需要给每个Wheel实例绑定对应的外围类信息，就能实现你要的区分逻辑。

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