Почему этот код 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 говорится, что «указанные выше ограничения предназначены для перехвата во время компиляции циклических или иным образом искаженных инициализаций».

К чему на самом деле сводятся эти правила?

Короче говоря, правила в основном говорят, что вы должны объявить поле перед ссылкой на это поле, если (а) ссылка находится в инициализаторе, (б) ссылка не назначается, (в) ссылка является простое имя (без таких квалификаторов this.) и (d) к нему нет доступа из внутреннего класса. Таким образом, прямая ссылка, удовлетворяющая всем четырем условиям, является недопустимой, но прямая ссылка, которая не работает хотя бы по одному условию, является допустимой.

int a = a = 1;компилируется , потому что он нарушает (б): ссылка a будет быть назначена, так что это законно , чтобы обратиться к aзаранее a«s полной декларации.

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 проверяет циклы и ветки, чтобы гарантировать, что присвоение всегда происходит до любого использования (вот почему определенному назначению посвящен целый раздел спецификации к нему). Основное правило:

• Для каждого доступа к локальной переменной или пустой конечного поля x, xдолжны быть определенно присвоенной перед въездом, или происходит ошибка времени компиляции.

В int d = d + 1;, доступ к dразрешен для локальной переменной штраф, но, поскольку dне был назначен до dобращения, компилятор выдает ошибку. В int c = c = 1, c = 1происходит во- первых, который назначает c, а затем cинициализируется в результате этого присваивания (который является 1).

Обратите внимание, что из-за определенных правил присваивания объявление локальной переменной int d = (d = 1) + d; будет успешно скомпилировано (в отличие от объявления поля 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уже была объявлена. Это также выражение со значением 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;добавлении 1 к й, так что значениеx , это еще не создано.

Но in int x=x=1;будет компилироваться без ошибок, потому что вы присваиваете 1 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, таким образом, эта строка компилирует ошибки, поскольку правая часть равных не будет компилировать добавление единицы к неназначенной переменной

Второй 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

Комплиер читал утверждения справа налево, а мы сделали обратное. Поэтому сначала это раздражало. Сделайте это привычкой читать операторы (код) справа налево, у вас не будет такой проблемы.