Using this.var during var's initialization [duplicate]

Answer 1

Use of simple name is not allowed in case of forward references as per JSL. So it is must to use this keyword to access such variables.

class UseBeforeDeclaration {
    int h = j++;  // error - `j` read before declaration
    int l = this.j * 3;  // ok - not accessed via simple name
    int j;
}

Answer 2

Introduction of Chapter 16

Chapter 16 describes the precise way in which the language ensures that local variables are definitely set before use. While all other variables are automatically initialized to a default value, the Java programming language does not automatically initialize local variables in order to avoid masking programming errors.

Answer 3

Nothing wrong in this. this keyword refers the current object and it is used to differentiate the local variable and instance variable. The value of local variable can be assigned into instance variable likewise, the vice verse also possible. That means we can assign the value of instance variable into a local variable.

refer the chapter 4.12.3 Kinds of Variables from http://docs.oracle.com/javase/specs/jls/se7/jls7.pdf (page 80). The example also given here.

      **Example 4.12.3-1. Different Kinds of Variables**
      class Point { 
      static int numPoints; // numPoints is a class variable 
      int x, y; // x and y are instance variables 
      int[] w = new int[10]; // w[0] is an array component 
      int setX(int x) { // x is a method parameter 
        int oldx = this.x; // oldx is a local variable 
        this.x = x; 
        return oldx; 
      } 
    }

Answer 4

It is mentioned in passing in the Example 8.3.2.3-1 in section 8.3.2.3. In the text to the example

class Z {
    static int peek() { return j; }
    static int i = peek();
    static int j = 1;
}
class Test {
    public static void main(String[] args) {
        System.out.println(Z.i);
    }
}

the caption says:

... the variable initializer for i uses the class method peek to access the value of the variable j before j has been initialized by its variable initializer, at which point it still has its default value (§4.12.5).

This should map directly to your situation.

Answer 5

Chapter 8.3.2.2. paragraph 2:

Initialization expressions for instance variables are permitted to refer to the current object this (§15.8.3) and to use the keyword super (§15.11.2, §15.12).

Although the next paragraph adds:

Use of instance variables whose declarations appear textually after the use is sometimes restricted, even though these instance variables are in scope. See §8.3.2.3 for the precise rules governing forward reference to instance variables.

Answer 6

Since all non-local variables are assigned an initial value (and the assignment happens-before everything else), there is no problem to read them at any time.

The spec selectively forbids some accesses at some situations, reasoning that such accesses are most likely programming mistakes. But had these accessed been allowed, they'll have well-defined semantics.

Actually a programmer can easily bypass the restrictions and "indirectly" access the field anyway; the semantics of that access is the same as the "direct" access if it were allowed.

int var = this.var + 1;       // suppose javac forbids this

int var = this.getVar() + 1;  // but can javac forbid this?