Can a class that does not have final modifier in it be fully immutable ?
For example, is the following class immutable ?
class Animal
{
private String animalName;
public Animal(String name) {
animalName = name;
}
public String getName() { return animalName; }
}
Yes.
The class (as depicted in your question) is immutable, as none of its internal state may be changed. Even if you were to define a subclass of the Animal class, it could not change animalName; however, while the Animal class is immutable, its subclasses may or not be immutable (depending on their implementation).
The danger of doing this is that if someone were to define a subclass as an inner class within the Animal class (as follows), then they could violate your immutability:
class Animal {
private String animalName;
public Animal(String name) {
animalName = name;
}
public getName() { return animalName; }
public class Eagle extends Animal {
public Eagle() {
super("Eagle");
}
public void foo() {
animalName = animalName + "!";
}
}
}
For this reason, it's great to use private visibility and the final modifier, wherever possible. This will prevent people from accidentally introducing code that violates immutability or encapsulation constraints that you have meant to impose. That way, it must be a conscious decision on the programmer's part to increase the visibility or remove the final keyword, and therefore they shall not introduce any "accidents" as described above.
Yes. It is fully immutable. Or to be more precise, its instances are fully immutable.
There can (of course) be subclasses that are not immutable ... but that does not affect the mutability of an instance of the Animal class.
Writing immutable classes is easy. A class will be immutable if all of the following are true:
1 All of its fields are final
2 The class is declared final
3 The this reference is not allowed to escape during construction
4 Any fields that contain references to mutable objects, such as arrays, collections, or mutable classes like Date:
4.1 Are private
4.2 Are never returned or otherwise exposed to callers
4.3 Are the only reference to the objects that they reference
4.4 Do not change the state of the referenced objects after construction
No, your Animal class is not immutable, because it allows subclassing.
Why not?
See this example subclass:
public class ExceptionalAnimal extends Animal {
public ExceptionalAnimal() {
super(null);
}
@Override
public String getName() {
throw new AssertionError("Oops.. where did that come from?");
}
}
Why does this matter?
Immutability is commonly used to guarantee:
If a class allows subclassing, none of these guarantees can be relied upon. If you have a method accepting an Animal as a parameter, anyone can pass in a subclass that breaks these guarantees.
Fix: No public or protected constructors
One often used technique is to not have any public or protected constructors. This prevents subclassing from outside your package and inside your package you could still have your own internal subclasses. Which you cannot if the class is final.
The immutable collection classes from Google's Guava library use this technique. From the Javadoc:
Although this class is not final, it cannot be subclassed as it has no public or protected constructors. Thus, instances of this type are guaranteed to be immutable.
A client can create ImmutableLists with the static of() and copyOf methods.
See also Effective Java, Item 4: Enforcing noninstantiability with a private constructor.
Be aware that guaranteeing immutability by having no public or protected constructors is easier to break than making the class final. For example Mockito will let you mock these cases by default:
ImmutableList notSoImmutable = mock(ImmutableList.class)
when(notSoImmutable.size()).thenThrow(new AssertionError("Oops.. where did that come from?"));
On package private classes
As your Animal class is package private it is not possible to create subclasses of it outside of its package. So assuming that in its package you only create subclasses of Animal that respect it's contract, the class is actually immutable.
For my answer I assumed that Animal is public. If you were interested specifically in package private classes, please ignore my answer ;-)
As long as you have no public setter method as is the case in your example the objects of your class will be immutable.
In Java this may be bypassed using the Reflection API as it allows modification of all kinds of fields.
Putting the final modifier on a class means that it can't be subclassed
