Почему при 127 * 2 результат равен -2, когда мы переходим к байту?

Это мой код:

public class test {

  public static void main(String[] args) {
    byte a=(byte)127, b=2;    
    byte c=(byte)(a*b);

    System.out.println(c);
  }    
}

Почему результат -2?

Ответ 1

Потому что a*b приведет к временной переменной int, а именно 254, которая равна 1111 1110. При передаче в байты это будет обрабатываться как знаковое значение. MSB равен 1, поэтому его значение будет отрицательным, а значение будет - (((inv) 111 1110) + 1) = - ((000 0001) + 1) = -2.

Ответ 2

a * b - 254, поэтому ваш код:

byte c=(byte)254;

Десятичное число 254 является двоичным 11111110, которое равно: -2. Почему?

Прежде всего, число отрицательно, так как оно начинается с 1 (два дополнения), а затем:

¬ 1 1 1 1 1 1 1 0 - 0 0 0 0 0 0 0 1.

0 0 0 0 0 0 0 1
              1 +
---------------
0 0 0 0 0 0 1 0

Это представляет 2 в десятичной системе, но помните, что MSB равен 1? Таким образом, конечный результат -2.

Ответ 3

Поскольку байт является подписанным типом 2 * 127, это двоичный код "11111110", который два дополнения для -2.

Ответ 4

потому что байт подписан, а не без знака.

254 = FE = 1111 1110

первый '1' представляет число как отрицательное число.

Ответ 5

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

01111111

Умножьте на 2, и вы получите следующее:

11111110

(Когда вы умножаете на 10 в базе 10, все цифры могут быть сдвинуты влево, в следующую позицию. То же самое естественно, когда вы умножаете на 2 в двоичном формате)

Java использует 2 дополнения для представления отрицательных чисел. В основном, самый левый бит - бит знака (0 для +, 1 для -). Чтобы преобразовать положительное число в отрицательное число, переверните все биты и добавьте один.

Пример: 00000010= 2, переверните биты: 11111101, затем добавьте один: 11111110= -2. Это то же самое, что и 127 * 2 выше.

Ответ 6

Я думаю, что вы пытались спросить, почему переполнение целого числа со знаком 8 бит будет обращено к отрицательному числу для вашего случая.
Как и в CPU, нет АБВ с 8 бит, поэтому 8 бит будет расширяться до 32 бит, после операции вернет нижние 8 бит для пользователя.
В CPU: 0000_007F * 0000_0002 = 0000_00FE
Это переполнение для подписанных 8 бит, но значение уже рассчитано.
Таким образом, возвращаемое значение равно FE.
Для подписанных 8 бит, FE - -2.