java: “final” System.out, System.in and System.err?

by

JLS 17.5.4 Write Protected Fields:

Normally, final static fields may not be modified. However System.in, System.out, and System.err are final static fields that, for legacy reasons, must be allowed to be changed by the methods System.setIn, System.setOut and System.setErr. We refer to these fields as being write-protected to distinguish them from ordinary final fields.

The compiler needs to treat these fields differently from other final fields. For example, a read of an ordinary final field is “immune” to synchronization: the barrier involved in a lock or volatile read does not have to affect what value is read from a final field. Since the value of write-protected fields may be seen to change, synchronization events should have an effect on them. Therefore, the semantics dictate that these fields be treated as normal fields that cannot be changed by user code, unless that user code is in the System class.

By the way, actually you can mutate final fields via reflection by calling setAccessible(true) on them (or by using Unsafe methods). Such techniques are used during deserialization, by Hibernate and other frameworks, etc, but they have one limitation: code that have seen value of final field before modification is not guaranteed to see the new value after modification. What’s special about the fields in question is that they are free of this limitation since they are treated in special way by the compiler.

More Related Contents:

  1. Cannot refer to a non-final variable inside an inner class defined in a different method
  2. Change private static final field using Java reflection
  3. Difference between final and effectively final
  4. How does the “final” keyword in Java work? (I can still modify an object.)
  5. Does use of final keyword in Java improve the performance?
  6. Comparing strings with == which are declared final in Java
  7. Why should I use the keyword “final” on a method parameter in Java?
  8. Why would one mark local variables and method parameters as “final” in Java? [closed]
  9. Lambdas: local variables need final, instance variables don’t
  10. Why is the String class declared final in Java?
  11. Behaviour of final static method
  12. Why would one declare an immutable class final in Java?
  13. Good reasons to prohibit inheritance in Java?
  14. Why does the Java compiler not understand this variable is always initialized?
  15. final keyword in method parameters [duplicate]
  16. in what order are static blocks and static variables in a class executed? [duplicate]
  17. Must all properties of an immutable object be final?
  18. Why are all fields in an interface implicitly static and final?
  19. Final variable manipulation in Java
  20. Will Java Final variables have default values?
  21. creating final variables inside a loop
  22. The final local variable cannot be assigned
  23. Anonymous-Inner classes showing incorrect modifier
  24. Why can final object be modified?
  25. Final arguments in interface methods – what’s the point?
  26. Why defining class as final improves JVM performance?
  27. How is concatenation of final strings done in Java?
  28. Why declare a function argument to be final?
  29. Make private methods final?
  30. Why do variables passed to runnable need to be final?

Leave a Comment