Почему смешивание + и cast не приводит к ошибке в "+(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);
    }
}

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

4 53
javascript

4 ответа:

вы не добавляете и не вычитаете. Эти операторы + и - являются унарными знаковыми операторами.

посмотреть документация at Унарные Операторы.

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

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

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

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

80

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

более конкретно, это на самом деле:

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

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

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
12

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

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

+ 1

то, что вы написали-это унарное числовое выражение, который распадается на две части:

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

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

(int) 1

поэтому вы можете заменить это на оригинал 1 выше:

+ (int) 1

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

почему?

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

7