核心方法

Java 提供了三种主要的方式来判断对象类型：

1. instanceof 运算符 (推荐)
2. getClass() 方法
3. isInstance() 方法 (与 instanceof 类似，但更灵活)

instanceof 运算符 (最常用、最推荐)

instanceof 是 Java 的一个二元运算符，用于测试一个对象是否是一个特定类或其子类的实例，或者是否实现了一个特定的接口。

语法

object instanceof Type

• object: 要检查的对象变量。
• Type: 一个类名、接口名或数组类型。

返回值

• true: object 是 Type 的一个实例，或者是 Type 的子类/子接口的实例。
• false: object 是 null，或者不是 Type 的实例。

示例

// 定义类和接口
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
interface Pet {}
class DogPet extends Dog implements Pet {}
public class InstanceofExample {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        Cat cat = new Cat();
        DogPet dogPet = new DogPet();
        Object obj = new Object();
        Object nullObj = null;
        // 1. 检查是否是特定类的实例
        System.out.println(dog instanceof Dog);      // true: Dog是Dog的实例
        System.out.println(dog instanceof Animal);   // true: Dog是Animal的子类，所以也是Animal的实例
        System.out.println(animal instanceof Dog);   // false: Animal不是Dog的实例
        // 2. 检查是否实现了接口
        System.out.println(dogPet instanceof Pet);    // true: DogPet实现了Pet接口
        System.out.println(dog instanceof Pet);      // false: Dog没有直接实现Pet接口
        System.out.println(dogPet instanceof Dog);   // true: DogPet是Dog的子类
        // 3. 检查与Object的关系
        System.out.println(dog instanceof Object);   // true: 所有Java类都直接或间接继承自Object
        System.out.println(obj instanceof Animal);   // false: Object不是Animal的实例
        // 4. 处理 null
        System.out.println(nullObj instanceof Animal); // false: instanceof对null总是返回false，不会抛出异常
    }
}

Java 14+ 的模式匹配 (Pattern Matching for instanceof)

从 Java 14 开始，instanceof 增强了功能，可以在判断的同时进行类型转换，使代码更简洁。

旧式写法 (Java 14 之前):

Object obj = "Hello, World!";
if (obj instanceof String) {
    String str = (String) obj; // 需要手动转换
    int length = str.length();
    System.out.println("Length is: " + length);
}

新式写法 (Java 14+):

Object obj = "Hello, World!";
if (obj instanceof String str) { // 自动转换并声明新变量 str
    int length = str.length(); // str 在这里已经是 String 类型
    System.out.println("Length is: " + length);
}

这种方式不仅代码更短,而且更安全，因为它避免了手动强制转换可能带来的 ClassCastException。

getClass() 方法

getClass() 是 Object 类中的一个方法，它返回该对象的运行时类（Class 对象）。

语法

Class<?> clazz = object.getClass();

返回值

• 一个 Class 对象，代表了对象的确切运行时类型。
• object 是 null，调用 getClass() 会抛出 NullPointerException。

instanceof vs getClass()

这是两者最关键的区别：

• instanceof 会考虑继承关系，它检查的是对象是否是某个类或其父类的实例。
• getClass() 不考虑继承关系，它检查的是对象的精确类型是否匹配。

示例

class Animal {}
class Dog extends Animal {}
public class GetClassExample {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        // 使用 getClass()
        System.out.println(dog.getClass() == Dog.class);       // true: 精确类型是 Dog
        System.out.println(dog.getClass() == Animal.class);   // false: 精确类型不是 Animal
        // 使用 instanceof
        System.out.println(dog instanceof Dog);                // true
        System.out.println(dog instanceof Animal);             // true (考虑了继承)
        // 一个实际的场景：重写 equals() 方法
        // 在 equals() 方法中，通常先检查 class 是否相同，以避免子类与父类比较逻辑混乱
        Animal a1 = new Animal();
        Animal a2 = new Dog();
        // 如果只使用 instanceof，可能会导致 a1.equals(a2) 和 a2.equals(a1) 结果不一致
        // 或者违反 equals 的对称性契约。
        // 一个健壮的 equals() 方法会这样做：
        if (this.getClass() != obj.getClass()) {
            return false;
        }
        // ... 然后再进行具体内容的比较
    }
}

何时使用 getClass()？ 当你需要检查对象的精确类型，并且不希望子类与父类被同等对待时，最常见的场景是在重写 equals() 和 hashCode() 方法时。

Class.isInstance() 方法

Class 类中的 isInstance(Object obj) 方法的作用与 instanceof 运算符完全相同，它检查指定的对象是否是该 Class 对象表示的类或接口的实例。

语法

Class<?> clazz = SomeClass.class;
boolean result = clazz.isInstance(object);

instanceof vs isInstance()

示例

class Animal {}
class Dog extends Animal {}
public class IsInstanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Animal animal = new Animal();
        // 等价于 dog instanceof Animal
        System.out.println(Animal.class.isInstance(dog)); // true
        // 等价于 animal instanceof Dog
        System.out.println(Dog.class.isInstance(animal)); // false
        // 动态获取 Class 对象
        String className = "java.lang.String";
        try {
            Class<?> dynamicClass = Class.forName(className);
            System.out.println(dynamicClass.isInstance("test")); // true
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

何时使用 isInstance()？ 当你需要在运行时动态地获取 Class 对象，然后进行类型检查时，这在反射 编程中非常常见。

总结与最佳实践

核心原则

1. 优先使用 instanceof：在绝大多数情况下，instanceof 是最清晰、最安全、最符合 Java 语言习惯的选择，特别是结合 Java 14+ 的模式匹配，它变得更加优雅。

2. 在 equals() 方法中使用 getClass()：为了保证 equals() 方法的对称性（a.equals(b) 和 b.equals(a) 应该返回相同的结果），通常应该先比较两个对象的 Class 对象是否完全相同。

3. 在反射中使用 isInstance()：当你通过反射动态加载类并需要检查实例类型时，isInstance() 是不二之选。

避免的类型判断方式

不要使用 来比较 Class 对象来判断类型（除非你真的想检查精确类型，且与 getClass() 意图相同）。

// 这段代码意图是检查 "是否是 Dog 或其子类"，但写错了
if (dog.getClass() == Dog.class) {
    // ...
}
// 这会漏掉 new DogPet() 的情况，因为它返回的是 DogPet.class，不等于 Dog.class

如果你想检查是否是 Dog 或其子类，正确的写法是 dog instanceof Dog。