private final static attribute vs private final attribute

by

In general, static means “associated with the type itself, rather than an instance of the type.”

That means you can reference a static variable without having ever created an instances of the type, and any code referring to the variable is referring to the exact same data. Compare this with an instance variable: in that case, there’s one independent version of the variable per instance of the class. So for example:

Test x = new Test();
Test y = new Test();
x.instanceVariable = 10;
y.instanceVariable = 20;
System.out.println(x.instanceVariable);

prints out 10: y.instanceVariable and x.instanceVariable are separate, because x and y refer to different objects.

You can refer to static members via references, although it’s a bad idea to do so. If we did:

Test x = new Test();
Test y = new Test();
x.staticVariable = 10;
y.staticVariable = 20;
System.out.println(x.staticVariable);

then that would print out 20 – there’s only one variable, not one per instance. It would have been clearer to write this as:

Test x = new Test();
Test y = new Test();
Test.staticVariable = 10;
Test.staticVariable = 20;
System.out.println(Test.staticVariable);

That makes the behaviour much more obvious. Modern IDEs will usually suggest changing the second listing into the third.

There is no reason to have an inline declaration initializing the value like the following, as each instance will have its own NUMBER but always with the same value (is immutable and initialized with a literal). This is the same than to have only one final static variable for all instances.

private final int NUMBER = 10;

Therefore if it cannot change, there is no point having one copy per instance.

But, it makes sense if is initialized in a constructor like this:

// No initialization when is declared
private final int number;

public MyClass(int n) {
   // The variable can be assigned in the constructor, but then
   // not modified later.
   number = n;
}

Now, for each instance of MyClass, we can have a different but immutable value of number.

More Related Contents:

  1. Change private static final field using Java reflection
  2. Use of Private static
  3. Behaviour of final static method
  4. in what order are static blocks and static variables in a class executed? [duplicate]
  5. Getting value of public static final field/property of a class in Java via reflection
  6. Why isn’t a qualified static final variable allowed in a static initialization block?
  7. Should a “static final Logger” be declared in UPPER-CASE?
  8. Why are all fields in an interface implicitly static and final?
  9. Java static final values replaced in code when compiling?
  10. Closest Ruby representation of a ‘private static final’ and ‘public static final’ class variable in Java?
  11. How to extend a final class in Java
  12. What is the use of a private static variable in Java?
  13. Java : in what order are static final fields initialized?
  14. Private class property visible
  15. Why are static variables considered evil?
  16. Calling Non-Static Method In Static Method In Java [duplicate]
  17. Comparing strings with == which are declared final in Java
  18. Java synchronized static methods: lock on object or class
  19. Why doesn’t Mockito mock static methods?
  20. Why is the String class declared final in Java?
  21. Are static variables shared between threads?
  22. Can I override and overload static methods in Java?
  23. Compile-time constants and variables
  24. Must all properties of an immutable object be final?
  25. Java: Static Class?
  26. When NOT to use the static keyword in Java?
  27. Will Java Final variables have default values?
  28. Private methods in Inheritance
  29. Difference between Dynamic and Static type assignments in Java
  30. Why is it allowed to access a private field of another object?

Leave a Comment