关于“非法的前向引用（illegal forward reference）”的探究

1.问题：

有如下代码：

public class Test {
    static {
        i = 0;// 给变量赋值可以正常编译通过
        System.out.print(i);// 编译器会提示“非法向前引用”(illegal forward reference)
    }
    static int i = 1;
}

这段代码来自于《深入理解Java虚拟机：JVM高级特性与最佳实践（第三版）》的第7章。

书里没有对前向引用的进一步说明，我们自己探究一下。
把这段代码放到IDEA中，System.out.print(i)直接提示有错误。

编译一下看看

编译失败，输出的信息是
java：非法前向引用

2.什么是forward reference？

forward reference可以翻译成向前引用或者前向引用。百度百科没有收录该词条，在维基百科中有该词条，但是描述很简单。

既然是Java编译器报错，那就去查询Java官方资料，在JLS（Java语言规范）中找到了该词的说明：

References to a field are sometimes restricted, even through the field is in scope. The following rules constrain forward references to a field (where the use textually precedes the field declaration) as well as self-reference (where the field is used in its own initializer).
即使该字段在范围内，对字段的引用有时也会受到限制。以下规则限制对字段的前向引用（其中使用文本在字段声明之前）以及自引用（其中字段在其自己的初始值设定项中使用）。

这一句提到了两个概念，前向引用和自引用。在JLS中说前向引用就是在字段声明之前使用它，再回头看前言的例子中的代码

public class Test {
    static {
        i = 0;
        System.out.print(i);
    }
    static int i = 1;
}

i在未声明时就在static块中使用了，说明i = 0;属于前向引用。
如果注释掉System.out.print(i);这一行，程序可以正常编译通过。
将上面的代码稍微改造一下，打印i的值，看看是0还是1。

public class Test {

    static {
        i = 0;// 给变量赋值可以正常编译通过
    }
    static int i = 1;

    public static void main(String[] args) {
        System.out.println(i);// 输出1
    }
}

i的值是1，符合预期。
复习一下类初始化的步骤，静态变量（类变量）和静态代码块（static{}块）按照从上到下的顺序执行。static int i = 1;在i = 0;后面，所以i的值是1。
再来看看Test这个类的字节码情况，使用jclasslib插件查看很方便。

Test类初始化方法<clinit>的字节码

iconst_0 // 把常量0压入操作数栈
putstatic #3 <com/shion/init_code/Test.i : I> // 把栈顶的值0赋值给类变量i i->0
iconst_1 // 把常量1压入操作数栈
putstatic #3 <com/shion/init_code/Test.i : I> // 把栈顶的值1赋值给类变量i i->1
return // 返回void

从字节码看到，类变量i确实被赋值了两次，第一次是0，第二次是1。难道类变量没声明也可以赋值吗？当然不是，答案已经呼之欲出了，我们来看看Test这个类的class文件，用IDEA查看反编译后的代码。

好家伙，原来是Java编译器的功劳。
补充：
Java允许前向引用，从JLS的说明上看，不管是类变量还是实例变量皆可，Java编译器编译时会自动处理。

3.什么情况属于非法的前向引用？

既然知道了前向引用的概念，那什么情况属于非法的前向引用呢？
还是看JLS的说明：

解释下什么是简单名称，就是一个单词或一个字母这种形式的名称，和它相对的就是限定名称（以.分隔的单词序列，例如java.lang.Object或者System.out）。
JLS给出了一个详细的例子来说明哪些情况属于非法的前向引用：

点击查看代码

class UseBeforeDeclaration {
    static {
        x = 100;
          // ok - assignment
        int y = x + 1;
          // error - read before declaration
        int v = x = 3;
          // ok - x at left hand side of assignment
        int z = UseBeforeDeclaration.x * 2;
          // ok - not accessed via simple name

        Object o = new Object() { 
            void foo() { x++; }
              // ok - occurs in a different class
            { x++; }
              // ok - occurs in a different class
        };
    }

    {
        j = 200;
          // ok - assignment
        j = j + 1;
          // error - right hand side reads before declaration
        int k = j = j + 1;
          // error - illegal forward reference to j
        int n = j = 300;
          // ok - j at left hand side of assignment
        int h = j++;
          // error - read before declaration
        int l = this.j * 3;
          // ok - not accessed via simple name

        Object o = new Object() { 
            void foo(){ j++; }
              // ok - occurs in a different class
            { j = j + 1; }
              // ok - occurs in a different class
        };
    }

    int w = x = 3;
      // ok - x at left hand side of assignment
    int p = x;
      // ok - instance initializers may access static fields

    static int u =
        (new Object() { int bar() { return x; } }).bar();
	    // ok - occurs in a different class

    static int x;

    int m = j = 4;
      // ok - j at left hand side of assignment
    int o =
        (new Object() { int bar() { return j; } }).bar(); 
        // ok - occurs in a different class
    int j;
}

通过查询其他资料，大家总结了一句话：

通过简单名称引用的变量可以出现在左值位置，但不能出现在右值的位置

根据这条规则，再看上面的例子，int y = x + 1;这行代码中，x出现在了右值的位置。
再回头看问题里面的例子，System.out.print(i);这行代码，符合JLS里提到的

The reference appears either in a class variable initializer of C or in a static initializer of C (§8.7);
该引用出现在 C 的类变量初始值设定项(static字段)中或 C 的静态初始值设定项(static代码块)中（第 8.7 节）；

4.前向引用的好处？

前向引用在语法上很容易造成误解，特别是刚接触Java编程的新人，那为什么Java还要允许它的存在呢？
以下说明来自：
前向引用 - 为什么这段代码会编译？

前向引用是一种编译技术，允许在当前编译单元中引用其他编译单元中的类型。这种技术可以提高编译速度，并允许在不同的编译单元之间进行更灵活的组织和模块化。
前向引用的优势：

1. 提高编译速度：通过将类型声明和定义分离，可以减少编译器需要处理的代码量，从而提高编译速度。
2. 更灵活的组织：前向引用允许在不同的编译单元之间进行更灵活的组织和模块化，这有助于提高代码的可维护性和可读性。
3. 更好的性能：前向引用可以减少不必要的内存分配和释放，从而提高程序的性能。
   应用场景：
4. 大型项目：在大型项目中，前向引用可以帮助开发人员更好地组织代码，提高代码的可读性和可维护性。
5. 模块化开发：在模块化开发中，前向引用可以帮助开发人员将不同的模块分离，从而提高代码的可读性和可维护性。
6. 多编译单元项目：在多编译单元项目中，前向引用可以帮助开发人员更好地组织代码，提高代码的可读性和可维护性。

5.总结

前向引用是Java语言层面允许的，Java编译器进行编译时会检查非法的前向引用，其目的是避免循环初始化和其他非正常的初始化行为。

最后再简单提一下什么是循环引用，看一下下面这个例子：

private int i = j;
private int j = i;

如果没有前面说的强制检查，那么这两句代码就会通过编译，但是很容易就能看得出来，i和j并没有被真正赋值，因为两个变量都是未初始化的（Java规定所有变量在使用之前必须被初始化），而这个就是最简单的循环引用的例子。

理解前向引用等概念，可能对提高写CRUD代码的水平没有什么帮助，但是能帮助我们更好的理解这门编程语言。

参考链接：
https://stackoverflow.com/questions/14624919/illegal-forward-reference-java-issue
https://www.imooc.com/wenda/detail/557184
https://cloud.tencent.com/developer/information/前向引用 - 为什么这段代码会编译？
https://docs.oracle.com/javase/specs/jls/se14/html/jls-8.html#jls-8.3.3