在 Java 中，判断一个 Object 的具体类型有多种方法，适用于不同的场景，下面我将从最常用到最专业的角度，为你详细讲解这些方法，并提供代码示例和最佳实践。

instanceof 运算符（最常用、最推荐）

这是 Java 中进行类型检查的标准方式，它检查一个对象是否是特定类或其子类的实例，如果是，则返回 true。

语法： object instanceof ClassName

特点：

• 安全：如果对象是 null，instanceof 表达式会直接返回 false，不会抛出 NullPointerException。
• 包含继承关系：如果一个对象是子类的实例，那么它也必然是父类的实例。
• 性能高：这是 JVM 优化的一个核心操作，效率非常高。

示例代码：

// 定义一个父类和子类
class Animal {}
class Dog extends Animal {}
public class InstanceofExample {
    public static void main(String[] args) {
        Object obj1 = new Dog();
        Object obj2 = new Animal();
        Object obj3 = "Hello, World!";
        Object obj4 = null;
        // 判断 obj1
        if (obj1 instanceof Dog) {
            System.out.println("obj1 is a Dog."); // 会执行
        }
        if (obj1 instanceof Animal) {
            System.out.println("obj1 is also an Animal."); // 会执行，因为 Dog 继承自 Animal
        }
        // 判断 obj2
        if (obj2 instanceof Dog) {
            System.out.println("obj2 is a Dog."); // 不会执行
        }
        if (obj2 instanceof Animal) {
            System.out.println("obj2 is an Animal."); // 会执行
        }
        // 判断 obj3
        if (obj3 instanceof String) {
            System.out.println("obj3 is a String."); // 会执行
        }
        // 判断 obj4 (null)
        if (obj4 instanceof Animal) {
            System.out.println("obj4 is an Animal."); // 不会执行，null 不是任何类的实例
        }
        // Java 14 引入的 instanceof 模式匹配 (更简洁)
        if (obj1 instanceof Dog dog) {
            System.out.println("Pattern matched: obj1 is a Dog, and its name is: " + dog.getClass().getSimpleName()); // 会执行
        }
    }
}

getClass() 方法

getClass() 方法返回对象的确切运行时类，返回一个 java.lang.Class 对象，如果你想获取对象的精确类型（而不是其父类类型），可以使用它。

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

特点：

• 精确类型：返回的是对象的实际类，不包括父类。
• 不能处理 null：如果对象是 null，调用 getClass() 会抛出 NullPointerException。

示例代码：

class Parent {}
class Child extends Parent {}
public class GetClassExample {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Child child = new Child();
        Object obj = child;
        // 获取精确类型
        Class<?> parentClass = parent.getClass();
        Class<?> childClass = child.getClass();
        Class<?> objClass = obj.getClass();
        System.out.println("parent's class: " + parentClass.getName()); // 输出: Parent
        System.out.println("child's class: " + childClass.getName());   // 输出: Child
        System.out.println("obj's class: " + objClass.getName());       // 输出: Child，而不是 Parent
        // 使用 getClass() 判断类型
        if (child.getClass() == Child.class) {
            System.out.println("child is exactly of type Child."); // 会执行
        }
        // 下面的判断会失败，因为 getClass() 返回的是精确类型
        if (child.getClass() == Parent.class) {
            System.out.println("child is exactly of type Parent."); // 不会执行
        }
    }
}

注意：使用 getClass() 进行类型判断时，通常使用 来比较 Class 对象，因为它检查的是类型是否完全相同，而不是继承关系。

Class.isInstance() 方法

这是 instanceof 运算符的方法等价物，当你需要动态地传入一个 Class 对象进行判断时，这个方法非常有用，尤其是在反射中。

语法： boolean result = clazz.isInstance(object);

特点：

• 功能与 object instanceof clazz 完全相同。
• 在反射和泛型编程中非常方便。

示例代码：

class Animal {}
class Dog extends Animal {}
public class IsInstanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Animal animal = new Animal();
        Object obj = dog;
        // 使用 isInstance() 进行判断
        boolean isDog = Dog.class.isInstance(dog);
        boolean isAnimal = Animal.class.isInstance(dog);
        boolean isAnimalForObj = Animal.class.isInstance(obj);
        System.out.println("Is dog a Dog? " + isDog);         // true
        System.out.println("Is dog an Animal? " + isAnimal); // true
        System.out.println("Is obj an Animal? " + isAnimalForObj); // true
        // 与 instanceof 对比
        System.out.println("dog instanceof Dog: " + (dog instanceof Dog)); // true
        System.out.println("dog instanceof Animal: " + (dog instanceof Animal)); // true
    }
}

Class.isAssignableFrom() 方法

这个方法用于判断类之间的继承或实现关系,而不是判断一个对象实例，它通常在反射框架内部使用。

语法： boolean result = superClass.isAssignableFrom(subClass);

特点：

• 参数是 Class 对象，而不是对象实例。
• subClass 是 superClass 本身，或者是 superClass 的子类/实现类，则返回 true。

示例代码：

class Animal {}
class Dog extends Animal {}
interface Flyable {}
class Bird implements Flyable {}
public class IsAssignableFromExample {
    public static void main(String[] args) {
        // 判断类之间的继承关系
        boolean assignable1 = Animal.class.isAssignableFrom(Dog.class);
        System.out.println("Animal is assignable from Dog: " + assignable1); // true
        boolean assignable2 = Dog.class.isAssignableFrom(Animal.class);
        System.out.println("Dog is assignable from Animal: " + assignable2); // false
        // 判断接口的实现关系
        boolean assignable3 = Flyable.class.isAssignableFrom(Bird.class);
        System.out.println("Flyable is assignable from Bird: " + assignable3); // true
    }
}

getClass().getName() 方法

如果你只需要获取类型的名称（用于日志记录或动态加载类），可以使用这个方法。

语法： String className = object.getClass().getName();

示例代码：

public class GetNameExample {
    public static void main(String[] args) {
        String str = "test";
        Integer num = 123;
        System.out.println("str's class name: " + str.getClass().getName()); // 输出: java.lang.String
        System.out.println("num's class name: " + num.getClass().getName());   // 输出: java.lang.Integer
    }
}

最佳实践与总结

在日常开发中，90% 的情况下你只需要使用 instanceof。 它是 Java 类型检查的基石，既安全又高效，只有在非常特殊的反射或需要精确类型信息的场景下，才考虑使用其他方法。