6.5.5 Meaning of Expression Names

The meaning of a name classified as an ExpressionName is determined as follows.

6.5.5.1 Simple Expression Names

If an expression name consists of a single Identifier, then:

• If the Identifier appears within the scope (§6.3) of a local variable declaration (§14.3) or parameter declaration (§8.4.1, §8.6.1, §14.18) with that name, then the expression name denotes a variable, that is, that local variable or parameter. Local variables and parameters are never hidden (§6.3, §6.3.1, §14.3), so there is necessarily at most one such local variable or parameter. The type of the expression name is the declared type of the local variable or parameter.
• Otherwise, if the Identifier appears within a class declaration (§8):
  • If there is not exactly one member of that class (§8.2) that is a field with that name, then a compile-time error results.
  • Otherwise, if the single member field with that name is declared final (§8.3.1.2), then the expression name denotes the value of the field. The type of the expression name is the declared type of the field. If the Identifier appears in a context that requires a variable and not a value, then a compile-time error occurs.
  • Otherwise, the expression name denotes a variable, the single member field with that name. The type of the expression name is the field's declared type.

If the field is an instance variable (§8.3.1.1), the expression name must appear within the declaration of an instance method (§8.4), constructor (§8.6), or instance variable initializer (§8.3.2.2). If it appears within a static method (§8.4.3.2), static initializer (§8.5), or initializer for a static variable (§8.3.1.1, §12.4.2), then a compile-time error occurs.

• Otherwise, the identifier appears within an interface declaration (§9):
  • If there is not exactly one member of that interface (§9.2) that is a field with that name, then a compile-time error results.
  • Otherwise, the expression name denotes the value of the single member field of that name. The type of the expression name is the declared type of the field. If the Identifier appears in a context that requires a variable and not a value, then a compile-time error occurs.

In the example:

class Test {

	static int v;


	static final int f = 3;


	public static void main(String[] args) {
		int i;
		i = 1;
		v = 2;
		f = 33;										// compile-time error
		System.out.println(i + " " + v + " " + f);
	}

}

the names used as the left-hand-sides in the assignments to i, v, and f denote the local variable i, the field v, and the value of f (not the variable f, because f is a final variable). The example therefore produces an error at compile time because the last assignment does not have a variable as its left-hand side. If the erroneous assignment is removed, the modified code can be compiled and it will produce the output:

1 2 3

6.5.5.2 Qualified Expression Names

If an expression name is of the form Q.Id, then Q has already been classified as a package name, a type name, or an expression name:

• If Q is a package name, then a compile-time error occurs.
• If Q is a type name that names a class type (§8), then:
  • If there is not exactly one accessible (§6.6) member of the class type that is a field named Id, then a compile-time error occurs.
  • Otherwise, if the single accessible member field is not a class variable (that is, it is not declared static), then a compile-time error occurs.
  • Otherwise, if the class variable is declared final, then Q.Id denotes the value of the class variable. The type of the expression Q.Id is the declared type of the class variable. If Q.Id appears in a context that requires a variable and not a value, then a compile-time error occurs.
  • Otherwise, Q.Id denotes the class variable. The type of the expression Q.Id is the declared type of the class variable.
• If Q is a type name that names an interface type (§9), then:
  • If there is not exactly one accessible (§6.6) member of the interface type that is a field named Id, then a compile-time error occurs.
  • Otherwise, Q.Id denotes the value of the field. The type of the expression Q.Id is the declared type of the field. If Q.Id appears in a context that requires a variable and not a value, then a compile-time error occurs.
• If Q is an expression name, let T be the type of the expression Q:
  • If T is not a reference type, a compile-time error occurs.
  • If there is not exactly one accessible (§6.6) member of the type T that is a field named Id, then a compile-time error occurs.
  • Otherwise, if this field is any of the following:
    • A field of an interface type
    • A final field of a class type (which may be either a class variable or an instance variable)
    • The final field length of an array type then Q.Id denotes the value of the field. The type of the expression Q.Id is the declared type of the field. If Q.Id appears in a context that requires a variable and not a value, then a compile-time error occurs.

  • Otherwise, Q.Id denotes a variable, the field Id of class T, which may be either a class variable or an instance variable. The type of the expression Q.Id is the declared type of the field

The example:

class Point {
	int x, y;
	static int nPoints;
}

class Test {
	public static void main(String[] args) {
		int i = 0;
		i.x++;								// compile-time error
		Point p = new Point();
		p.nPoints();								// compile-time error
	}
}

encounters two compile-time errors, because the int variable i has no members, and because nPoints is not a method of class Point.