instanceof 操作符

instanceof 是 Java 中最基本、最常用的类型判断操作符，它用于检查一个对象是否是某个特定类或其子类的实例，或者是某个特定接口的实现。

语法： object instanceof Type

• object: 要检查的对象（注意，object 不能是 null，否则结果为 false）。
• Type: 可以是一个类、一个接口、一个抽象类，甚至是数组类型。

返回值：

• boolean 类型。object 是 Type 的实例，则返回 true；否则返回 false。

instanceof 操作符 (推荐)

这是最标准、最安全、最推荐的方法，它在 Java 14 及更高版本中得到了增强（见下文）。

基本用法

class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
public class InstanceofExample {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        Animal myAnimal = new Animal();
        // 检查 myDog 是否是 Dog 类的实例
        if (myDog instanceof Dog) {
            System.out.println("myDog is a Dog."); // 输出
        }
        // 检查 myCat 是否是 Dog 类的实例
        if (myCat instanceof Dog) {
            System.out.println("This will not be printed.");
        }
        // 检查 myAnimal 是否是 Dog 类的实例
        if (myAnimal instanceof Dog) {
            System.out.println("This will not be printed.");
        }
        // 检查是否实现了某个接口
        List<String> myList = new ArrayList<>();
        if (myList instanceof List) {
            System.out.println("myList is a List."); // 输出
        }
    }
}

instanceof 与 null

instanceof 操作符会优雅地处理 null，任何 null 值与任何 instanceof 表达式的结果都是 false。

String str = null;
if (str instanceof String) {
    // 这行代码永远不会执行
    System.out.println("str is a String.");
}
System.out.println(str instanceof String); // 直接输出 false

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

这是 Java 14 引入的一个重大改进，它极大地简化了类型转换的代码，在旧版本中，你需要先 instanceof 判断，然后再强制类型转换。

Java 14 之前 (繁琐的写法):

Object obj = "Hello, World!";
if (obj instanceof String) {
    // 必须再次进行强制类型转换
    String s = (String) obj;
    System.out.println(s.length());
}

Java 14+ (简洁的写法): instanceof 为 true，编译器会自动将 obj 转换为 String 类型，并赋值给变量 s，你无需手动进行强制类型转换。

Object obj = "Hello, World!";
if (obj instanceof String s) {
    // s 在这里已经是 String 类型，可以直接使用
    System.out.println(s.length()); // 输出 13
}

这个特性不仅让代码更简洁,而且更安全，因为它避免了因手动强制转换而导致的 ClassCastException。

getClass() 方法

getClass() 方法是 Object 类中的一个方法，它返回该对象的运行时类（Class 对象），你可以通过 操作符来比较两个对象的 Class 对象是否完全相同。

关键区别：

• instanceof 会考虑继承关系（Dog 是 Animal 的实例）。
• getClass() 不考虑继承关系，它只关心对象的精确类型。

class Animal {}
class Dog extends Animal {}
public class GetClassExample {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        Dog myDog2 = new Dog();
        // 使用 getClass()
        System.out.println(myDog.getClass() == Dog.class);      // 输出 true
        System.out.println(myDog.getClass() == Animal.class);   // 输出 false！
        System.out.println(myAnimal.getClass() == Animal.class); // 输出 true
        // 与 instanceof 的对比
        System.out.println(myDog instanceof Animal); // 输出 true
    }
}

何时使用 getClass()？ 当你需要判断对象的精确类型，并且不希望任何子类通过时，在实现 equals() 方法时，通常要求两个对象的类型必须完全相同（getClass() 比较），而不是父子类关系。

// 一个典型的 equals() 方法实现
@Override
public boolean equals(Object o) {
    if (o == null || this.getClass() != o.getClass()) {
        return false;
    }
    MyType other = (MyType) o;
    // 比较字段...
    return this.field.equals(other.field);
}

isInstance() 方法

isInstance() 是 java.lang.Class 类中的一个方法，它的功能和 instanceof 操作符几乎完全一样，只是调用方式不同。

语法： Class.isInstance(Object obj)

对比：

• obj instanceof Type 等价于 Type.class.isInstance(obj)

class Animal {}
class Dog extends Animal {}
public class IsInstanceExample {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        Class<?> dogClass = Dog.class;
        Class<?> animalClass = Animal.class;
        // 使用 isInstance()
        System.out.println(dogClass.isInstance(myDog)); // 输出 true
        System.out.println(animalClass.isInstance(myDog)); // 输出 true (考虑继承)
        // 等价于 instanceof
        System.out.println(myDog instanceof Dog);      // 输出 true
        System.out.println(myDog instanceof Animal);   // 输出 true
    }
}

何时使用 isInstance()？ isInstance() 主要在反射场景中使用，当你有一个 Class 对象，但你不知道它的具体类型时，这个方法就非常有用。

// 反射场景示例
public void process(Object obj, Class<?> targetClass) {
    if (targetClass.isInstance(obj)) {
        System.out.println("Object is an instance of the target class.");
        // 可以安全地进行转换
        TargetType t = targetClass.cast(obj);
        // ...
    }
}

isAssignableFrom() 方法

这个方法用于判断一个类或接口是否是另一个类或接口的超类或超接口,它的视角与 isInstance() 相反。

语法： Class1.isAssignableFrom(Class2)

• Class1 是 Class2 的超类、超接口，或者 Class1 和 Class2 是同一个类，则返回 true。
• Class2 是 Class1 的子类，则返回 false。

class Animal {}
class Dog extends Animal {}
public class IsAssignableFromExample {
    public static void main(String[] args) {
        Class<?> animalClass = Animal.class;
        Class<?> dogClass = Dog.class;
        Class<?> objectClass = Object.class;
        // Animal 是否可以赋值给 Animal？可以。
        System.out.println(animalClass.isAssignableFrom(animalClass)); // true
        // Animal 是否可以赋值给 Dog？不可以。
        System.out.println(animalClass.isAssignableFrom(dogClass)); // false
        // Dog 是否可以赋值给 Animal？可以。
        System.out.println(dogClass.isAssignableFrom(animalClass)); // true
        // Object 是否是所有类的超类？
        System.out.println(objectClass.isAssignableFrom(animalClass)); // true
        System.out.println(objectClass.isAssignableFrom(dogClass));   // true
    }
}

何时使用 isAssignableFrom()？ 主要用于反射框架，Spring、Hibernate 等，在容器初始化时，需要判断一个类是否符合某个要求（比如是否是某个接口的实现类，或者是否是某个抽象类的子类）。

总结与选择

简单选择指南：

• 99% 的情况下，请使用 instanceof。 如果你的 Java 版本是 14 或更高，请务必使用它的模式匹配形式，代码会更优雅。
• 只有在需要区分精确类型，且不希望子类通过时（如 equals），才使用 getClass()。
• 只有在进行反射编程，动态获取 Class 对象后，才考虑 isInstance() 和 isAssignableFrom()。