public class TestStatic{
static {a=2;}
static int a=1;
static int b=3;
static {b=4;}
public static void main(String[] args){
System.out.println(a);
System.out.println(b);}
}
}
the output is
1
4
I wonder why the a=2 doesn't throw an error, for a is not declared yet.
I understand the initialization order and static block "static {a=2;}" initializes before static variable "static int a=1;", just can't figure out the "a=2" part.
A local variable can't be used earlier (lexicographically) than its declaration.
That's specified in JLS section 6.3
The scope of a local variable declared in a block by a local variable declaration statement (§14.4.2) is the rest of the block, starting with the declaration's own initializer and including any further declarators to the right in the local variable declaration statement.
But that doesn't apply to fields, whether they're static or instance fields. Fields are members, and as it also says in section 6.3:
The scope of a declaration of a member
mdeclared in or inherited by a class or interface C (§8.2, §9.2) is the entire body ofC, including any nested class or interface declarations. IfCis a record class, then the scope of m additionally includes the header of the record declaration ofC.
You can see what the scope of any declaration is, by reading section 6.3 of the Java Language Specification.
In particular,
The scope of a declaration of a member m declared in or inherited by a class or interface
Cis the entire body ofC, including any nested class or interface declarations.
So the scope of a is the entire body of testStatic. The static initialiser is in the body of testStatic, so a is in scope in the body of the static initialiser.
No additional restrictions regarding whether a is accessible, or whether you can set it applies here, so a = 2; compiles.
In a sense, this works for the same reason that calling a method before it is declared works:
void f() {
g(); // can call g here!
}
void g() {}
Note that this is different in the case of referring to other static fields in the field initialiser of a static field. i.e. this does not compile:
class Foo {
static int b = a; // changing this to Foo.a works
static int a = 0;
}
Even though a is in scope in the field initialiser of b, this is now allowed in the specification, section 8.3.3:
For a reference by simple name to a class variable f declared in class or interface C, it is a compile-time error if:
The reference appears either in a class variable initializer of C or in a static initializer of C (§8.7); and
The reference appears either in the initializer of f's own declarator or at a point to the left of f's declarator; and
The reference is not on the left hand side of an assignment expression (§15.26); and
The innermost class or interface enclosing the reference is C.
Also note that the scope of local variables does not include the code before it is declared:
The scope of a local variable declared in a block by a local variable declaration statement (§14.4.2) is the rest of the block, starting with the declaration's own initializer and including any further declarators to the right in the local variable declaration statement.
Note the wording of "the rest of the block".
When in a static block, if a variable has not been declared or initialized, it's gonna be initialized to the default value of it's data type.
Here you are initializing an int ( a = 2 ), therefore it's first being initialized as an int with the value 0, and then the value 2 is stored inside.
As for why that works that way, well that's just how the language works
The code you provided does not throw any errors because it correctly initializes the static variable x before it is used in the static block.
technically possible to initialize a variable in a static block before it is declared, it can make the code harder to understand and maintain. It's generally recommended to declare and initialize variables in the order they will be used, and to avoid using static blocks unless they are absolutely necessary.
