Is there a difference between directly assigning a final variable and assigning a final variable in the constructor?

Question

is there a difference between these two initializations of the final variable value?

class Test {
    final int value = 7;
    Test() {}
}

and

class Test {
    final int value;
    Test() {
        value = 7;
    }
}

--

EDIT: A more complex example, involving subclasses. "0" is printed to stdout in this case, but 7 is printed if i assign the value directly.

import javax.swing.*;
import java.beans.PropertyChangeListener;

class TestBox extends JCheckBox {

    final int value;

    public TestBox() {
        value = 7;
    }

    public void addPropertyChangeListener(PropertyChangeListener l) {
        System.out.println(value);
        super.addPropertyChangeListener(l); 
    }

    public static void main(String... args) {
        JFrame frame = new JFrame();
        JPanel panel = new JPanel();
        frame.setContentPane(panel);
        panel.add(new TestBox());
        frame.pack();
        frame.setVisible(true);
    }
}

Answer 1

There is differece in byte-code level:

Source code:

  final int value;

  public TestBox() {
      value = 7;
  }

Produces following code from addPropertyChangeListener:

   0:   getstatic       #3; 
   3:   aload_0
   4:   getfield        #2; 
   7:   invokevirtual   #4; 

And source code:

final int value = 7;

public TestBox() {      
}

Produces the following code from addPropertyChangeListener:

   0:   getstatic       #3; 
   3:   bipush  7
   5:   invokevirtual   #4; 

So there is a small difference. But not practical.

Seems that compiler can handle a final variable as a constant if it is intialized in definition statement. Of course different compilers may do it different way.

Answer 2

Tried with a very simple example and yes, when value is accessed in the parent's constructor it is unitialized (as it should be), unless it's final and initialized when declared. The process is that described by EJP, but with a #0 step: finals are initialized with the specified value, if any.

Answer 3

A common misinterpretation of a final variable is that it can't change its value. The actual meaning of the final modifier (JLS 4.5.4) is that "a final variable may only be assigned to once".

You've run into one of the situations where it is possible to evaluate a so called "blank final" (declared, but not yet assigned) variable, so that it evaluates to the default value for the specified datatype, even if its later assigned a different value.