Позвольте мне сказать это очень четко, потому что люди все время неправильно понимают это:
Порядок оценки подвыражений не зависит ни от ассоциативности, ни от приоритета . Ассоциативность и приоритет определяют, в каком порядке выполняются операторы , но не определяют, в каком порядке оцениваются подвыражения . Ваш вопрос касается порядка, в котором оцениваются подвыражения .
Посмотрим A() + B() + C() * D(). Умножение имеет более высокий приоритет, чем сложение, а сложение является левоассоциативным, поэтому это эквивалентно (A() + B()) + (C() * D()) Но, зная, что это только говорит вам, что первое сложение произойдет до второго сложения, и что умножение произойдет до второго сложения. Он не сообщает вам, в каком порядке будут вызываться A (), B (), C () и D ()! (Он также не сообщает вам, происходит ли умножение до или после первого сложения.) Было бы вполне возможно соблюдать правила приоритета и ассоциативности , скомпилировав это как:
d = D()
b = B()
c = C()
a = A()
sum = a + b
product = c * d
result = sum + product
Здесь соблюдаются все правила старшинства и ассоциативности - первое сложение происходит перед вторым сложением, а умножение происходит перед вторым сложением. Очевидно, что мы можем выполнять вызовы A (), B (), C () и D () в любом порядке и при этом соблюдать правила приоритета и ассоциативности!
Нам нужно правило, не связанное с правилами приоритета и ассоциативности, чтобы объяснить порядок, в котором оцениваются подвыражения. Соответствующее правило в Java (и C #) гласит: «Подвыражения оцениваются слева направо». Поскольку A () появляется слева от C (), A () вычисляется первым, независимо от того, что C () участвует в умножении, а A () участвует только в сложении.
Итак, теперь у вас есть достаточно информации, чтобы ответить на ваш вопрос. В a[b] = b = 0правилах ассоциативности сказано, что это есть, a[b] = (b = 0);но это не значит, что b=0запускается первым! Правила приоритета говорят, что индексирование имеет более высокий приоритет, чем присвоение, но это не означает, что индексатор запускается перед крайним правым назначением .
(ОБНОВЛЕНИЕ: в более ранней версии этого ответа были некоторые небольшие и практически несущественные упущения в следующем разделе, который я исправил. Я также написал статью в блоге, описывающую, почему эти правила разумны в Java и C # здесь: https: // ericlippert.com/2019/01/18/indexer-error-cases/ )
Старшинство и ассоциативность только говорят нам , что присвоение нуля , чтобы bдолжно произойти , прежде чем присваивание a[b], поскольку присваивание нуля вычисляет значение, которое присваивается в операции индексирования. Старшинство и ассоциативность в одиночку ничего не говорят о ли a[b]оценивается до того или послеb=0 того, как .
Опять же, это то же самое, что: A()[B()] = C()- Все, что мы знаем, это то, что индексация должна происходить до присвоения. Мы не знаем, запускается ли A (), B () или C () первым, исходя из приоритета и ассоциативности . Нам нужно другое правило, чтобы сказать нам это.
Правило опять же: «когда у вас есть выбор, что делать в первую очередь, всегда идите слева направо». Однако в этом конкретном сценарии есть интересная загвоздка. Считается ли побочный эффект выброшенного исключения, вызванного пустой коллекцией или индексом вне допустимого диапазона, частью вычисления левой части присвоения или частью вычисления самого присвоения? Java выбирает последнее. (Конечно, это различие имеет значение только в том случае, если код уже неверен , потому что правильный код в первую очередь не разыменовывает null и не передает плохой индекс.)
Так что же происходит?
- Символ
a[b]находится слева от b=0, поэтому сначалаa[b] выполняется , в результате чего . Однако проверка правильности этой операции индексации откладывается.a[1]
- Тогда
b=0случается.
- Затем происходит проверка, которая
aдействительна и a[1]находится в диапазоне.
- Присваивание значения
a[1]происходит в последнюю очередь.
Итак, хотя в этом конкретном случае есть некоторые тонкости, которые следует учитывать для тех редких случаев ошибок, которые в первую очередь не должны возникать в правильном коде, в целом вы можете рассуждать: что-то слева происходит раньше, чем что-то справа . Это то правило, которое вы ищете. Разговоры о приоритете и ассоциативности сбивают с толку и неуместны.
Люди все время ошибаются , даже те, кому следует знать лучше. Я редактировал слишком много книг по программированию, в которых правила указаны неверно, поэтому неудивительно, что многие люди имеют совершенно неверные представления о взаимосвязи между приоритетом / ассоциативностью и порядком оценки, а именно, что на самом деле такой взаимосвязи нет. ; они независимы.
Если эта тема вас интересует, смотрите мои статьи по этой теме для дальнейшего чтения:
http://blogs.msdn.com/b/ericlippert/archive/tags/precedence/
Они посвящены C #, но большая часть из них одинаково хорошо применима и к Java.