SCJP: нельзя расширять, а затем боксировать, но можно боксировать, а затем расширять

язык сбивает с толку.

По сути, вы не можете использовать этот способ:
byte -> Byte -> Long,
потому что Byte и Long не имеют отношения is-a.
Итак, он пытается сделать это:
byte -> long -> Long
Но и этого он сделать не может (видимо, из-за ограничений компилятора). Итак, он терпит неудачу и выдает ошибку.

Но, с другой стороны, вы МОЖЕТЕ сделать это:
byte -> Byte -> Object
потому что байт — это объект.

рассмотрим 2 функции и байтовую переменную:

toLong(Long x)
toObject(Object x)
byte b = 5;

Тогда это утверждение будет недопустимым:
toLong(b);
// потому что b -> new Byte(b) -> new Long(new Byte(b)) недопустимо.
AND byte -> long -> Long нельзя сделать из-за ограничений компилятора.

но это утверждение допустимо:
toObject(b);
// потому что b -> новый байт(b) -> новый объект(новый байт(b)) является допустимым.

Причина, по которой «расширение, а затем бокс» не разрешено, может быть связана со следующей причиной (стр. 249 книги SCJP):

Разработчики Java 5 решили, что наиболее важным правилом должно быть то, что ранее существовавший код должен функционировать так, как раньше, поэтому, поскольку возможность расширения уже существует, метод, который вызывается через расширение, не должен проигрывать вновь созданному методу, основанному на упаковке.

В основном это означает, что расширение работает только с примитивными типами, а не с оболочками. Если вы сначала боксируете, вы получаете обертку (byte -> Byte). А вот обертки - Byte, Double, Float, Integer, Long и Short не имеют отношения наследования (IS-A). Например, параметр Long не может принимать Byte.

Таким образом, вы должны сначала расширить (byte -> long), а затем боксировать (long -> Long).

Это не расширение, потому что Byte не помещается в Long. Вот почему это не работает.

Вы можете упаковать в байт, а затем расширить в Object или Number.

Как говорится в вашей книге:

мы вернулись к попыткам расширить байт до длинного

В вашем случае, я полагаю, код выглядит так:

byte b = 1;
Long l = b;

b изменяется на Byte (сначала бокс), но не может быть изменен на Long, потому что Byte не является подклассом Long.

В дополнительных шагах:

byte b = 1;
Byte byteB = b; //works
Long l = byteB; //doesn't work

По сути, правила состоят в том, что вы можете боксировать, а затем расширять, но не расширять, а затем боксировать. Однако, если бокс затем расширяется, расширяемый класс должен находиться в том же дереве наследования, что и класс, до которого вы расширяетесь.

Хотя показанный пример пытается упаковать, а затем расширить, причина, по которой он недействителен, заключается в том, что байт не является длинным, т. е. они не находятся в одном и том же дереве наследования. Однако, если в примере использовались байты и числа, то вам было бы правильно преобразовать байты в байты, а затем расширить байты в числа, поскольку байты являются числовыми (они НАХОДЯТСЯ в одном дереве наследования)