Why would one declare an immutable class final in Java?

by

If you don’t mark the class final, it might be possible for me to suddenly make your seemingly immutable class actually mutable. For example, consider this code:

public class Immutable {
     private final int value;

     public Immutable(int value) {
         this.value = value;
     }

     public int getValue() {
         return value;
     }
}

Now, suppose I do the following:

public class Mutable extends Immutable {
     private int realValue;

     public Mutable(int value) {
         super(value);

         realValue = value;
     }

     public int getValue() {
         return realValue;
     }
     public void setValue(int newValue) {
         realValue = newValue;
     }

    public static void main(String[] arg){
        Mutable obj = new Mutable(4);
        Immutable immObj = (Immutable)obj;              
        System.out.println(immObj.getValue());
        obj.setValue(8);
        System.out.println(immObj.getValue());
    }
}

Notice that in my Mutable subclass, I’ve overridden the behavior of getValue to read a new, mutable field declared in my subclass. As a result, your class, which initially looks immutable, really isn’t immutable. I can pass this Mutable object wherever an Immutable object is expected, which could do Very Bad Things to code assuming the object is truly immutable. Marking the base class final prevents this from happening.

Hope this helps!

More Related Contents:

  1. Must all properties of an immutable object be final?
  2. Cannot refer to a non-final variable inside an inner class defined in a different method
  3. Change private static final field using Java reflection
  4. Difference between final and effectively final
  5. String is immutable. What exactly is the meaning? [duplicate]
  6. How does the “final” keyword in Java work? (I can still modify an object.)
  7. What is meant by immutable?
  8. Why should I use the keyword “final” on a method parameter in Java?
  9. Why would one mark local variables and method parameters as “final” in Java? [closed]
  10. Immutable array in Java
  11. Immutable class?
  12. Behaviour of final static method
  13. Good reasons to prohibit inheritance in Java?
  14. Immutable vs Unmodifiable collection [duplicate]
  15. final keyword in method parameters [duplicate]
  16. in what order are static blocks and static variables in a class executed? [duplicate]
  17. Is Integer Immutable
  18. Why are all fields in an interface implicitly static and final?
  19. creating final variables inside a loop
  20. The final local variable cannot be assigned
  21. Mutable objects and hashCode
  22. Anonymous-Inner classes showing incorrect modifier
  23. Will the jit optimize new objects
  24. Why can final object be modified?
  25. Make immutable Java object
  26. Why defining class as final improves JVM performance?
  27. Immutable Type: public final fields vs. getter
  28. How is concatenation of final strings done in Java?
  29. final fields and thread-safety
  30. Why do variables passed to runnable need to be final?

Leave a Comment