为什么整数类对象的引用中的增量操作整数值？

Question

I have a basic doubt, we can increment reference of Integer class object, while not reference of any other class(D class has 1 Integer data member and one parameterized constructor).

Integer x=new Integer(10); x++;
    D d=new D(10); d++;

here both x and d are reference still we are able to increment Integer reference while not any other reference. I am missing something very basic, please help me out.

Answer 1

Integer x=new Integer(10); x++;

Here java compiler will do the un-boxing of the object, which converting the Integer object into primitive int . Then the increment operation will be performed. This is only defied for java primitives, the auto-boxing is converting primitive to wrapper object and reverse of it is call un-boxing . This is what is happening here.

The auto-boxing or un-boxing which is an automatic conversion, it is defined for java primitives only. So it can not be performed on other objects. Remember, the object are not just memory references like C or C++ that we can increment them.

Answer 2

This is because of Autoboxing for wrapper classes which was introduced from jdk 1.5. Internally java will convert the integer reference to int and increment it. You can't increment the objects.

Answer 3

Java has no way of overloading operators for arbitrary classes. Thus, D d; d++ D d; d++ is just not available. You can do:

public class D {
    private int value;
    public D( int v ){
        value = v;
    }

    public void increment(){
        value++;
    }
}

Now you can do

D d = new D(10);
d.increment();

and d's value will be 11.

Answer 4

According to Oracle Java Documentation , The automatic conversion of primitive data types into its equivalent wrapper type is known as autoboxing and opposite operation is known as unboxing . Whenever we use object of wrapper class in an expression, automatic unboxing and autoboxing is done by JVM.

Integer object;
object = 100;        //Autoboxing of int
++object;

When we perform an increment operation on Integer object, it is first unboxed, then incremented and then again reboxed into Integer type object. You can also take a look at How java auto boxing/unboxing works?