Do final fields really prevent mutability in Java?

Question

From the famous book Java Concurrency in Practice chapter 3.4.1 Final fields

Just as it is a good practice to make all fields private unless they need greater visibility[EJ Item 12] , it is a good practice to make all fields final unless they need to be mutable.

My understanding of final references in Java : A final reference/ field just prevents the the field from getting re initialized but if it references a mutable object , we can still change its state rendering it mutable . So I am having difficulty understanding the above quote . What do you think ?

Answer 1

final fields prevent you from changing the field itself (by making it "point" to some other instance), but if the field is a reference to a mutable object, nothing will stop you from doing this:

public void someFunction (final Person p) {
    p = new Person("mickey","mouse"); //cant do this - its final
    p.setFirstName("donald");
    p.setLastName("duck");
}

the reference p above is immutable, but the actual Person pointed to by the reference is mutable. you can, of course, make class Person an immutable class, like so:

public class Person {
    private final String firstName;
    private final String lastName;
    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    //getters and other methods here
}

such classes once created, cannot be modified in any way.

Answer 2

This quote says only what is says:

make all fields final unless they need to be mutable

mutable field is a field that you can later change to point to another object. If the field is final, it can still reference mutable object (e.g. java.util.Date). Thus the field is immutable (always points to the same object), but this object is mutable.

Answer 3

in java final is similer to this:

int *const p=&something //constant pointer.in c++. you can't use this pointer to change something but that something can be changed with its own.

in java final fields can't be changed but the object to who they refer may change by its own . Ex. 'this' is final you can't assign anything to this but you can assign to object to whom this refer.

From your Ques:

it is a good practice to make all fields final unless they need to be mutable.

to just avoid any modification(either logically or accidently) to original it's always good to make them final.