Are all final class immutable?

Question

Are all final classes in Java immutable. String and Integer both are final classes and both are immutable i beleive.

Answer 1

No, final means the class can not be extended. It says nothing about mutability. For example:

final class MutInt {
   public int modifyMe;
}

Answer 2

No - a final class means you cannot inherit from it. It has nothing to do with mutability. The following class is final yet mutable:

public final class FinalMutable {
  int value;
  public void setValue(int v) { value=v; }
  public int getValue() { return value; }
}

Answer 3

There is no keyword for immutability, it's more like a design pattern.

EDIT:
This means, there is no keyword, that makes a class immutable. To make a class immutable, you have to protect the internals by make them final or private.

The confusing thing is this: The final keyword has different meanings when used on a class then it has when used on a field/variable. The former means "this class can not be extended". The Second means "this variable (or reference) can not me changed".

Answer 4

Further to the other responses, if you look at the code for java.lang.String you'll see it contains a field: hash, which is mutable and is in fact computed and stored when hashCode() is called for the first time.

However, the class is still immutable: The hash field cannot be accessed directly or modified outside of the class.

Also, you may notice a common approach within the JDK is the implementation of immutable wrappers that can be used to expose an object's internal state without allowing it to be modified; e.g.

private final List<String> values;

public List<? get String> getValues() {
  return Collections.unmodifiableList(values);
}

Answer 5

As has been said by the others before final does not make a class imuutable in Java though it plays a part in the immutability strategy. To obtain immutability you should follow the general guidlines:

• ensure the class cannot be overridden - make the class final, or use static factories and keep constructors private
• make fields private and final
• force callers to construct an object completely in a single step, instead of using a no-argument constructor combined with subsequent calls to setXXX methods (that is, avoid the Java Beans convention)
• do not provide any methods which can change the state of the object in any way - not just setXXX methods, but any method which can change state
• if the class has any mutable object fields, then they must be defensively copied when passed between the class and its caller