Object mutability

[Ryan McClain]

Referring to: Head First Servlets & JSP: page 204. Quote: "(And since you're a Java programmer you know that even a final variable can still be manipulated unless it's immutable)"
This topic is not about servlets or jsp.

How would one mutate an object that is final? By referencing the object and then doing a mutate() operation on it? e.g.:
final Object o = new Object();
o.mutate();

I don't understand. If it was declared final, then how come you are allowed to mutate it (or is that not true)?

How would one make the Object immutable then? Meaning: not mutable in any way, not even by reference.
How do I make sure a reference cannot modify the object it refers to? So that MyObject o = new Object(); o.modify(); is not possible?

I also read on Wikipedia the following example:
final Position pos = new Position(); //pos is immutable
members:
pos.x, pos.y, pos.z are mutable still, unless they are declared final.

So if I am understanding this correctly, in order to make an object/class completely immutable, everything in it including its reference has to be declared final? e.g.:

final Position pos = new Position();

class Position {
final int x;
final int y;
final int z;

public Position(){
x=1;
y=2;
z=3;
}

final void doA(){}
final void doB(){}
}

I am confused on this topic.

[Darryl Burke]

Objects aren't final; references variables are.

[Chan Ag]

How would one make the Object immutable then? Meaning: not mutable in any way

Here is a helpful page.
http://docs.oracle.com/javase/tutorial/essential/concurrency/imstrat.html

And here is a very helpful post.
https://coderanch.com/t/613910/java/java/Creating-Immutable-Classes-object-reference

HIH

Chan.

[Jesper de Jong]

As Darryl already mentioned, objects cannot be final; variables can be.

You have to be aware of the distinction between objects and variables; they're not the same thing. A variable* is a reference (i.e., a pointer) to an object. Making a variable final means that you can't change the variable, in other words, you can't make the variable refer to another object. It doesn't mean that you cannot change the state of the object that the variable refers to.

To have an immutable object, the class that the object was made from has to be designed to be immutable. Some classes in Java's standard library are immutable, and some aren't. For example, class String is immutable; once a String object is initialized, its content cannot be modified (and it doesn't matter if your variable that refers to the String is final or not). Class Date is mutable; you can change its contents (even if the variable that refers to it is final).

// Non-final variable s, referring to an immutable String object
String s = "Hello World";

// Final variable d, referring to a mutable Date object
final Date d = new Date();
d.setYear(2014);

To make a class immutable, you'll have do a few things: make all member variables final, do not add any methods to the class that can change the state of the object, and make the class itself final so that subclasses can't make it mutable.

You have to be careful, because subtle things can go wrong. If you have any member variables that are of a mutable type, you should be careful that you don't let them leak out, so that outside code might indirectly change the state of the object. Here's an example with two bugs:

final class NotReallyImmutable {
    private final String name;
    private final Date date;

    public NotReallyImmutable(String name, Date date) {
        this.name = name;
        this.date = date;
    }

    public String getName() {
        return name;
    }

    public Date getDate() {
        return date;
    }
}

There are two places where this class has leaks; through the constructor, and through the getDate() method:

Date date = new Date();
NotReallyImmutable one = new NotReallyImmutable("Jesper", date);

// Problem: We can change the state of the Date object stored in the NotReallyImmutable object!
date.setYear(2014);

NotReallyImmutable two = new NotReallyImmutable("Jesper", new Date());

// Problem: We can change the state of the Date object through the getter method!
two.getDate().setYear(2015);

To fix these, you'll have to make copies of the Date object in the constructor and the getter:

final class ReallyImmutable {
    private final String name;
    private final Date date;

    public ReallyImmutable(String name, Date date) {
        this.name = name;

        // Make a copy of the Date object that's passed in
        this.date = new Date(date.getTime());
    }

    public String getName() {
        return name;
    }

    public Date getDate() {
        // Return a copy of the Date object
        return new Date(date.getTime());
    }
}

* of a non-primitive type

[Chan Ag]

Fantastic example. Thank you so much, Jesper de Jong.