arithmetic promotion and bit shifting

[Tom Tang]

class Test{
 public static void main(String[] args) {
byte b=-64;
byte i=b>>4;
System.out.println(i);
   }
             }

As we know, because b is promoted to int before shifting, the above code will cause compiling error.
However the following code compiles neatly.

class Test{
     public static void main(String[] args) {
byte i=(byte)-64>>4;
System.out.println(i);
   }
             }

Please note unary cast operator() has higher precedence than the signed right shift operator>>. So I thought the above two codes are exactly the same. To support my argument, the same code does not compile with unsigned rigth shift >>>:

class Test{
     public static void main(String[] args) {
byte i=(byte)-64>>>4;
System.out.println(i);
   }
             }

Can someone explain the inconsistancy?


[This message has been edited by Tom Tang (edited January 21, 2001).]

[greg clarke]

Tom
Your second program compiles because you are supplying a compile-time literal value which fits in a byte, so no cast is needed. This is demonstrated by the following line which compiles ie. your line of code without the cast.

 byte i= -64>>4;

The important point is that -64>>4 can be calculated at compile time and returns -4 which is acceptable as a byte.
Your third program does not compile because the unsigned right-shift of -64 produces a very large value, far too big for a byte. So, even though the result of the shift is available at compile time, the compiler can see that you are trying to squeeze a large value into a byte, so it objects. You can make the code compile by bracketing the shift operation and applying the cast to it, but the result is truncated.

  byte i= -64>>>4; // does not compile
  byte i=(byte)(-64>>>4);  // compiles and runs but gives wrong result of -4
  int i= -64>>>4;  // compiles and outputs 268435452

I think this explains what your are observing. There is no inconsistency.