Java instanceof 运算符

在 Java 面向对象编程中，instanceof 是一个用于运行时类型检查的关键字。它判断一个对象引用是否是指定类（或其子类、实现类）的实例，返回 true 或 false。这是实现安全向下转型和多态处理的重要工具。

学习目标

理解 instanceof 的作用与语法
掌握其在继承体系中的行为规则
学会结合类型转换实现安全访问子类成员
了解 null 引用的特殊处理
避免常见误用场景

什么是 `instanceof`？

instanceof 是 Java 中的二元运算符，用于检查左侧对象引用是否是右侧类 / 接口类型的实例（包括其子类或实现类）。

referenceVariable instanceof ClassName

返回值：boolean（true 或 false）
左侧必须是引用类型变量（不能是基本类型）
右侧必须是类、接口或数组类型
若左侧为 null，结果恒为 false

✅ 重要特性：instanceof 检查的是对象的实际类型，而非引用变量的声明类型。

核心行为示例

示例 1：基础用法

class GFG { }

public class Main {
    public static void main(String[] args) {
        GFG obj = new GFG();
        System.out.println(obj instanceof GFG); // true
    }
}

输出：true —— 对象确实是 GFG 类的实例。

示例 2：继承关系中的行为

class Parent { }
class Child extends Parent { }

public class Main {
    public static void main(String[] args) {
        Child c = new Child();

        System.out.println(c instanceof Child);  // true
        System.out.println(c instanceof Parent); // true（子类也是父类）
        System.out.println(c instanceof Object); // true（所有类继承 Object）
    }
}

💡 关键规则：
子类对象 instanceof 父类 → true
对象 instanceof 其任意祖先类 → true

示例 3：`null` 引用的处理

class Test { }

public class Main {
    public static void main(String[] args) {
        Test t = null;
        System.out.println(t instanceof Test); // false
    }
}

⚠️ 安全设计：即使引用为 null，也不会抛出异常，而是返回 false，避免空指针错误。

示例 4：父类引用指向子类对象

Parent p = new Child(); // 向上转型（Upcasting）

System.out.println(p instanceof Child);  // true
System.out.println(p instanceof Parent); // true

🔍 尽管 p 声明为 Parent 类型，但实际对象是 Child，因此 p instanceof Child 为 true。

示例 5：父类对象不是子类实例

Parent p = new Parent();
System.out.println(p instanceof Child); // false

❌ 父类对象不能被视为子类实例，这是类型安全的基本保障。

实际应用场景：安全向下转型

在多态编程中，我们常使用父类引用操作子类对象。若需访问子类特有成员，必须进行向下转型（Downcasting），而 instanceof 是确保转型安全的关键。

问题背景

class Parent {
    int value = 1000;
}

class Child extends Parent {
    int value = 10; // 隐藏父类字段
}

public class Main {
    public static void main(String[] args) {
        Parent ref = new Child(); // 父类引用指向子类对象

        // 直接通过 ref 访问 value → 得到 1000（编译时绑定）
        System.out.println(ref.value); // 1000

        // 如何获取子类的 value = 10？
    }
}

解决方案：`instanceof` + 类型转换

if (ref instanceof Child) {
    Child childRef = (Child) ref; // 安全向下转型
    System.out.println(childRef.value); // 10
}

完整示例

class Parent {
    int value = 1000;
}

class Child extends Parent {
    int value = 10;
}

public class Test {
    public static void main(String[] args) {
        Parent par = new Child();

        if (par instanceof Child) {
            System.out.println("Value via casting: " + ((Child) par).value);
            // 输出: Value via casting: 10
        }
    }
}

✅ 最佳实践：永远在强制类型转换前使用 instanceof 检查，避免 ClassCastException。

使用限制与注意事项

1. 编译时类型兼容性检查

String s = "Hello";
// 编译错误！String 和 List 无继承关系
// System.out.println(s instanceof List);

📌 Java 编译器会阻止明显不相关的类型比较（如 String instanceof List），除非存在继承或实现关系。

2. 不能用于基本数据类型

int x = 5;
// 编译错误：基本类型不能用于 instanceof
// System.out.println(x instanceof Integer);

✅ 必须使用包装类（如 Integer）或对象引用。

3. 接口也支持 `instanceof`

List<String> list = new ArrayList<>();
System.out.println(list instanceof List);     // true
System.out.println(list instanceof ArrayList); // true
System.out.println(list instanceof Collection); // true

优势总结

优势	说明
运行时安全	避免非法类型转换导致的 `ClassCastException`
空安全	对 `null` 返回 `false`，无需额外判空
支持多态	正确识别对象的实际类型（而非引用类型）
简洁高效	单行代码完成类型验证

重点总结

instanceof 检查对象的实际运行时类型
子类对象 instanceof 父类 → true
父类对象 instanceof 子类 → false
null instanceof AnyType → false
必须先用 instanceof 检查，再进行向下转型
适用于类、接口、数组类型，不适用于基本类型

思考题

以下代码输出什么？为什么？

Object obj = "Hello";
System.out.println(obj instanceof String);    // ?
System.out.println(obj instanceof Object);    // ?
System.out.println(obj instanceof Serializable); // ?

在什么情况下，即使 obj instanceof MyClass 为 true，(MyClass) obj 仍可能抛出异常？
如何利用 instanceof 实现一个能处理多种图形（Circle、Rectangle）的通用面积计算方法？