Why can not I add two bytes and get an int and I can add two final bytes get a byte?

[Joey Sanchez]

    public class Java{
        public static void main(String[] args){
            final byte x = 1;
            final byte y = 2;
            byte z = x + y;//ok
            System.out.println(z);

            byte a = 1;
            byte b = 2;
            byte c = a + b; //Compiler error
            System.out.println(c);
        }
    }

If the result of an expression involving anything int-sized or smaller is always an int even if the sum of two bytes fit in a byte.

Why does it happen when we add two final bytes that fit in a byte? There is no compiler error.

[Ulf Dittmer]

Because, being final, the compiler can tell that the sum of x and y will fit into a byte without loss of precision. That's not the case with the non-final a and b.

As an experiment, compile with "x=100" and "y=200" and see what happens.

[Seetharaman Venkatasamy]

    
            final byte x = 1;
            final byte y = 2;
            byte z = x + y;//ok
            System.out.println(z);

because x+y is a compile time constants, since x and y is a compile time constant;
so compiler make sure that x+y dont overflow

 
            byte a = 1;
            byte b = 2;
            byte c = a + b; //Compiler error
            System.out.println(c);
        }
    }

here a+b is runtime expression. compiler cant evaluate them at compile time. it may not be fit in to byte .
in java arithmetic operation performed on operands that are below int ranges are resulted as int, normally.

does that make sense?

[Joey Sanchez]

Yes, It makes sense!

byte z = x + y;  // x and y are declared final

Here, since x and y are declared final so the value of expression on the RHS is known at compile time, which is fixed at (1 + 2 = 3) and cannot vary. So, you don't need to typecast it explicitly

byte c = a + b;   // a and b are not declared final

Whereas, in this case, value of a and b are not declared final. So, the value of expression is not known at compile time, rather is evaluated at runtime. So, you need to do an explicit cast.

However, even in the 1st code, if the value of a + b comes out to be outside the range -128 to 127, it will fail to compile.

final byte b = 121;
final byte a = 120;
byte x = a + b;  // This won't compile, as `241` is outside the range of `byte`

final byte b1 = 12;
final byte a1 = 12;
byte x1 = a1 + b1;  // Will Compile. byte can accommodate `24`

More information From the JLS 5.2 Assignment Conversion

[Joey Sanchez]

Ulf Dittmer wrote:Because, being final, the compiler can tell that the sum of x and y will fit into a byte without loss of precision. That's not the case with the non-final a and b.

As an experiment, compile with "x=100" and "y=200" and see what happens.

If it doesn't fit in a byte, it will produce Compilation fails!

[Henry Wong]

Joey Sanchez wrote:Yes, It makes sense!

byte z = x + y;  // x and y are declared final

Here, since x and y are declared final so the value of expression on the RHS is known at compile time, which is fixed at (1 + 2 = 3) and cannot vary. So, you don't need to typecast it explicitly

Be careful with this generalization. Yes, compile time constant variables are always declared final, but ... No, a variable that is declare final is not necessarily a compile time constant variable.

Henry

[Mark Moge]

For the record: the code with the explicit casting compiles.

           byte a = 1;  
           byte b = 2;  
           byte c = (byte) (a + b);
           System.out.println(c); // prints 3  

[Henry Wong]

Mark Moge wrote:For the record: the code with the explicit casting compiles.

           byte a = 1;  
           byte b = 2;  
           byte c = (byte) (a + b);
           System.out.println(c); // prints 3  

Yeah, it is legal to explicitly cast from any primative type to any other primative type.

Henry

[Buddhi Vikasitha]

Seetharaman Venkatasamy wrote:[code=java]

does that make sense?

Of course it does