什么是不可变对象(immutable object)？

不可变对象(Immutable Object)

不可变对象是指一旦创建后，其状态（即对象的数据或属性值）就不能被修改或改变的对象。这种特性使得不可变对象在多线程环境下尤为有用，因为它们避免了因并发访问和修改数据而可能引起的线程安全问题。此外，不可变对象还因其不可变性而具有一些其他优点，如缓存友好、安全性高、易于实现线程安全等。

不可变对象的优点

1. 线程安全：由于不可变对象的状态不能被修改，因此它们可以安全地在多线程环境中共享，无需额外的同步机制。
2. 缓存友好：不可变对象的哈希值在对象创建后就不会改变，因此它们可以被用作缓存键，从而提高缓存的效率和可靠性。
3. 安全性：不可变对象可以防止数据被意外修改，这在需要确保数据一致性和完整性的场景中尤为重要。
4. 简化并发编程：在多线程编程中，使用不可变对象可以减少因数据竞争和同步问题而导致的错误和复杂性。
5. 易于设计：不可变对象的设计相对简单，因为它们不需要考虑对象状态的变化和同步问题。

Java中创建不可变对象的方法

在Java中，创建不可变对象通常涉及以下步骤和关键点：

1. 将类声明为final

   通过将类声明为final，可以防止其他类继承该类并修改其状态。这是创建不可变对象的第一步，因为它确保了类的不可继承性，从而避免了子类可能引入的状态变化。

   public final class ImmutableClass {
       // 类体
   }
   

2. 将所有字段声明为private和final

   为了确保不可变性，需要将类的所有字段声明为private和final。私有字段可以防止直接访问，而final字段可以确保字段的值在对象创建后无法修改。这样，除了构造函数之外，没有其他方法可以修改字段的值。

   public final class ImmutableClass {
       private final int value;
       private final String name;
   
       public ImmutableClass(int value, String name) {
           this.value = value;
           this.name = name;
       }
   
       // Getter方法
       public int getValue() {
           return value;
       }
   
       public String getName() {
           return name;
       }
   }
   

3. 不提供修改字段值的方法

   为了保持不可变性，不要提供任何公共方法来修改字段的值，如setter方法。只提供getter方法用于获取字段的值。这样可以确保对象的状态在创建后不会被改变。

4. 对可变字段进行深拷贝

   如果类中包含可变字段（如集合或数组），则在构造函数中对它们进行深拷贝，以防止外部代码修改对象的状态。这是因为即使字段本身是私有的，但如果它们引用的是可变对象，那么这些对象的状态仍然可能被外部代码通过引用修改。

   import java.util.ArrayList;
   import java.util.List;
   
   public final class ImmutableClassWithList {
       private final List<String> list;
   
       public ImmutableClassWithList(List<String> initialList) {
           this.list = new ArrayList<>(initialList); // 深拷贝
       }
   
       public List<String> getList() {
           return new ArrayList<>(list); // 返回深拷贝，防止外部修改
       }
   }
   

   注意，在上面的例子中，即使list字段是私有的，但我们在getList()方法中仍然返回了一个新的列表副本，以防止外部代码修改原始列表。

5. 确保引用类型字段的不可变性

   如果类中包含引用类型字段，并且这些字段引用的对象是可变的，那么即使类本身是不可变的，这些字段引用的对象的状态仍然可能被修改。为了解决这个问题，可以在构造函数中对这些引用类型字段进行保护性拷贝，或者确保它们引用的对象本身也是不可变的。

6. 确保对象的正确创建

   在创建不可变对象时，还需要确保对象在创建期间的状态是正确的，即没有发生this引用的逸出。this引用的逸出是指对象在构造函数完全执行完毕之前就被其他线程或方法访问到。这可能会导致对象在完全初始化之前就被修改，从而破坏其不可变性。

   为了避免this引用的逸出，可以在构造函数中将对象的状态设置为最终状态之前，不将this引用传递给其他方法或线程。此外，还可以使用工厂方法或构建器模式来封装对象的创建过程，从而确保对象在创建过程中不会被外部访问或修改。

示例：Java中的String类

Java平台类库中包含许多不可变类的示例，其中最具代表性的是String类。String 类是 Java 中最典型的不可变对象之一，它遵循了上述提到的所有创建不可变对象的最佳实践。

String 类的不可变性

1. final 修饰的类：
   String 类被声明为 final，这意味着它不能被继承。这阻止了通过继承来覆盖 String 类的任何方法或添加新的字段，从而保持其不可变性。

   public final class String {
       // 类定义...
   }
   

2. 私有字段：
   虽然 String 类的内部实现细节（如 JDK 9 之前的 char 数组和 JDK 9 及以后可能的 byte 数组加上编码标志）对于 Java 程序员来说是不透明的，但从概念上讲，这些字段是私有的，并且不能被外部访问或修改。

3. 没有修改状态的方法：
   String 类没有提供任何修改其内部状态（即其包含的字符序列）的方法。它提供了许多用于操作和生成新字符串的方法（如 substring、concat、replace 等），但这些方法都会返回一个新的字符串对象，而不会修改原始字符串。

4. 不可变性的优势：

   • 字符串常量池：由于 String 的不可变性，Java 虚拟机（JVM）可以安全地将相同的字符串常量存储在字符串常量池中，从而节省内存。当创建字符串常量时，JVM 会首先检查常量池中是否已存在相同的字符串，如果存在，则直接返回常量池中的引用，而不是创建一个新的对象。
   • 线程安全：由于 String 是不可变的，因此它是线程安全的。这意味着你可以在多线程环境中自由地共享字符串，而无需担心并发修改导致的问题。

示例：自定义不可变类

下面是一个自定义的不可变类的例子，它模拟了一个简单的 Point 类，表示二维空间中的一个点。

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

    // 构造函数
    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    // Getter 方法
    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    // 为了演示，提供一个方法计算点到原点的距离
    // 注意：这个方法不修改对象的状态，只是基于当前状态返回一个新的结果
    public double distanceToOrigin() {
        return Math.sqrt(x * x + y * y);
    }

    // 重写 toString 方法以便于打印对象信息
    @Override
    public String toString() {
        return "Point(" + x + ", " + y + ")";
    }

    // 为了防止子类覆盖 equals 和 hashCode 方法，可以显式提供这些方法
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        ImmutablePoint that = (ImmutablePoint) obj;
        return x == that.x && y == that.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

在这个例子中，ImmutablePoint 类被声明为 final，其字段 x 和 y 被声明为 private 和 final。构造函数用于初始化这些字段，并且没有提供任何修改这些字段的方法。此外，还提供了 equals 和 hashCode 方法的实现，以确保 ImmutablePoint 对象可以被正确地用作集合中的元素或键。

通过遵循这些最佳实践，你可以创建出既安全又高效的不可变对象，这些对象在并发编程和数据共享方面表现出色。