所谓向前引用，即在定义某个变量前使用它
在c中向前引用一定是错误的，而在Java中，向前引用在某些时候是可行的
为什么java可以实现向前引用（这里只是讨论可行性的原理，实际上java对向前引用做了许多限制，所以这里许多看似无错的案例实际上是不被允许的））
为一个变量分配好空间，填入了默认值，之后无论是读取它还是赋值都是可行的
当在java程序中创建一个对象实例时：
1.先查看类有没有被加载，没有的话首先完成加载类
类的加载会做如下的事情：
加载class文件，给所有static属性分配空间，将这片存储空间清零，这等同于设置了默认值(0,null)
再按照源文件中书写顺序进行指定初始化
2.当类的加载完成后
给所有非static属性分配空间，设置默认值
按照书写顺序进行指定初始化
进行构造器初始化
创建过程结束
对于静态属性
static int b = a;
static Integer a = 1;
在执行这两条语句的赋值动作之前，a、b被加载进内存，拥有了空间和默认值
所以按理来说，b在a的定义语句之前使用它是没有问题的
对于非静态属性，它的加载在静态属性之后，所以不能用非静态属性去给静态属性赋值（即使甚至没有使用向前引用）：
int b = 1;
static int a = b;
而非静态属性的执行初始化就宽松多了，可以使用非静态的其他属性，也可以使用静态属性，因为这时所有属性都已经被加载了:
int a = b;
int b = 1;
或
int a = b;
static int b = 1;
按照原理，这两种都不会有什么问题
注：静态属性和静态代码块的地位是一样的，非静态属性和非静态代码块的地位是一样的
*java对向前引用的限制
在指定初始化时，若使用了别的属性值，如语句int a = b;
因为书写顺序的原因，存在两种可能
（1）b未完成自己的指定初始化，这时b的值为默认值
（2）b已经完成了自己的指定初始化，这时b的值为你设定的值
在定义语句前使用一个属性，往往并非程序员特意设计，而是因为疏漏
如上述的例子
int a = b;//a == 0
int b = 1;//b == 1;
乍一看这个代码的目的是让a和b的值都为1
但实际上，执行到a的指定初始化时，b的指定初始化尚未执行，所以此时的b仍为默认值（0）
为了避免类似的问题，java对向前引用做了一些限制
允许在定义一个字段前为它赋值，不允许在定义一个字段前读取它或者修改它
这里有一个小陷阱
{
a = 1;//right
int b = a;//error
}
int a;
即使对a提前完成了指定初始化，也不可以在定义它的语句之前使用它
不过有一些方法可以绕过上面的限制，在属性的定义语句之前进行不止赋值的操作
实际上，当同时满足下面4个条件，编译器就会判断当前的向前引用是非法的（也就是说打破任意一项就可以做到向前引用）：
1. 该属性若是静态的，出现在了静态属性的初始化语句或者静态的初始化块中
该属性若是非静态的，出现在了非静态的初始化语句或者非静态的初始化块中
2. 该属性不在赋值语句的左边
3. 直接使用变量名来访问属性
4.以上所有发生在直接包含该属性的类或者接口中
实例
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
//注：规则1目的在于：
// 限制静态属性初始化使用未定义的静态属性
// ，限制非静态属性初始化使用未定义的非静态属性
//但正如前面分析的，非静态属性可以任意使用静态属性,所以这里没问题
//另外，想要破坏规则1，还可以把赋值语句放进构造器或者函数里，满足了不在初始化语句或者不在初始化代码块的条件，如：
int b;
int a = -1;
UseBeforeDeclaration() {
b = a;//在构造器中初始化
}
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;
}public class Test {
int b = this.a;//不是通过变量名直接访问，通过方法访问也可以
// int b = getA();
int a = -1;
}* 以上所有讨论都是限于类的成员变量，并不适用在方法中的本地变量，本地变量无法做到向前引用
对于局部变量，既不能在定义它前使用它，也不能在定义它前给它赋值
本地变量并不会有默认值，当你使用一个未经指定初始化的本地变量，永远都会直接报错
为什么Java不像对待成员属性那样对待本地变量呢，给它赋一个默认值呢？
对于一个成员属性，它可能会在声明处完成指定初始化，也可能会在某个代码块或者函数内部完成，也可能在构造器里完成
所以在使用一个成员属性的时候，编译器很难确定它是否已经完成了指定初始化，这时候一个适当的默认值就很有必要了
对于生存期和作用域局限于方法块中的普通本地变量，它的初始化语句显然就在这个块里，这时候很容易判断出这个变量是否完成了初始化，不赋给默认值，而是强制程序员在完成初始化后再使用变量，可以避免很多错误
