instanceof 和 getClass() 有什么区别？在 equals 里该用哪个？

简化版

instanceof 和 getClass() 都用于判断对象类型，但有本质区别：instanceof 判断「对象是不是某个类型或其子类型」（考虑继承——dog instanceof Animal 为 true，因为 Dog 是 Animal 的子类）；getClass() 返回对象的「精确实际类型」，用 == 比较是「是不是严格同一个类」（不考虑继承——dog.getClass() == Animal.class 为 false）。所以 instanceof 是「宽松」的（含子类）、getClass()== 是「严格」的（精确类型）。在 equals 里用哪个有讲究：用 getClass() 保证「对称性」但不允许子类和父类相等；用 instanceof 允许子类和父类比较但可能破坏对称性——多数场景（尤其类可能被继承时）推荐用 getClass()。Java 16+ 还有 instanceof 模式匹配（if (o instanceof User u) 判断+转型一步到位）。

详细版

instanceof vs getClass 的核心区别：

class Animal {}
class Dog extends Animal {}
Dog dog = new Dog();

// instanceof：判断"是不是某类型或其子类"（考虑继承）
dog instanceof Dog;      // true
dog instanceof Animal;   // true！——Dog 是 Animal 的子类，instanceof 认
dog instanceof Object;   // true——一切都是 Object

// getClass()：返回精确实际类型，== 比较是"严格同类"（不考虑继承）
dog.getClass() == Dog.class;      // true
dog.getClass() == Animal.class;   // false！——实际类型是 Dog 不是 Animal

对比表：

维度	`instanceof`	`getClass() ==`
判断内容	是否是某类型或其子类	是否严格是同一个类
考虑继承	是（子类算 true）	否（精确类型）
null 处理	`null instanceof X` 恒为 false	`null.getClass()` 抛 NPE
松紧	宽松（含子类）	严格（精确）

在 equals 里的选择：

// 用 getClass（严格，推荐——尤其类可能被继承时）
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;  // 严格同类才可能相等
    ...
}

// 用 instanceof（宽松，允许子类）
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof User)) return false;   // 是 User 或其子类就继续
    ...
}

⚠️ instanceof 对 null 安全，getClass() 对 null 会 NPE——null instanceof X 恒为 false（不抛异常），而 null.getClass() 会抛 NullPointerException。所以在 equals 里用 getClass() 时，必须先判 o == null（if (o == null || getClass() != o.getClass())）；用 instanceof 则不用单独判 null（instanceof 自带 null 检查，o instanceof User 在 o 为 null 时直接返回 false）。

完整版教学

一、两者的本质区别：含不含子类

instanceof 和 getClass() 最核心的区别是「判断时含不含子类」：

instanceof：判断"对象是不是某类型 或 该类型的子类"（IS-A 关系，含继承）
  dog instanceof Animal → true（Dog IS-A Animal，是一种动物）
  → 它问的是"是不是这一类（含子类）"

getClass()：返回对象"精确的实际运行时类型"
  dog.getClass() == Animal.class → false（dog 的实际类型精确是 Dog，不是 Animal）
  → 它问的是"是不是严格这一个类"

一个比喻：instanceof 问「你是不是动物？」（狗、猫都算是）；getClass()== 问「你是不是恰好是『狗』这个物种？」（只有狗算，猫不算，「动物」这个抽象概念也不精确匹配狗）。所以 instanceof 宽松（把子类也算进来、符合多态的「IS-A」思想），getClass()== 严格（只认精确的那一个类）。理解「instanceof 含子类（IS-A）、getClass 精确类型」，就抓住了两者的本质区别——一个宽、一个严。

二、instanceof：面向多态的类型判断

instanceof 判断「是否属于某类型（含子类）」，它天然契合多态——用父类/接口引用时判断实际能不能当某类型用：

Object o = getData();
if (o instanceof String) {           // 判断 o 是不是 String（或其子类，但 String 是 final）
    String s = (String) o;           // 判断通过才安全转型
    // 用 s
}

// 常见场景：处理不同类型
if (shape instanceof Circle) { ... }
else if (shape instanceof Rectangle) { ... }

instanceof 的典型用途是「转型前的安全检查」——强制转型前先 instanceof 判断，避免 ClassCastException。它符合多态思想：判断「能不能把这个对象当某类型用」（子类对象当然能当父类型用，所以 instanceof 父类 为 true）。两个特性：① 对 null 安全（null instanceof X 恒为 false，不抛异常）；② 含子类（子类实例 instanceof 父类 为 true）。理解「instanceof 判断是否属于某类型含子类、用于安全转型、对 null 安全」，就掌握了它的用法——它是「宽松的、多态友好的」类型判断。

三、getClass：精确的实际类型

getClass() 返回对象运行时的精确实际类型（Class 对象），用 == 比较 Class 对象是「严格同类判断」：

Object o = new Dog();
Class<?> c = o.getClass();        // 返回 Dog.class（精确实际类型，不是声明类型 Object）
c == Dog.class;                   // true
c == Animal.class;                // false（实际类型是 Dog，精确匹配）
c.getName();                      // "com.xx.Dog"

getClass() 的特性：① 返回精确实际类型（多态下返回子类，不是声明类型）；② == 比较是严格同类（不含子类——Dog 和 Animal 是不同的 Class 对象）；③ 对 null 会 NPE（null.getClass() 抛异常，因为要调 null 的方法）；④ 是 final 方法（不能重写，保证类型信息可靠）。它常用于「需要精确类型判断」的场景——如 equals 里要求「严格同类才可能相等」、反射里获取类信息。理解「getClass 返回精确实际类型、== 是严格同类、对 null NPE、final」，就掌握了它和 instanceof 的对比——它是「严格的、精确的」类型判断。

四、equals 里用哪个：对称性之争

在 equals 里用 instanceof 还是 getClass()，是一个经典的设计权衡，核心争议是「对称性」：

equals 的对称性要求：a.equals(b) 和 b.equals(a) 必须结果一致

用 instanceof 的问题（可能破坏对称性）：
  class Point { equals 用 instanceof Point }
  class ColorPoint extends Point { equals 用 instanceof ColorPoint }
  Point p = new Point(1,2);
  ColorPoint cp = new ColorPoint(1,2,红);
  p.equals(cp)  → true（cp instanceof Point 为 true，且坐标相同）
  cp.equals(p)  → false（p instanceof ColorPoint 为 false）
  → 不对称！破坏了 equals 契约

用 getClass 的效果（保证对称性）：
  p.equals(cp)  → false（getClass 不同：Point ≠ ColorPoint）
  cp.equals(p)  → false（同样不同类）
  → 对称！但"父类对象和子类对象永远不相等"

两种选择的取舍：① 用 getClass()——严格「同类才可能相等」，保证对称性，但「父类对象和子类对象永远不相等」（哪怕子类只是加了个字段）；② 用 instanceof——允许「子类和父类比较」，但可能破坏对称性（子类重写 equals 后，父子互相比较结果可能不一致）。推荐：一般用 getClass()（更安全、保证对称性），尤其是「类可能被继承」时；只有在明确「所有子类都用父类的 equals（不重写）」的情况下才用 instanceof。理解「equals 里 getClass 保证对称性但父子不等、instanceof 允许父子比较但可能破坏对称性、一般推荐 getClass」，就掌握了这个设计权衡。

五、instanceof 模式匹配：Java 16+ 的简化

Java 16 正式引入了 instanceof 模式匹配，把「判断 + 转型」合并成一步，消除了冗余：

// 传统写法：判断 + 强转，o 写两遍
if (o instanceof String) {
    String s = (String) o;      // 判断后还要手动强转
    System.out.println(s.length());
}

// 模式匹配（Java 16+）：判断 + 绑定变量一步到位
if (o instanceof String s) {    // 判断通过就自动把 o 转型并绑定到 s
    System.out.println(s.length());  // 直接用 s，不用手动强转
}

// 还能在条件里直接用
if (o instanceof String s && s.length() > 5) { ... }

模式匹配的价值是「消除『判断 + 强转』的冗余」——传统写法要写两遍对象名（instanceof 一次、强转一次），模式匹配 o instanceof String s 判断通过就自动转型并绑定到 s，直接用。它还能配合 && 在条件里用（o instanceof String s && s.length() > 5），且 s 的作用域是「流敏感」的（只在判断为 true 的分支可用）。这让 instanceof 更简洁安全（不会强转错类型）。理解「instanceof 模式匹配把判断+转型合并、Java 16+」，就掌握了这个现代简化（前面「模式匹配」题详讲，这里作为 instanceof 的演进补充）。

六、选择建议：什么时候用哪个

总结两者的选择：

用 instanceof：
  - 转型前的安全检查（if (o instanceof X) { X x = (X)o; }）
  - 需要"含子类"的判断（判断能不能当某类型用）
  - 对 null 安全的场景（不想单独判 null）
  - Java 16+ 优先用模式匹配 if (o instanceof X x)

用 getClass() ==：
  - equals 里要求"严格同类才相等"（推荐，保证对称性）
  - 需要精确的实际类型（反射、类型的精确比较）
  - 注意先判 null（getClass 对 null NPE）

核心判断：需要「含子类的宽松判断」用 instanceof（转型检查、多态判断），需要「精确同类的严格判断」用 getClass()（equals 对称性、精确类型）。日常最常用的是 instanceof（尤其模式匹配版）做转型检查；equals 里的类型判断则推荐 getClass()（除非明确子类不重写 equals）。理解「宽松判断用 instanceof、严格判断用 getClass、equals 一般用 getClass、转型检查用 instanceof」，就能在实际场景中选对——这道题的落脚点就是「根据『要不要含子类』选择」。

记忆钩子：「instanceof 判断『是某类型或其子类』（含继承、IS-A、对 null 安全）、getClass()== 判断『严格是同一个类』（精确实际类型、不含子类、对 null NPE、final）；equals 里用 getClass 保证对称性但父子不等、用 instanceof 允许父子比较但可能破坏对称性——一般推荐 getClass；Java 16+ 用 instanceof 模式匹配 o instanceof X x 判断+转型一步到位」。

七、常见误区与追问

误区：instanceof 和 getClass 一样。 本质不同——instanceof 判断「是某类型或其子类」（含继承），getClass()== 判断「严格是同一个类」（精确类型不含子类）；一个宽松一个严格。
误区：dog.getClass() == Animal.class 为 true。 false——getClass 返回精确实际类型 Dog，== 比较严格同类；而 dog instanceof Animal 才是 true（含子类）。
误区：equals 里用 instanceof 一定对。 用 instanceof 在「类被继承且子类重写 equals」时可能破坏对称性（父子比较结果不一致）；一般推荐 getClass 保证对称性（除非子类不重写 equals）。
误区：getClass 对 null 安全。 不安全——null.getClass() 抛 NPE；instanceof 才对 null 安全（null instanceof X 恒为 false）。所以 equals 用 getClass 要先判 null。
追问：instanceof 和 getClass 在 equals 里怎么选？ 一般用 getClass（严格同类、保证对称性，但父类对象和子类对象永不相等）；用 instanceof 允许子类和父类比较但子类重写 equals 时可能破坏对称性；类可能被继承时推荐 getClass。
追问：为什么 instanceof 对 null 安全而 getClass 不安全？ instanceof 是运算符，null instanceof X 规范规定恒为 false（不抛异常）；getClass() 是方法调用，null.getClass() 是调 null 的方法，抛 NullPointerException。
追问：Java 16 的 instanceof 模式匹配是什么？ if (o instanceof String s)——判断 o 是 String 的同时自动转型并绑定到变量 s，消除了「判断 + 手动强转」的冗余，s 的作用域流敏感（只在判断为 true 的分支可用）。

八、加强记忆

instanceof 和 getClass() 都判断对象类型，核心区别是「含不含子类」：instanceof 判断「对象是不是某类型或其子类」（含继承、IS-A 关系——dog instanceof Animal 为 true，宽松、契合多态、对 null 安全恒返回 false）；getClass() 返回「精确的实际运行时类型」，== 比较是「严格同类」（不含子类——dog.getClass() == Animal.class 为 false，精确、对 null 会 NPE、是 final 方法）。在 equals 里的选择是经典权衡：用 getClass() 保证对称性（严格同类才可能相等，但「父类对象和子类对象永不相等」）、用 instanceof 允许父子比较但可能破坏对称性（子类重写 equals 时 a.equals(b)≠b.equals(a)）——一般推荐 getClass()（尤其类可能被继承时），且用它要先判 null。Java 16+ 的 instanceof 模式匹配（if (o instanceof String s)）把「判断 + 转型」合并、消除冗余。选择：宽松/含子类/转型检查用 instanceof，严格/精确/equals 对称性用 getClass()。一句话「instanceof 判是某类型或子类（含继承、null 安全）、getClass 判严格同类（精确、null NPE、final），equals 一般用 getClass 保对称、转型检查用 instanceof（模式匹配更简洁）」。

简化版

详细版