Почему смешение + и приведение не приводит к ошибке в "+ (int) + (long) -1"?

Почему эта печать 1?

import java.util.*;
import java.lang.*;
import java.io.*;


class Main
{
    public static void main (String[] args) throws java.lang.Exception
    {
        // your code goes here
        System.out.println((byte)+(short)-(int)+(long)-1);
    }
}

Можно ли смешивать кастинг и +,- унарные операторы? Я знаю, что мы можем делать кастинг несколько раз, но почему не помещает + ,- унарные операторы между ошибками?

Ответы

Ответ 1

Вы не добавляете и не вычитаете. Те + и - операторы - это унарные знаковые операторы.

Смотрите документация в разделе Унарные операторы.

Последовательность на кону:

(byte)+(short)-(int)+(long)-1

оценивается справа налево следующим образом:

начальное значение равно -1 кастинг длинным (который все еще -1)
знак унарного + (все еще -1)
литье в int (все еще -1)
унарный знак (теперь значение равно 1)
и так далее (значение остается 1 до конца)

Ответ 2

Эти + и - являются унарными.

В частности, это фактически:

System.out.println((byte) (+((short) (-((int) (+((long) -1)))))));

Ответ 3

если вы удалите все кастинг из своего примера, потому что в этом случае он ничего не сделает

System.out.println((byte)+(short)-(int)+(long)-1);

станет

System.out.println( + - + -1);

теперь вы можете видеть, что только операторы все еще существуют, и поскольку минус и минус плюс, ваш результат будет 1

в принципе вы можете думать об этом как:

var mylong  = +(long)-1;      <- -1
var myint   = -(int)mylong;   <-  1
var myshort = +(short)myint;  <-  1
var mybyte  =  (byte)myshort; <-  1

Ответ 4

Я знаю, что мы можем делать кастинг несколько раз. Но положив +, - унарные операторы между ними не дают ошибку?

Это просто следствие последовательности Java-грамматики. Когда вы пишете

+ 1

то, что вы на самом деле написали, является унарным числовым выражением, которое разлагается на две части:

  • оператор унарного плюса: +
  • числовое выражение, в данном случае int литерал 1.

Другим примером числового выражения является выражение cast (также унарное):

(int) 1

Поэтому вы можете заменить это для исходного 1 выше:

+ (int) 1

Повторяя такой же согласованный процесс, мы можем получить вложенное унарное выражение произвольной сложности. Чтобы вернуться к вашему ключевому вопросу:

почему?

Потому что Java действительно нуждается в определенном правиле против таких выражений.