DIfference between a static final field and an instance final field initialized at declaration when accessed through an object

Question

• First example

  public class MyClass {
      final int x = 2;
  }
  

  x is

  1. final which means it can never be set after initialization.
  2. Initialized at declaration which means it can't have a different value assigned to it later (even in the constructor).
  3. fixed (regardless of the instance) because its value can't be changed in the constructor (or anywhere else really).

• Second example

  public class MyOtherClass {
      static final int x = 3;
  }
  

  x is

  1. final which means it can never be set after initialization.
  2. Initialized at declaration which means it can't have a different value assigned to it later.
  3. a static field and the value will always remain the same regardless of the instance.
  4. constant because it is both static and final.

My questions are

What are the differences between both? (excluding creation time)

Am i missing something?

Answer 1

The differences between x in MyClass and MyOtherClass are:

• the first can only be accessed via a MyClass instance and there can be multiple copies of the constant.

• the second can be accessed without MyOtherClass instance and only one copy can exist.

In your example, there is no practical difference¹ between having one or multiple instances of the constant. However consider this:

public class YetAnotherClass {
    final int x;

    public YetAnotherClass(int x) {
        this.x = x;
    }
}

... which shows how an instance constant can have different values in different instances.

---

^{1 - That is an overstatement. First, static final int x = 3; is declaring a compile-time constant, and a compile-time constant can be used in a switch case expression, where a non-compile-time constant can't. Second the non-static version of the constant will occupy space in each and every instance of MyClass. Finally, there will be differences in behaviour if you are daft enough to try to change the constants using reflection. (Just don't do it ...)}

Answer 2

Although final, the JVM does not make any optimizations or assumptions, so each instance of the class will have an instance of x. If you declare the member static, each instance of the class will share the same instance of x because it's statically allocated. Moreover, as written (x has package visibility), other classes can potentially access x statically, i.e., without having an instance of the class available.

Answer 3

If you create multiple instances of both type of classes then,

In First scenario all object of MyClass would have own final x field.

Where as in second scenario all object of MyOtherClass would have points to one final x class field as because it is static in nature.

Answer 4

Difference : Static belongs to class So You can access it without any instance of the class and hence only one copy of it.

While for accessing second one you need instance of an class to access it so you can have as many copy of non static final Object as it belongs to Object.

You can Verify with Byte Code: For Static

Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return

For Non-Static Final

Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: iconst_2
         6: putfield      #2                  // Field x:I
         9: return
      LineNumberTable:

As you can see it's has putfield Which sets the value of the field identified in objectref (a reference to an object)