如何在将用户定义的类对象作为类成员的 Java 中创建用户定义的不可变类？

Question

I want to make my immutable class EmployeeDetails which has Employee object in it. I have followed conditions to make class immutable: 1. class is final 2. class members are final 3. no setters

If EmployeeDetails is immutable, I should not be able to change content in it. Still, I can change employee name or id.

What I am missing here?

public class TestImmutable{
    public static void main(String args[]){
        EmployeeDetails empd1 = new EmployeeDetails("ABC", new Employee(1, "n1"));

        System.out.println("Id   : " + empd1.getEmployee().getId());
        System.out.println("Name : " + empd1.getEmployee().getName());
        System.out.println("Empr : " + empd1.getEmployer());

        empd1.getEmployee().setId(2);
        empd1.getEmployee().setName("n2");
        System.out.println("\nId   : " + empd1.getEmployee().getId());
        System.out.println("Name : " + empd1.getEmployee().getName());
        System.out.println("Empr : " + empd1.getEmployer());
    }
}

final class EmployeeDetails{
    private final String employer;
    private final Employee emp1;

    public EmployeeDetails(String employer, Employee emp1){
        this.employer = employer;
        this.emp1 = emp1;
    }

    public String getEmployer(){
        return this.employer;
    }

    public Employee getEmployee(){
        return this.emp1;
    }
}

class Employee{
    public int id;
    public String name;

    public Employee(int id, String name){
        this.id = id;
        this.name = name;
    }

    public int getId(){
        return this.id;
    }

    public String getName(){
        return this.name;
    }

    public void setId(int id){
        this.id = id;
    }

    public void setName(String name){
        this.name = name;
    }
}   

Answer 1

Get rid of getEmployee() . You shouldn't be able to reach Employee emp1 outside EmployeeDetails . If you need access to the fields in Employee emp1 , then provide public methods that return them.

For example:

final class EmployeeDetails{
    private final String employer;
    private final Employee emp1;

    public EmployeeDetails(String employer, Employee emp1){
        this.employer = employer;
        this.emp1 = emp1;
    }

    public String getEmployer(){
        return this.employer;
    }

    public String getEmployeeName() {
        return this.emp1.getName();
    }

    ...
}

Answer 2

Making a variable final means that you cannot assign it again to some other object. You can still modify the state of the object whose reference it holds.

In this case :

final class EmployeeDetails{
  private final String employer;
  **private final Employee emp1;**
}

You cannot assign emp1 to a new object but you can still change the state of the employee object as it is not immutable. You can make Employee objects immutable by removing all the setters.

Answer 3

I have followed conditions to make class immutable: 1. class is final 2. class members are final 3. no setters

The conditions you have laid out are necessary but not sufficient to make a class immutable. Confused?

Immutability is about preserving the state of class instances for all time. Once an instance of a class is created, then all the attributes that comprise the state of that instance must remain forever unchanged.

What happens if 1 through 3 above are satisfied, but one of your instance fields is a mutable class? In this case, returning the reference to that instance field to a client makes it possible for the client to mutate the state of your supposedly immutable class.

One solution is to perform defensive copying upon all instance fields of the immutable class that are, themselves, mutable. Instead of...

public Employee getEmployee(){
    return this.emp1;
}

change this code so that a new copy of the Employee object is returned to the client. This assures that clients can not get a reference to the internal state of the instances of your immutable class:

public Employee getEmployee(){
    return this.emp1.clone();  // this solution assumes that Employee
                               // is safely cloneable, which requires some
                               // care on your part.  An alternative is
                               // to define a copy constructor in the
                               // Employee class and: return new Employee(emp1);
}

Defensive copying is necessary for all mutable components of an immutable class, and this rule must be applied during both construction and field access. Otherwise, you make it possible for client code to retain a reference to the mutable internal state of your class.

Answer 4

The EmployeeDetails class is not immutable. You have followed the usual rules for immutability except one. In Joshua Bloch's Effective Java this rule is stated as follows:

Ensure exclusive access to any mutable componenent.

In your case, since the class Employee is mutable, you need to copy Employee instances in the getter and the constructor.

public Employee getEmployee() {
    return new Employee(emp1.getId(), empl.getName());       // Copy
}

public EmployeeDetails(String employer, Employee emp1){
    this.employer = employer;
    this.emp1 = new Employee(emp1.getId(), empl.getName());  // Copy
}

Since this version uses copies, it is not possible to modify the internals of the EmployeeDetails class.

This solution is very common. For example, the String class is immutable. Both the constructor String(char[] value) and the method char[] toCharArray() make copies of the array. This is necessary because arrays are mutable.

Another solution, which may be more appropriate for your situation, is to make Employee immutable as well.

You could even get rid of the Employee class completely and just use two fields in the EmployeeDetails class.