Java - why does char get implicitly cast to byte (and short) primitive, when it shouldn't?

Question

Certain functionality of the compiler puzzles me (Oracle JDK 1.7 using Eclipse).

So I've got this book that says char primitive needs to be explicitly cast to short and byte and this all makes sense due the data types' allowed ranges don't overlap.

In other words below code works (but wouldn't work without the explicit type casts):

char c = '&';  
byte b = (byte)c;
short s = (short)c;

Printing b or s correctly displays the number 38, which is the numeric equivalent of (&) in Unicode.

Which brings me to my actual question. Why does the following work as well?

byte bc = '&';
short sc = '&';
System.out.println(bc); // Correctly displays number 38 on the console
System.out.println(sc); // Correctly displays number 38 on the console

Now I would certainly understand the following (which works too):

byte bt = (byte)'&';
System.out.println(bt); // Correctly displays number 38 on the console

But this no-compiler-warning char to byte (and short) "sneak conversion" doesn't seem right to me.

Can some one explain, why this is allowed?

Could the reason be in the interpretation of the '<char>' itself, so that it doesn't actually ever get to a char primitive state but is handled as a numeric (octal or hexadecimal etc) value?

Answer 1

Basically, the specification of assignment conversion specifies that

In addition, if the expression is a constant expression (§15.28) of type byte, short, char, or int:

A narrowing primitive conversion may be used if the type of the variable is byte, short, or char, and the value of the constant expression is representable in the type of the variable.

Your '&' is precisely "a constant expression of type byte, short, char, or int".