JAVA热门面试题二

什么是不可变对象(immutable object)？Java中怎么创建一个不可变对象？

不可变对象（Immutable Object）是指一旦创建后，其状态（即对象内部存储的数据）就不能被修改的对象。不可变对象在并发编程、数据共享和持久化存储等场景中非常有用，因为它们可以确保数据的一致性，并且由于状态不可变，可以避免许多并发问题。

在Java中，创建不可变对象通常遵循以下几个原则：

1. 私有成员变量：将对象的所有成员变量设置为私有（private），防止外部直接访问。

2. 不提供setter方法：不提供任何修改成员变量的setter方法，这样外部代码就不能直接修改对象的内部状态。

3. 构造函数初始化：在构造函数中初始化所有成员变量，并在之后不再修改它们。

4. 只提供getter方法：如果需要访问对象的内部状态，可以提供getter方法返回内部状态的副本或不可变视图。

5. 使用final关键字：将类声明为final可以防止子类修改其行为，同时可以将成员变量声明为final，表示一旦初始化之后就不能再被修改（注意，final仅适用于基本数据类型和引用类型的引用本身，如果成员变量是对象引用，对象本身的状态仍可被修改）。

下面是一个简单的不可变对象的例子：

public final class Person {
    private final String name;
    private final int age;

    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // 示例：toString方法
    @Override
    public String toString() {
        return "Person{" +
               "name='" + name + '\'' +
               ", age=" + age +
               '}';
    }

    // 禁止继承
    // private Person() {} // 私有构造函数防止继承（如果类已经是final，则不需要这一步）
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        System.out.println(person); // 输出Person{name='Alice', age=30}

        // 注意：以下操作都是不允许的，或者无法改变Person对象的状态
        // person.setName("Bob"); // 错误，没有setName方法
        // person.setAge(31); // 错误，没有setAge方法
    }
}

注意：虽然Person类的成员变量name和age被声明为final，但name是一个String对象引用。由于String在Java中是不可变的，所以这里没有问题。但如果name是一个可变对象（如StringBuilder），则即便引用本身是final的，其内部状态仍然可以被修改。因此，对于引用类型的成员变量，如果希望它们是“不可变的”，则需要确保这些对象本身也是不可变的，或者通过提供不可变视图（如返回防御性副本）来避免外部修改。

我们能创建一个包含可变对象的不可变对象吗？

是的，我们可以创建一个包含可变对象的不可变对象。然而，这需要我们采取一些额外的措施来确保外部代码不能通过不可变对象的接口来修改其内部的可变对象。

在Java中，这通常意味着我们需要对可变对象进行封装，并在不可变对象内部持有这些可变对象的不可变视图或防御性副本。这样，即使内部的可变对象本身是可以修改的，外部代码也无法通过不可变对象的接口来修改它。

以下是一个简单的例子，展示了如何创建一个包含可变对象的不可变对象：

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public final class ImmutableContainer {
    // 使用Collections.unmodifiableList来创建一个不可修改的列表视图
    private final List<String> data;

    public ImmutableContainer(List<String> initialData) {
        // 创建一个内部可变对象的不可变视图
        this.data = Collections.unmodifiableList(new ArrayList<>(initialData));
    }

    // Getter方法返回内部列表的不可变视图
    public List<String> getData() {
        return data;
    }

    // 禁止继承
    private ImmutableContainer() {}

    public static void main(String[] args) {
        ImmutableContainer container = new ImmutableContainer(Arrays.asList("A", "B", "C"));
        System.out.println(container.getData()); // 输出: [A, B, C]

        // 尝试修改列表将抛出UnsupportedOperationException
        // container.getData().add("D"); // 这将抛出异常

        // 但请注意，如果initialData本身在创建ImmutableContainer后被修改，
        // 那么这个修改可能会反映到ImmutableContainer的内部（尽管getData()返回的视图仍然不可变）
        // 为了避免这种情况，可以在构造函数中创建initialData的深拷贝
    }
}

然而，需要注意的是，如果initialData列表在创建ImmutableContainer实例之后被外部代码修改，那么这个修改可能会（在某些情况下）影响到ImmutableContainer内部的data列表（尽管getData()方法返回的列表视图仍然是不可变的）。为了避免这种情况，我们可以在构造函数中创建initialData的深拷贝，而不是直接使用它。

但在这个特定的例子中，由于我们使用了Collections.unmodifiableList()，所以即使initialData被修改，data列表的视图仍然是不可变的。不过，如果initialData包含的是可变对象（如自定义的可变对象列表），那么这些内部对象的可变性就需要额外注意和处理了。

总之，通过封装和提供不可变视图，我们可以创建包含可变对象的不可变对象，但需要注意确保这些可变对象的状态不会通过不可变对象的接口被外部修改。