关于“非法的前向引用（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还要允许它的存在呢？
以下说明来自：
前向引用 - 为什么这段代码会编译？
前向引用是一种编译技术，允许在当前编译单元中引用其他编译单元中的类型。这种技术可以提高编译速度，并允许在不同的编译单元之间进行更灵活的组织和模块化。
前向引用的优势：
- 提高编译速度：通过将类型声明和定义分离，可以减少编译器需要处理的代码量，从而提高编译速度。
- 更灵活的组织：前向引用允许在不同的编译单元之间进行更灵活的组织和模块化，这有助于提高代码的可维护性和可读性。
- 更好的性能：前向引用可以减少不必要的内存分配和释放，从而提高程序的性能。
应用场景：- 大型项目：在大型项目中，前向引用可以帮助开发人员更好地组织代码，提高代码的可读性和可维护性。
- 模块化开发：在模块化开发中，前向引用可以帮助开发人员将不同的模块分离，从而提高代码的可读性和可维护性。
- 多编译单元项目：在多编译单元项目中，前向引用可以帮助开发人员更好地组织代码，提高代码的可读性和可维护性。
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