Promotion in Java?

The rules for promotion is "when operan开发者_开发知识库ds are of different types, automatic binary numeric promotion occurs with the smaller operand type being converted to the larger". But the operands are of same type for example,

byte=byte+byte // Compile time error... found int..

So why is it so?

There's no + operator for byte. Instead, both operands are promoted to int, so you've got

byte = byte + byte
... becomes (widening to find + operator) ...
byte = int + int
... becomes (result of + operator) ...
byte = int 

... which then fails because there's no implicit conversion from int to byte. You need to cast:

byte a = 1;
byte b = 2;

byte c = (byte) (a + b);

Here are the actual rules for numeric promotion, from section 5.6.2 of the JLS:

When an operator applies binary numeric promotion to a pair of operands, each of which must denote a value that is convertible to a numeric type, the following rules apply, in order, using widening conversion (§5.1.2) to convert operands as necessary:

• If any of the operands is of a reference type, unboxing conversion (§5.1.8) is performed. Then:
• If either operand is of type double, the other is converted to double.
• Otherwise, if either operand is of type float, the other is converted to float.
• Otherwise, if either operand is of type long, the other is converted to long.
• Otherwise, both operands are converted to type int.

You were provided with correct answer about automatic promotion to 'int'.

There is one more note about that - compound assignment operators behave as they have an implicit type case. Example:

byte b1 = 1;
byte b2 = 2;
b1 = b1 + b2; // compilation fails
b1 += b2; // compilation successful

I would like to talk about Promotion in general

Java can evaluate only arithmetic expressions in which the operands’ types are identical

For example, in an expression containing int and double values, the int values are promoted to double values for use in the expression.

in another word

double someVar = 1 / 2;// someVar = 0

but

double someVar = (double)1 / 2;// someVar = 0.5

why?

• we use the (double) cast operator to create a temporary floating-point copy of its operand "1" (it's called explicit conversion)
• The calculation now consists of a floating-point value (the temporary double copy of 1) divided by the integer 2
• according to the above statement, Java performs an operation called promotion (or implicit conversion), so the int values are promoted to double values for use in the expression => the integer 2 is promoted to double
• the expression became double someVar = 1.0 / 2.0; // someVar= 0.5

hope this is helpful, even if it is out of the core of the question

To understand this you should refer the 2 things:

Implicit Casting: byte (8 bit) -> short (16 bit) -> int (32 bit) -> float (32 bit) -> double (64 bit) char (16 bit) -> int (32 bit)

Arithmetic Operator Rules

1. Operator Precedence Rule : This rule states that Group of (*,/, %) will be evaluated first. Then Group of (+,-) operator will be evaluated. From a same Group of Operators, calculate from the left.

2. Operand Promotion Rule : This rule states that Operands having data type smaller than int will be promoted to int. order of promotion (byte->short->int, char->int)

3. Same Type Operand Rule: This rule states that if both operands are int,long,float,double then the same type is carried to the result type. i.e. long+long => long , float + float => float, int+int => int

4. Mix Type Operand Rule : Follow the order of Promotion (int->long->float->double) if any of the operand is from the above order then the smaller will be promoted to the bigger one and result will be calculated in bigger type. i.e. long + double => double , int + long => long

From this SO question, and above answers due to + arithmetic operator, both operands are converted to type int.

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2; // compile time error

In above code, value of b1 and b2 will be resolved at runtime, so compiler will convert both to int before resolving the value.

But if we consider the following code,

final byte b1 = 1;
final byte b2 = 2;
int b3 = b1 + b2; // constant expression, value resolved at compile time

b1 and b2 are final variables and values will be resolved at compile time so compilation won't fail.