Effective Java笔记 :覆盖 equals 时请遵守通用约定

原创 已于 2025-08-13 14:33:51 修改 · 615 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #笔记 #Effective Java

于 2025-08-13 11:45:11 首次发布

Effective Java笔记 :覆盖 equals 时请遵守通用约定

在《Effective Java》中，Item 10：覆盖 equals 时请遵守通用约定 是一个重要的指导原则。equals 方法是 Java 对象中最核心的方法之一，正确地覆盖它不仅可以让程序运行更可靠，还能避免由于设计错误导致的潜在问题，例如违反对称性或一致性等。

下面我们会详细讲解覆盖 equals 方法的通用约定、注意事项、以及一个示例实现。

1. 为什么需要覆盖 equals 方法？

默认行为（Object 的 equals）

equals 方法在 java.lang.Object 中默认实现如下：

public boolean equals(Object obj) {
    return this == obj;  // 默认比较的是对象的引用
}

这一默认实现检查两个对象是否是同一个对象（内存地址是否相同）。这种行为对于大部分类（例如用作某种特定唯一身份对象）是足够的，但对于某些类，比如值类型类（value classes），通常需要比较它们的内容是否相同，而不是引用相等。

什么时候需要覆盖 equals？

当一个类需要通过值相等来判断两个对象是否相同时（而不是引用相等），就应该覆盖 equals。

比如：

  • String 类已经覆盖了 equals，比较内容而不是引用。
  • Integer 类也覆盖了 equals。

2. 通用约定（契约）

覆盖 equals 时，必须遵守以下约定，这些约定定义了 equals 的行为：

2.1 自反性（Reflexive）

  • 对任意非空引用值 x, x.equals(x) 必须返回 true。
  • 一个对象必须与自身相等。

2.2 对称性（Symmetric）

  • 对任意引用值 x 和 y，如果 x.equals(y) 返回 true，则 y.equals(x) 也必须返回 true。
  • 比较结果必须互相一致。

2.3 传递性（Transitive）

  • 对任意引用值 x、y 和 z，如果 x.equals(y) 为 true，且 y.equals(z) 为 true，那么 x.equals(z) 必须为 true。
  • 这保证了 equals 的一致性。

2.4 一致性（Consistent）

  • 对任意引用值 x 和 y，只要对象未改动，x.equals(y) 的比较结果就必须一致（无论调用几次都返回相同的值）。

2.5 对 null 的比较

  • 对任意非空引用值 x, x.equals(null) 必须返回 false。

3. 覆盖 equals 方法的注意事项

3.1 使用 instanceof 检查类型

  • 确保传入的对象类型是正确的，避免出现 ClassCastException。

3.2 比较每个字段的值

  • 对各个关键字段进行比较来判断对象是否相等。

3.3 返回 boolean 类型

  • 始终返回布尔值 true 或 false，而不是抛异常或者返回其他值。

3.4 避免对浮点数直接比较

  • 对于 float 和 double，在比较其值时要考虑精度问题；
  • 可以使用 Double.compare 或 Float.compare 方法。

4. 示例：一个正确覆盖 equals 的实现

假设我们有一个表示二维点的类 Point，需要覆盖 equals 方法。

public class Point {
    private final int x;
    private final int y;

    // 构造器
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    // 覆盖 equals 方法
    @Override
    public boolean equals(Object obj) {
        // 1. instanceof 检查类型
        if (!(obj instanceof Point)) {
            return false; // 非同类型返回 false
        }
        
        // 2. 进行类型转换
        Point other = (Point) obj; 
        
        // 3. 比较关键字段
        return this.x == other.x && this.y == other.y; 
    }
    
    // 最好还要覆盖 hashCode 方法（后续会讨论）
    @Override
    public int hashCode() {
        return 31 * x + y; // 简单的哈希实现，确保一致性
    }
}

测试类：验证遵守约定

public class Main {
    public static void main(String[] args) {
        Point p1 = new Point(1, 2);
        Point p2 = new Point(1, 2);
        Point p3 = new Point(3, 4);

        // 自反性
        System.out.println("自反性: " + p1.equals(p1)); // true

        // 对称性
        System.out.println("对称性: " + p1.equals(p2)); // true
        System.out.println("对称性: " + p2.equals(p1)); // true

        // 传递性
        Point p4 = new Point(1, 2);
        System.out.println("传递性: " + p1.equals(p2)); // true
        System.out.println("传递性: " + p2.equals(p4)); // true
        System.out.println("传递性: " + p1.equals(p4)); // true

        // 一致性
        System.out.println("一致性: " + p1.equals(p3)); // false
        System.out.println("一致性: " + p1.equals(p3)); // false

        // 对 null 的检查
        System.out.println("null 检查: " + p1.equals(null)); // false
    }
}

输出：

自反性: true
对称性: true
对称性: true
传递性: true
传递性: true
传递性: true
一致性: false
一致性: false
null 检查: false

5. 需要同时覆盖 hashCode

约定：如果覆盖了 equals，必须同时覆盖 hashCode，并确保逻辑一致性。

equals 和 hashCode 的一致性要求：

  • 如果两个对象的 equals 方法返回 true，它们的 hashCode 方法也必须返回相同的值。
  • 如果两个对象的 equals 方法返回 false，它们的 hashCode 方法不强制要求不同。
为什么需要一致性？
  1. 在集合中使用（例如 HashMap、HashSet）时，hashCode 会影响哈希表的存储和查找行为。如果 equals 和 hashCode 不一致，集合可能出现较大的性能问题，甚至逻辑错误。
  2. equals 和 hashCode 共同确保对象的一致性。

6. equals 方法的设计建议

6.1 不要覆盖 equals（默认实现足够时）

如果类的实例不需要比较内容（即始终只需要比较引用），无需覆盖 equals，默认实现已经足够。

6.2 避免滥用 instanceof

如果对象应该实现严格的相等检查（包括类的子类比较），可以使用 getClass() 而不是 instanceof。

  • getClass() 是 java.lang.Object 中的方法，用于返回运行时对象的具体类（即实际类型）的 Class 实例。
  • 用 getClass() 检查类型时，它只会返回对象的声明类，不会考虑继承链。
  • 如果两个对象属于不同的具体类（即使其中一个是另一个的子类），getClass() 判断它们为不同类型。
  • instanceof 是一种用于检查一个对象是某个类或其子类的实例的运算符。使用 instanceof 时，会考虑继承关系，可以用来判断类的子类是否属于同一类型。
    这种行为更松散，因为它允许子类在类型检查时被认作父类。

示例：

@Override
public boolean equals(Object obj) {
    if (obj == null || obj.getClass() != getClass()) {
        return false;
    }
    // 自定义逻辑
}
6.3 谨慎处理浮点数比较

浮点数可能涉及精度问题，建议使用 Double.compare 或 Float.compare 方法。

7.子类新增比较字段的问题

如果你扩展了一个具体类（一个不是 abstract 的类），并且想在子类中引入新字段（值组件），则很难在保留这些约定的同时正确实现 equals。原因在于父类与子类之间的继承关系导致设计出了矛盾的逻辑。

具体举例：颜色点（Point 和 ColorPoint）问题

假设我们有一个简单的 Point 类，表示二维坐标系中的点。

父类 Point：
public class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Point)) {
            return false;
        }
        Point point = (Point) o;
        return x == point.x && y == point.y;
    }
}

Point 的 equals 方法比较其 x 和 y 坐标，判断两个点是否相等。

子类 ColorPoint：

现在我们扩展 Point 类，增加颜色字段：color。

public class ColorPoint extends Point {
    private final String color; // 新的值组件：颜色

    public ColorPoint(int x, int y, String color) {
        super(x, y);
        this.color = color;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof ColorPoint)) {
            return false;
        }
        ColorPoint that = (ColorPoint) o;
        return super.equals(o) && this.color.equals(that.color);
    }
}
出现的问题：打破 equals 的对称性

我们来看这个例子会发生什么：

public static void main(String[] args) {
    Point p = new Point(1, 2);
    ColorPoint cp = new ColorPoint(1, 2, "red");

    System.out.println(p.equals(cp));  // true （从 Point 的 perspective 只检查 x 和 y）
    System.out.println(cp.equals(p));  // false（从 ColorPoint 的 perspective 检查 x, y, color）
}

违反了对称性！

  • p.equals(cp) 返回 true，因为 Point 的 equals 实现只比较了 x 和 y，并不关心是否是 ColorPoint 的实例。
  • 但 cp.equals(p) 返回 false，因为 ColorPoint 的 equals 要求不仅 x 和 y 相同，还需要 color 相同（p 没有颜色数据）。
进一步问题：违反传递性

现在，我们再引入另一个颜色点：

ColorPoint cp_red = new ColorPoint(1, 2, "red");
ColorPoint cp_blue = new ColorPoint(1, 2, "blue");
Point p = new Point(1, 2);

如果按默认实现，这样的行为会违反传递性：

System.out.println(cp_red.equals(p)); // true (ColorPoint 和 Point 只比较 x 和 y)
System.out.println(p.equals(cp_blue)); // true (Point 和 ColorPoint 也只比较 x 和 y)
System.out.println(cp_red.equals(cp_blue)); // false (ColorPoint 额外比较 color)

违反了传递性：

  • cp_red.equals(p) 返回 true
  • p.equals(cp_blue) 返回 true
  • 但 cp_red.equals(cp_blue) 返回 false
** 为什么无法解决这个问题？**

这个问题的根本原因是继承 Point 和 ColorPoint 之间对 equals 的要求不可兼容：

  1. Point 的 equals 定义只比较 x 和 y。
  2. ColorPoint 的 equals 不仅要比较 x 和 y，还要比较 color。

在继承关系中，子类通常需要扩展父类，而不是减少功能。然而，equals 的传递性要求比较的逻辑必须是固定的，不能根据子类的扩展而改变。

总之，这种扩展导致逻辑矛盾：

  • 如果 Point.equals 忽略 color，它会打破对称性。
  • 如果 ColorPoint.equals 强制要求所有对象都包含 color，就和父类逻辑不兼容。
如何应对这个问题？
方案 1：限制继承（违反里氏替换原则）

最简单的办法是，不允许子类为 Point 添加新的值组件。换言之：

  • 如果设计了一个支持 equals 方法的类（比如 Point），让这个类不允许被继承。

可以通过将 Point 声明为 final 来避免继承。

public final class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Point)) {
            return false;
        }
        Point point = (Point) o;
        return x == point.x && y == point.y;
    }
}

如果 Point 是不可扩展的，类的等价性逻辑也会变得清晰：它永远只需要比较 x 和 y。

方案 2：使用组合而不是继承

另一种解决方法是，避免直接继承，而通过组合来表达扩展的需求。

public class ColorPoint {
    private final Point point; // 组合关系
    private final String color;

    public ColorPoint(int x, int y, String color) {
        this.point = new Point(x, y);
        this.color = color;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof ColorPoint)) {
            return false;
        }
        ColorPoint cp = (ColorPoint) o;
        return point.equals(cp.point) && color.equals(cp.color);
    }

    @Override
    public int hashCode() {
        return point.hashCode() * 31 + color.hashCode();
    }
}

通过组合，ColorPoint 的等价性检查不再打破 Point 的逻辑，因为 Point 的等价逻辑与子类（ColorPoint）之间没有直接耦合关系。

方案 3：用不同类型的方式比较

如果确实需要支持父类和子类之间带值组件的比较，可以提供额外的比较逻辑（如提供一个自定义比较器），而不是直接扩展 equals 方法。

8. equals 的测试工具

  1. JUnit：
    使用 JUnit 可以对 equals 方法进行系统性测试。
  2. Apache Commons EqualsBuilder：
    Apache Commons Lang 提供了一个 EqualsBuilder 工具类，可以快速实现 equals 方法。
Jooou
关注
Effective Java阅读笔记
学无止境
03-31 381
最近在看Effective Java这本书，在这里简单记录下书中78条建议，因为有一定的编程经验，书中一大半条理规范都在践行中，还有一部分在用但是不知道为什么这么用，当然如枚举、并发等，还是需要多加以实践。 考虑用静态工厂方法代替构造器 遇到多个构造器参数时要考虑用构建器 用私有构造器或者枚举类型强化Singleton属性 通过私有构造器强化不可实例化的能力 避免创建不必要的对象 消除过期的对...
【Effective Java笔记】第8条：覆盖equals时请遵守通用约定
浅然的专栏
04-22 1183
反反复复看了几遍，感觉第八条写的真心好，虽然平时知道怎么重写equals吧，但根本不会去想这么多，各种固定思维。不过现在对equals的重写又有新的认识了，下面就写关于第八条覆盖equals时请遵守通用约定的阅读笔记吧 该篇博客主要阐述 1、不需要覆盖equals的情景 2、需要覆盖equals的情景 3、对5条通用约定的理解 4、实现高质量equals的诀窍...
Java：Effective java学习笔记之 覆盖equals时请遵守通用约定
JMW1407的博客
12-07 545
Java覆盖equals时请遵守通用约定覆盖equals时请遵守通用约定1、为什么要覆盖equals2、需要覆盖equals方法的时机2.1、不需要覆盖equals方法的情况2.2、需要覆盖equals方法的情况2.2.1、自反性2.2.2、对称性2.2.3、传递性2.2.4、一致性2.2.5、非空性3、高质量equals方法的几个注意点3.1、规范案例4、除了上述的注意点之外，下面给出一些整体的告诫：4.1、==和equals()的区别5、总结参考 覆盖equals时请遵守通用约定 1、为什么要覆盖equ
《Effective Java》阅读笔记8 覆盖equals方法请遵守通用约定
weixin_41563161的博客
04-21 290
1.序 2.不需要覆盖equals的情景 类的每个实例本质上都是唯一的。对于代表活动实体而不是值（value）的类来说确实如此，例如Thread。Object提供的equals实现对于这些类来说正是正确的行为。 不关心类是否提供了“逻辑相等（logical equality）”的测试功能。例如，java.util.Random覆盖了equals，以检查两个Random实例是否产生相同的随机数序列，但是设计者并不认为客户需要或者期望这样的功能。在这样的情况下，从Object继承得到的equals实现已经足
Effective Java笔记（10）覆盖 equals 时请遵守通用约定
琅琊之榜
07-14 407
如果类实现的接口改进了 equals 约定，允许在实现了该接口的类之间进行比较，那么就使用接口。如果覆盖 equals ，一定要比较这个类的所有关键域，并且查看它们是否遵守 equals 合约的所有五个条款。例如，大多数的Set 实现都从Abstract Set 继承 equals 实现，List 实现从 AbstractList 继承 equals 实现，Map 实现从 AbstractMap 继承 equals 实现。如果该类型是个类，也许就能够直接访问参数中的域，这要取决于它们 的可访问性。
读《Effective Java》笔记之 第八条：覆盖equals时请遵守通用约定
myco前的专栏
07-24 296
不应覆盖equals的情况 equals方法有许多覆盖方式都会导致错误，避免这种错误最简单的办法就是不覆盖equals方法。以下几种情况适合不去覆盖equals 类的每个实例本质上都是唯一的 不需要“逻辑相等”的概念 超类已经覆盖了equals，从超类继承过来的行为对子类也是合适的 类是私有或包级私有的，可以确定它的equals方法永远不会被调用；不过这种情况，显然应该覆盖equals方...
effective java读书笔记8：覆盖equals方法请遵守通用约定
weixin_33713503的博客
01-21 84
2019独角兽企业重金招聘Python工程师标准>>> ...
读书笔记-《Effective Java》第8条：覆盖equals时请遵守通用约定
baitianmingdebai的专栏
12-25 192
如果覆盖equals方法的目的是判断对象之间是否相等，那么使用超类(Object)的方法即可。 public boolean equals(Object obj) { return (this == obj); } 在覆盖equals方法的时候，必须要遵守它的通用约定： 自反性（reflexive）。对于任何非null的引用值x，x.equals(x)必须返回tr...
Java编程应用（三）：覆盖equals时请遵守通用约定——Effective Java
风的专栏
02-14 1007
如果满足了以下任一条件，这就正是所期望的结果： 类的每个实例本质上都是唯一的。 不关心类是否提供了“逻辑相等”的测试功能。 超类已经覆盖了equals，从超类继承过来的行为对于子类也是适合的。 类是私有的或是包级私有的，可以确定它的equals方法永远不会被调用。如果类具有自己特有的“罗吉相等”概念（不同于对象等同的概念），而且超类还，没有覆盖equals以实现期望的行为，这时我们就需要覆盖
Effective Java读书笔记-覆盖equals时遵守的通用约定
G7S9R的专栏
11-11 348
不需覆盖equals的情况覆盖equals看似很简单，但是很多覆盖方式会导致错误，并且后果会非常严重，最简单的方法就是不去覆盖equals方法。 以下几种情况，可以不用覆盖equals方法： 类的每个实例本质上是一致的。 不关心是否提供了“逻辑相等”的测试功能。 超类继承了equals，从超类继承过来的行为对于子类来讲也是合适的。 类是私有的或者包级私有的，可以确定equals方法永远不会被调用。
深度解析：Effective.Java中文版第3版读书笔记
- 条目10：重写equals方法时遵循通用约定。 - 条目11：重写equals方法时必须重写hashCode方法。 - 条目12：始终重写toString方法。 - 条目13：谨慎重写clone方法。 - 条目14：考虑实现Comparable接口。 - 条目15：使...
深入理解Effective Java第三版精要
3. 覆盖equals时请遵守通用约定：同样重要的是，在覆盖equals方法时，应当同时覆盖hashCode方法，以确保两个使用equals方法判断为相等的对象返回相同的哈希码。 4. 始终覆盖toString方法：toString方法返回对象的...
《Effective Java》Second Edition中文版笔记（完整）
陀思妥耶夫斯基和海德格尔伴我勇敢存在
09-09 4761
第2章 创建和销毁对象
为什么重写equals()方法时，必须要求重写hashCode()方法？
热门推荐
Java Punk
03-14 1万+
equals() 方法和 hashcode() 方法是 java.lang.Object 类的两个重要的方法，Java中多数类都会重写 Object 类的 equals() 方法。 在实际应用中，如果我们自定义的类需要进行比较操作，就一定也需要重写 equals() 方法。那么为什么重写 equals()方法时，必须要求重写 hashCode() 方法呢？ 首先， equals() 方法和 h...
【Android逆向工程】第8章：Frida 高级应用：函数追踪与 RPC 调用
w987333120的博客
12-01 202
本文介绍了Frida框架的核心功能与应用技巧，包括函数调用栈追踪、RPC机制、批量Hook、内存操作和脚本模块化等关键技术。重点讲解了Thread.backtrace()和DebugSymbol.fromAddress()的用法，提供Java和Native函数的调用栈追踪示例，并展示了调用栈过滤与分析方法。最后通过实战案例演示登录流程追踪和RPC调用，同时给出常见问题解决方案。这些技术可有效提升逆向分析效率，适用于移动应用安全测试场景。
07_Spring AI 干货笔记之提示词
在科技的浪潮中，我们寻找着创新的火种，在代码的海洋里，我们编织着智慧的网。腾飞开源，就是这样一个由技术精英汇聚而成的博客平台，我们致力于分享在Java、Python、IoT和人工智能等领域的最新研究成果和实战经验。 在腾飞开源的博客上，你会看到紧跟技术前
11-30 1030
本文详细介绍了Spring AI中的提示词核心概念与API设计。提示词作为引导AI模型生成特定输出的关键输入，其结构从简单字符串演进为包含多角色消息的复杂形式。Spring AI通过Prompt和Message接口提供结构化提示词管理，支持系统、用户、助手等角色分配。PromptTemplate类实现动态内容渲染，并支持自定义模板引擎。文章还涵盖提示词工程的最佳实践与令牌机制，为开发者提供完整的提示词设计解决方案。
【实战】项目traffic analysis技术点记录二
努力学习的！
11-28 1002
主要是因为ClickHouse的DateTime类型精度只到秒级，不支持毫秒部分，而Java的LocalDateTime默认包含毫秒精度。（1） 服务提供者： 通过k8s Service 暴露出一组pod实例，并拥有一个稳定的DNS名称 ： user-service.default.svc.cluster.local。这个注解的正确使用对于保证对象比较的正确性非常重要，特别是在使用HashSet、HashMap等集合时！轻量级，中心化的调度方案，依赖JobRunLock，同一任务实例互斥。
Docker：基于自制openjdk8镜像 or 官方openjdk8镜像，制作tomcat镜像
2509_94186151的博客
11-29 481
78.56 MBopenjdk二进制下载地址Dockerfile中，source /etc/profile不能加载的原因为什么还需要选择使用他的原因：三 中，tomcat普通用户交互式启动tomcat#在 Docker 容器中，/etc/profile 文件不会在容器启动时自动执行，这是因为 Docker 容器通常不会启动交互式登录 shell，而是直接运行指定的命令。
SpringMVC的工作流程
最新发布
2509_94106460的博客
12-01 320
在上述过程中，DispatcherServlet、HandlerMapping、HandlerAdapter和ViewResolver对象的工作是在框架内部执行的，开发人员只需要配置DispatcherServlet，完成Controller中的业务处理并在View中展示相应信息。DispatcherServlet是前端控制器，是整个流程控制的中心。（5） HandlerAdapter会调用并执行Handler（处理器），这里的处理器指的就是程序中编写的Controller类，也被称之为后端控制器。
Effective Java 读书笔记：对象创建与优化策略
"Effective Java读书笔记" Effective Java是Java编程领域的一本经典书籍，由Joshua Bloch撰写，主要探讨了编写高质量Java代码的最佳实践。以下是对书中几个关键知识点的详细解析： 1. 考虑使用静态工厂方法替代...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值