If a constant is not static, Java will allocate a memory for that constant in every object of the class (i.e., one copy of the constant per object). If a constant is static, there will be only one copy of the constant for that class (i.e., one copy per class). Therefore, if the constant has … Read more
Just having final will have the intended effect. final int x = 5; … x = 10; // this will cause a compilation error because x is final Declaring static is making it a class variable, making it accessible using the class name <ClassName>.x
final declares an object reference that can’t be modified, e.g. private final Foo something = new Foo(); creates a new Foo and places the reference in something. Thereafter, it’s not possible to alter something to point to a different instance of Foo. This does not prevent modification of the internal state of the object. I … Read more
I don’t consider it’s bad practice to mark a static method as final. As you found out, final will prevent the method from being hidden by subclasses which is very good news imho. I’m quite surprised by your statement: Re-defining method() as final in Foo will disable the ability for Bar to hide it, and … Read more
You can’t get much simpler than using an enum with no instances. public enum MyLib {; public static void myHelperMethod() { } } This class is final, with explicitly no instances and a private constructor. This is detected by the compiler rather than as a runtime error. (unlike throwing an exception)
You could add a comment in there to the effect of: # We’ll fire you if you override this method. It’s surprising how well low-tech solutions like this work in practice.
Virtual (overridden) methods generally are implemented via some sort of table (vtable) that is ultimately a function pointer. Each method call has the overhead of having to go through that pointer. When classes are marked final then all of the methods cannot be overridden and the use of a table is not needed anymore – … Read more
Yes of course: static final variables can be initialized in a static block but…. you have implicit GOTOs in that example (try/catch is essentially a ‘GOTO catch if something bad happens’). If an exception is thrown your final variables will not be initialized. Note that the use of static constructs goes against Object-Oriented dogma. It … Read more
Yes, it can be changed. Only the references cannot be changed, but its internal fields can be. The following code shows it: public class Final { static final Point p = new Point(); public static void main(String[] args) { p = new Point(); // Fails p.b = 10; // OK p.a = 20; // Fails … Read more
It means that if your final variable is a reference type (i.e. not a primitive like int), then it’s only the reference that cannot be changed. It cannot be made to refer to a different object, but the fields of the object it refers to can still be changed, if the class allows it. For … Read more