为什么要编译此Java代码？

在方法或类范围内，下面的行进行编译（带有警告）：

int x = x = 1;

在类范围中，变量获取其默认值，以下给出“未定义引用”错误：

int x = x + 1;

它不是第一个x = x = 1应该以相同的“未定义参考”错误结束吗？还是第二行int x = x + 1应该编译？还是我缺少什么？

tl; dr

对于字段，int b = b + 1是非法的，因为它b是对的非法前向引用b。您实际上可以通过编写来解决此问题int b = this.b + 1，该文件可以毫无抱怨地进行编译。

对于局部变量，int d = d + 1是非法的，因为d未在使用前进行初始化。这是不是对领域，其中总是默认初始化的情况。

您可以尝试编译来查看差异

int x = (x = 1) + x;

作为字段声明和局部变量声明。由于语义上的差异，前者将失败，而后者将成功。

介绍

首先，字段和局部变量初始化程序的规则非常不同。因此，此答案将分两部分解决规则。

我们将在整个过程中使用此测试程序：

public class test {
    int a = a = 1;
    int b = b + 1;
    public static void Main(String[] args) {
        int c = c = 1;
        int d = d + 1;
    }
}

的声明b无效，失败并显示illegal forward reference错误。
的声明d无效，失败并显示variable d might not have been initialized错误。

这些错误不同的事实应表明错误的原因也不同。

领域

Java中的字段初始化程序由JLS§8.3.2（字段的初始化）控制。

字段的范围在JLS§6.3声明的范围中定义。

相关规则是：

• m在类类型C（第8.1.6节）中声明或继承的成员的声明范围是C的整个主体，包括任何嵌套的类型声明。
• 实例变量的初始化表达式可以使用在类中声明或由类继承的任何静态变量的简单名称，即使是声明在文本后出现的静态变量也是如此。
• 有时会限制使用声明之后在文本中出现的实例变量，即使这些实例变量在范围内。有关控制对实例变量的前向引用的精确规则，请参见第8.3.2.3节。

§8.3.2.3说：

仅当成员的声明是类或接口C的实例（分别为静态）字段且满足以下所有条件时，才需要在成员声明之前以文本形式出现：

• 使用情况发生在C的实例（分别为静态）变量初始化程序或C的实例（分别为静态）变量初始化程序中。
• 用法不在作业的左侧。
• 用法是通过一个简单的名称。
• C是包含用法的最里面的类或接口。

实际上，在某些情况下，您可以在声明字段之前先对其进行引用。这些限制旨在防止类似

int j = i;
int i = j;

从编译。Java规范说：“以上限制旨在在编译时捕获循环或其他形式的初始化。”

这些规则实际上可以归结为什么？

简而言之，规则基本上说，如果（a）引用位于初始化程序中，（b）引用未分配给该字段，（c）引用是a ，则必须在对该字段的引用之前声明一个字段简单名称（没有限定词this.）和（d）不能从内部类中访问它。因此，满足所有四个条件的前向引用是非法的，但是至少在一个条件下失败的前向引用是可以的。

int a = a = 1;编译是因为它违反了（b）：引用a 已分配给它，因此a在a的完整声明之前进行引用是合法的。

int b = this.b + 1还会编译，因为它违反了（c）：引用this.b不是简单的名称（已使用限定this.）。这个奇数构造仍然是完美定义的，因为this.b它的值为零。

因此，基本上，初始化器中对字段引用的限制会阻止int a = a + 1成功进行编译。

观察到字段声明int b = (b = 1) + b将无法编译，因为最终声明b仍然是非法的前向引用。

局部变量

局部变量声明受JLS§14.4局部变量声明语句约束。

局部变量的范围在JLS§6.3声明的范围中定义：

• 块中的局部变量声明的范围（第14.4节）是该声明在其中出现的其余部分，从其自身的初始化程序开始，并在局部变量声明语句的右侧包括其他任何声明符。

请注意，初始化器在要声明的变量的范围内。那为什么不int d = d + 1;编译呢？

原因是由于Java的定值分配规则（JLS§16）。明确赋值基本上是说，对局部变量的每次访问都必须对该变量进行事先赋值，并且Java编译器会检查循环和分支，以确保赋值始终在任何使用之前发生（这就是为什么明确赋值有专门的整个规范部分的原因对此）。基本规则是：

• 对于每次访问局部变量或空白的final字段x，x必须在访问之前明确分配，否则会发生编译时错误。

在中int d = d + 1;，对的访问d被解析为局部变量fi​​ne，但是由于d之前未分配访问权限d，因此编译器会发出错误。在中int c = c = 1，c = 1首先发生，它分配c，然后c初始化为该分配的结果（为1）。

请注意，由于有明确的赋值规则，局部变量声明int d = (d = 1) + d; 将成功编译（与 field声明不同int b = (b = 1) + b），因为d在d到达最终变量时已明确赋值。

int x = x = 1;

相当于

int x = 1;
x = x; //warning here

而在

int x = x + 1; 

首先我们需要计算，x+1但是x的值未知，所以会出现错误（编译器知道x的值未知）

大致相当于：

int x;
x = 1;
x = 1;

首先，int <var> = <expression>;总是等于

int <var>;
<var> = <expression>;

在这种情况下，您的表达式是x = 1，这也是一条语句。x = 1是有效的语句，因为x已经声明了var 。它也是一个值为1的表达式，然后x再次分配给它。

在Java或任何现代语言中，分配均来自正确的位置。

假设您有两个变量x和y，

int z = x = y = 5;

该语句是有效的，这是编译器将它们拆分的方式。

y = 5;
x = y;
z = x; // which will be 5

但是你的情况

int x = x + 1;

编译器给出了一个异常，因为它像这样分裂。

x = 1; // oops, it isn't declared because assignment comes from the right.

int x = x = 1; 不等于：

int x;
x = 1;
x = x;

javap再次帮助了我们，这些是为此代码生成的JVM指令：

0: iconst_1    //load constant to stack
1: dup         //duplicate it
2: istore_1    //set x to constant
3: istore_1    //set x to constant

更像：

int x = 1;
x = 1;

这里没有理由抛出未定义的参考错误。现在，在初始化变量之前就可以使用它，因此此代码完全符合规范。实际上，根本没有使用变量，只是分配。而且JIT编译器将走得更远，它将消除这种构造。说实话，我不明白这段代码是如何与JLS的变量初始化和用法规范联系在一起的。没有用法没有问题。;）

如果我错了，请更正。我无法弄清楚为什么涉及许多JLS段落的其他答案会收集这么多优点。这些段落与这种情况没有共同之处。仅执行两个序列分配，就没有更多。

如果我们写：

int b, c, d, e, f;
int a = b = c = d = e = f = 5;

等于：

f = 5
e = 5
d = 5
c = 5
b = 5
a = 5

最右边的表达式只是一个一个地分配给变量，没有任何递归。我们可以用任何我们喜欢的方式弄乱变量：

a = b = c = f = e = d = a = a = a = a = a = e = f = 5;

在int x = x + 1;x中加1，所以的值是多少x，尚未创建。

但是in int x=x=1;会编译没有错误，因为您将1分配给x。

您的第一段代码包含第二个=而不是加号。这将在任何地方编译，而第二段代码将不在任何地方编译。

在第二段代码中，x在声明之前使用，而在第一段代码中，x仅被分配了两次，这没有意义，但有效。

让我们一步一步地分解它，正确关联

int x = x = 1

x = 1，将1分配给变量x

int x = x，将x本身的值指定为int。由于x以前曾被分配为1，所以它保留了1，尽管这是多余的。

这样编译就可以了。

int x = x + 1

x + 1，将一个加到变量x中。但是，x未定义将导致编译错误。

int x = x + 1，因此这行会编译错误，因为等号的右侧部分不会编译将未分配的变量加1

第二个int x=x=1是编译的，因为您正在将值分配给x，但在其他情况下，int x=x+1这里的变量x没有初始化，请记住，在Java局部变量中，没有将其初始化为默认值。注意如果它int x=x+1也在类范围内（），则由于未创建该变量，也会产生编译错误。

int x = x + 1;

在Visual Studio 2008中成功编译并出现警告

warning C4700: uninitialized local variable 'x' used`

x未在x = x + 1;中初始化。

Java编程语言是静态类型的，这意味着必须先声明所有变量，然后才能使用它们。

查看原始数据类型

由于代码实际上是如何工作的，因此该行代码不会带有警告编译。在运行代码时int x = x = 1，Java首先创建x定义的变量。然后，它运行分配代码（x = 1）。由于x已经定义，因此系统不会将错误设置x为1。这将返回值1，因为现在是的值x。因此，x现在最终设置为
1。Java基本上像这样执行代码：

int x;
x = (x = 1); // (x = 1) returns 1 so there is no error

但是，在第二段代码中，需要定义int x = x + 1该+ 1语句x，而那时尚未定义。由于赋值语句始终意味着=首先运行右侧的代码，因此该代码将因为x未定义而失败。Java将运行以下代码：

int x;
x = x + 1; // this line causes the error because `x` is undefined

编译器从右到左读取语句，我们设计相反。这就是为什么它一开始很烦。习惯于从右到左读取语句（代码），这样就不会出现问题。