Fw: [rapidsource@googlegroups.com] : Auto boxing

I appeared for NIC exam on last Sunday. they asked one question related to auto boxing. I got confused and applied my common sense and by luck my answer was correct.
The question was :
What is the output of following

Short s=0x00FE;
Byte b=(byte)s;
System.out.println(b);

As per as old java, we can create object of Short and Byte wrapper classes like above syntax, it will give compile time error. But in new Java due to Auto boxing support. We can create non-primitive object for the primitive values on the fly. You no need to specify explicitly like "Short s=new Short(0xFE)" .

Auto boxing is the feature that allow automatic conversion between non-primitive type to primitive type and vis-versa.

======================================================================

In the version of J2SE 5.0 released by Sun, Autoboxing is one of the new feature. Before J2SE 5.0, working with primitive types required the repetitive work of converting the primitive types into wrapper classes and vice - versa. Sometimes the purpose of conversion is just for some API call, after which the results have to be converted into original form which is very frustrating .Auto-boxing and Auto-Unboxing enables the primitive types to be converted into respective wrapper objects and the other way around.This article gives some insight about the importance of this new feature and how it can be used in the real-world programming.

Boxing/Unboxing

• Let's take a small example of incrementing the value of Integer Object for understanding the concept of Boxing/Unboxing.
  

 Before Java 5   int intPrimitive = intObject.intValue();
       intPrimitive++;
       intObject = new Integer(intPrimitive);
       Using Java 5   Integer intObject = new Integer(10);
       intObject++;     

The output for the above examples will be same. In the first example we are creating an Integer object, unwrapping it to primitive value, incrementing the primitive value, rewrapping it to Integer object again.

In the second example when the compiler encounters the line intObject++ compiler unwraps Integer object to primitive type, increments it and rewraps to Integer Object again,So When the compiler got to the line intObject++; it substitues the code which will be something like this:

 Integer.valueOf(intObject.intValue()+1);
       or  
      int intPrimitive = intObejct.intValue();
      intPrimitive++;
       intObject = new Integer(intPrimitive); 

Below example's show different ways of Boxing/Unboxing.

         Boolean isValid = false;  
              // Boxing
               Short shortObject = 200;
            // Boxing
  if(shortObject<20){
 // unboxing          }
               ArrayList<
Integer> list = new ArrayList<
Integer>();  
         for(int i = 0; i < 10; i++){
 list.add(i);          // Boxing
          }