Why "byte a = 1;" compiles, but "Byte c = new Byte(1);" error out?

Let's take a look at the following code:

class Program {
    public static void main (String[] args) {
        byte a = 1;
        Byte b = new Byte(primitiveByte);
        Byte c = new Byte(1);
        Byte d = new Byte((byte)1);
        System.out.print(b.byteValue() + c.byteValue());
    }
}

Why does the line "byte a = 1;" compile without error? and Why does the "Byte c = new Byte(1);" has a compile-time error?. Both of them use the integer literal value 1 within the range of byte. So why explicit casting "(byte)1" is needed?

The assignment conversion (such as "byte a = 1;") is different than the method invocation conversion (such as "Byte c = new Byte(1);").  They are two subsections in Java Language Specification 3rd Edition:

• 5.2 Assignment Conversion : Assignment conversion converts the type of an expression to the type of a specified variable.
• 5.3 Method Invocation Conversion : Method invocation conversion is applied to each argument in a method or constructor invocation and, except in one case, performs the same conversions that assignment conversion does.

Assignment Conversion

Please read the above link for the detail about Assignment Conversion in Java. For our example:

byte a = 1; 

The assignment will not generate the compiler error because at any time if an integral value is assigned to any of the primitive types (byte, char, short), and the right hand side value is within the range of the left hand side data type, it will not generate an error. Hence as 1 is within the range of byte (-128 to 127), it is not generating compiler error. For example:

byte a = 129; //Compile-time error

When you assign an intergal value to any primitive type variable, the compiler will do a range checking to see if this value is in the range of the left side data type. If it is NOT within the range of data type, a compile-time error occurs.

If the righ-hand of assignment is a variable or expression, can narrowing primitive conversions still work (5.1.3 Narrowing Primitive Conversions in Java Language Specification 3rd Edition)?

• If the variable is a compile-time constant and the constants value is within the range of the left side data type, then it can be assigned to a narrower primitive type. Otherwise, a compiler error will occurs.
• If the expression is a compile-time constant expression and the evaluated value is within the range of the left side data type, then it can be assigned to a narrower primitive type. Otherwise, a compiler time error will occurs.

For example:

int i1=1;
final int i2 = 127;
final int i3 = 245;
byte b1 = i1;        //Compile-time error, not final variable
byte b2 = i2;        //OK, compile time constant
byte b3 = i3;        //Compile-time error, over range
byte b4 = (i2 + 2);  //OK, compile time constant expression
byte b5 = (i1 + 2);  //Compile-time error, not final variable

 

Method Invocation Conversion

Please read the above link for the detail about the Method Invocation Conversion in Java. For our example:

Byte c = new Byte(1);
				

A compile-time error will occurs because you are passing an integer to the constructor of the Wrapper class Byte, the compiler will not do the implicit casting here.

The method invocation conversions specifically do not include the implicit narrowing of integer constants which is part of assignment conversion. The designers of the Java programming language felt that including these implicit narrowing conversions would add additional complexity to the overloaded method matching resolution process.