0

In version 1.5, Java have introduced the concept of auto-boxing.

public interface SomeInterface {
    public void test(Integer val);
}

public class Main implements SomeInterface {

    /*The method signature gets different and compiler is asking to override 
    un-implemented methods*/
    public void test(int t) {

    }
}

Then why I am getting compile time error for overriding un-implemented methods, why above test method's arguments are not auto-boxed to match parent test method signature?

Vishrant
  • 15,456
  • 11
  • 71
  • 120
  • the feature that is demonstated here is called method overloading... but you need to override here – AurA Jul 03 '14 at 09:19

5 Answers5

6

It's because the method in subclass is not override-equivalent with the one in super class. The super class method can take null as argument, while the subclass method can't (There's nothing about auto-boxing here).

Rohit Jain
  • 209,639
  • 45
  • 409
  • 525
  • @WillieWheeler THIS has happened with me so many times... pssshhh. – Rohit Jain Jul 03 '14 at 09:20
  • Sir, if i replace Interface method with public void test(Number val); and implemented method with public void test(Integer t){} it is not working – LMK Jul 03 '14 at 09:30
  • 1
    @LMK Because again the subclass method is not override equivalent. Basically your argument type should be same in overridden method. You can't have covariant types in argument but only in return type. – Rohit Jain Jul 03 '14 at 09:32
  • @LMK So, parameter type should exactly be same. Try this with return type, and it will work. – Rohit Jain Jul 03 '14 at 09:33
  • Please add the comment that clarify your answer in it and copy the part of the link into the answer so (even if it might never happens) the link dies, the answer stay useful. – Jonathan Drapeau Jul 22 '14 at 12:57
1

Because Integer Not Equal to int

  • Integer is class
  • int is primitive type

So both methods have different argument types that's why you are not overriding the method but creating newer one in your class.

You can call method with autoboxing feature but you can not ovverride.

Overriding

An instance method in a subclass with the same signature (name, plus the number and the TYPE of its parameters) and return type ....

The Java compiler applies autoboxing when a primitive value is:

  • Passed as a parameter to a method that expects an object of the corresponding wrapper class.
  • Assigned to a variable of the corresponding wrapper class.
Community
  • 1
  • 1
akash
  • 22,664
  • 11
  • 59
  • 87
0

Autoboxing and unboxing can happen anywhere where an object is expected and primitive type is available for example In method invocation where an object argument is expected, if you pass primitive, Java automatically converts primitive into equal value.

Read more: http://javarevisited.blogspot.com/2012/07/auto-boxing-and-unboxing-in-java-be.html#ixzz36Rhg91CB.

and here your class Main implements interface SomeInterface and this is the implementation of method not the calling of a method where autoboxing works.

ajava
  • 77
  • 1
  • 4
  • 9
0

This is conceptually impossible, because the Java runtime does not know a thing about boxing. The boxing feature was implemented on the Java compiler level, similarly to generics. As a matter of fact, the Java runtime does not consider a primitive int and a boxed Integer to have anything in common, even in the current Java 8 version.

Instead, whenever you make an assignment like:

Integer i = 42;

the Java compiler desugars this expression to

Integer i = new Integer(42);

which is then observed as above by the Java runtime. At the same time, the Java runtime considers

void foo(int i);
void foo(Integer i);

to be different methods which is why boxing would have been difficult to be implemented at the runtime level for reasons of backwards compatibility.

Rafael Winterhalter
  • 42,759
  • 13
  • 108
  • 192
0

The simple answer to this is :

If 2 methods can be overloaded, it means, compiler considers the signatures to be different.

And, for Overriding a method, both the methods should be having the same signature.

E.g. : 

//Method overloading, compiler doesn't complain, which means "signatures are different",
//because one is expecting an object of Integer Class, and other is expecting a primitive value.
class A{
  public void a(Integer a){...}
  public void b(int a){...}
}

//Method Overriding, compiler complains, because "signatures are different!"
class A{
  public void a(Integer a){...}
}
class B extends A{
    @Override
    public void a(int a){...}
}
aayoustic
  • 99
  • 9
  • Did not answer my question. I am having interface, and there won't be compile time error. If you are adding something like "Note" do provide the reference. – Vishrant Jun 19 '18 at 14:11
  • The NOTE was for the overloading example I provided, have edited my answer accordingly. – aayoustic Jun 20 '18 at 07:38
  • U can check the updated comment in Method Overloading example section. – aayoustic Jun 20 '18 at 09:09
  • 1
    thanks for updating, the whole point was if you are quoting something then you are supposed to provide a reference. – Vishrant Jun 20 '18 at 14:01
  • also whatever you posted, comes down to my initial question which is "why above test method's arguments are not auto-boxed to match parent test method signature" I am looking for **why compiler does that** not **how compiler behaves** :) – Vishrant Jun 20 '18 at 14:04
  • Yeah, got your point about the Reference, thanks ! New to StackOverflow :) Coming to the point, Unboxing occurs once you make a call to the method, or pass a primitive value to the Integer reference. Here, the compiler knows, one method has Integer as an argument, the other has a primitive type int as an argument. Therefore, the signature is different. – aayoustic Jun 22 '18 at 05:53
  • Adding to the above. When you call a method, say with primitive type argument, the compiler first looks for a method with primitive argument, and if it isn't present, it looks for the Wrapper class arg method. It's quite clear, the compiler considers both as different arg methods. – aayoustic Jun 22 '18 at 06:12