Difference between private final and private final Static for the use of immutability

Question

An attribute when declared with the modifier Static has the characteristic of "propagating its value" by all instances of the class to which it belongs, that is, its value will be the same for all instances. Due to this feature these attributes are named after class variables. They have their value stored in a fixed address memory. Here is an example:

class Foo {
    public static int count = 0 ;
    Foo() { 
        ++count;
    }
}

Another use for the Static modifier is when we want to make an immutable attribute unalterable, achieved from the addition of the final modifier, as in the following example:

class Carro {
    private static final int RODAS = 4;
    ...
}

The same result is when we declare the attribute without the Static modifier, only with the final modifier.

class Carro {
    private final int RODAS = 4;
    ...
}

In both instructions we achieve the same goal, that of making the value of an attribute immutable. Given this, what is the real advantage of using the Static modifier in creating immutable variables? Is there any real gain related to performance?

Answer 1

There are some false premises in your question:

"In both the instructions [Static and final] we achieve the same goal, that of making the value of an unchanging attribute."

The objective of Static is not to implement immutability but rather to declare the member (method, "field", "property", "attribute"...) in a class instead of publishing in an object (an instance of the class).

You may have confused Static with immutable knowledge that once assigned a value to a static member, the reference will remain throughout the application lifecycle - the referenced object will never be collected by the Garbage Collector while the app is running.

But this static member is not immutable, since at any time you can assign another value to it (change its reference to that of another object) or even change the state of the object it references.

The keyword final yes, this helping to implement immutable objects since you can only assign value to the "final" member once, and since the compiler requires this value to be assigned already in the class constructor (if it has not already been assigned in the static member’s own declaration).

So, by directly answering the questions:

• "What is the real advantage of using the Static modifier in creating immutable variables?" - Answer: none.

• "Is there any real gain related to performance?" - Answer: no.

• "Difference between private final and private final Static for the use of immutability." - Answer: no difference regarding the immutability of the variable.

Answer 2

When you do not use Static you will have the variable created for each instance of the object, already using Static it will be created only once (it will be of the class and not of the instance). How this will impact your system depends on many other factors.

Answer 3

The difference between Static and final is as follows: private example Static final int A = 10; private Static int B = 15;

      Suponha que a classe que você declarou essas variáveis chama-se (Test)
      ao criar um objeto a partir dessa classe sua variável do tipo static final
      não pode ser alterada o valor por exemplo você não pode fazer isso 
      Test test = new Test(); 
      test.setA(20); Você não consegue mudar o valor da variável.
       
      Já na variável somente static você pode mudar o valor
      Exemplo Test test = new Test();
      test.setB(20); Você consegue altear o valor da variável
      Isso é possível porém se você instanciar outro objeto com outro valor 
      por exemplo Test test2 = new Test();
      test2.setB(30);
      vai prevalecer o valor do ultimo objeto instanciado.
      e test.setB(20); deixa de existir.
      você não pode ter mais de um objeto com valores diferente quando é do 
      tipo statico.