Java转发引用在不同情况下的行为是否有所不同？

Question

Please take a look at this snippet:

public class A {
    void method() {
        System.out.print(B.j);//This is legal!
        class C {
            void method () {
                System.out.print(j);//This is illegal!
            }
        }
        final int j = 10;
        class D {
            void method() {
                System.out.print(j);//This is legal!
            }
        }
    }
}
class B {
    static int j = 10;
}

We can access the 'Bj' in a place before it's definition whilst this is illegal in the case of accessing 'final int j' in class C.

Does java compiler looks at local classes as simple variables/objects? Specially, what's the rationale behind this behavior? I mean forward checking is working for the Bj but it doesn't work for the 'j' inside the class C.

Answer 1

I believe this is simple scoping. If you replace your inner classes with simple System.out.println() calls,

public class A {
  void method() {
    System.out.print(j);//This is illegal!
    final int j = 10;
    System.out.print(j);//This is legal!
  }
}

you'll find you get the same message. The scope of local variables starts where they are declared and continues through the end of the block they're declared in.

To answer your question about the reference to B: Consider

public class A {
  void method() {
    System.out.print(k);//This is legal!
  }
  int k=17;
}

Java is not a single-pass compilation. Classes, and their exposed fields and methods, can be forward referenced. A deliberate decision was made that local variables can not be forward referenced. I'm guessing that this was to let programmers establish restricted scopes without having to use additional levels of {} block statements -- if I introduce a new variable, especially with an initialization, I don't want anyone tampering with it before that.

That's how Java local variables happen to work. This may not be a satisfying answer, but it's the best one we've got.

Answer 2

Setting the possibility that your code does not compile aside...

When class A is loaded by the classloader into memory, so is class B, because they're in the same file. So Bj is already allocated on the heap when method is called at runtime.

On the other hand, when you declare variables in a method, those variables are stored on the stack when the method is invoked, in the order that you write them, so here order matters.