Мне любопытно, почему эта простая программа может быть скомпилирована java с помощью IntelliJ (Java 7).
public class Main {
public static void main(String[] args)
{
int e = + + 10;
System.out.println(e);
}
}
Выходной файл все равно 10. В чем смысл + + 10?
Это унарный плюс, дважды. Это не префиксный прирост, потому что есть пробел. Java во многих случаях рассматривает пробелы.
Унарный плюс в основном ничего не делает, он просто продвигает операнд.
Например, это не компилируется, потому что унарный плюс заставляет byte повышаться до int:
byte b = 0;
b = +b; // doesn't compile
В этом случае Java рассматривает оператор + как унарный оператор и, следовательно, результат 10. Просто попробуйте со следующим кодом:
int e = + - 10; // result is -10
int e = - - 10; // result is 10
+ 'es - унарный плюс, указывающий знак справа от него, а не оператор добавления, используемый при добавлении двух значений.
Рассмотрим эту строку
int e = + + + + + + + + 10;
что эквивалентно этому
int e = +( +( +( +( +( +( +( +10)))))));
что снова эквивалентно этому
int e = +10;
и похож (по форме) на
int e = -10;
который, вероятно, более понятен.
И, кстати, + + не эквивалентен и не анализируется парсером как оператор приращения ++!
++ и + - оба оператора. Это элементы языка. Технически они могут упоминаться как токены. + + не является одним токеном в Java и разбивается на два отдельных токена во время секций синтаксического анализа компиляции.
+ может существовать в двух формах: (i) как унарный оператор; например +10 (который по существу является no-op, который только добавляет к путанице) или (ii) как двоичный оператор (что означает, что он действует на две вещи), чтобы добавить два слагаемых; например 10 + 10.
Так как они имеют внутреннее значение, вы можете также рассматривать 10 и +10 как оба выражения. Следует также отметить, что унарный + имеет очень высокий приоритет оператора, поэтому он будет тесно привязан к выражению сразу после него.
Итак, что происходит в вашем коде, компилятор привязывает + только слева от выражения 10, чтобы создать другое выражение со значением 10. Затем это связывает второй левый унарный + для создания, пока снова, 10.
В заключение: без пробела ++ - это один токен. С любым пространством между ними два + действуют как два унарных оператора.
Не смешивайте оператор preincrement ++, а унарный оператор + повторяется дважды.
int e = ++10; // won't compile "invalid argument to operation ++/--"
int e = + +10; //compile and e equals to 10
Это просто унарный плюс. Если вы скомпилируете int e = + + 10, вы получите следующий байт-код:
bipush 10
istore_1
что в точности эквивалентно int e = 10
Итак, все сказали, что это унарный плюс, который продвигает свой операнд к целочисленному значению. Я заметил несколько комментариев о том, как Java допускает бесполезные конструкции. Ну, так и на любом другом языке, включая формальную математику.
Это не специфичная для Java вещь. Для авторов компилятора невозможна попытка "предсказать" каждую бесполезную вещь, которую программист мог бы написать в грамматике, и попытаться ограничить ее добавлением семантических проверок в компиляторе. Плюс, "бесполезный" - субъективный термин. Один человек бесполезен, это еще один инструмент для изучения человека. Вы оставляете это до программиста. Если он хочет писать бесполезный код, пусть будет так. Пока он производит правильный код, мы должны быть удовлетворены.
Код похож на математику. Это может быть полезно или нет. Но это просто так, как и число 42. Оно не является ни полезным, ни бесполезным, в зависимости от контекста. Это всего лишь 42.
Нам не нужен какой-либо дополнительный семантический код в компиляторе Java, чтобы ограничить программистов. В языке уже достаточно рабства.
10 - буква, а не переменная. Таким образом, 10 не могут быть увеличены.
++somevariable increments somevariable.
++variable -> increment operator.
+ + someliteral will just equate to someliteral.
+ + literal -> successive unary + operator