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 be 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; eg

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

Answer 6

子类的重写方法无法访问私有字段...因此子类方法无法更改超类的私有字段...那么将不可变类作为final是什么用途？

Answer 7

Final keywords prevents the other classes to inherit it. Final keyword doesn't make it immutable but there are such condition as making the instance class members private as well final and by using getters and not using setters

Answer 8

A final immutable classes cannot be mutated. Here below it shows a non-final immutable class being mutated:

// a class not intended to be mutated 
public class GoodClass{

   private String name;

   public GoodClass() {
       this.name = "Good Class Neme";
   }

   public String getName() {
       return name;
   }
}

public class BadClass extends GoodClass {

   private String name;

   public String getName() {
       return name;
   }

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