Java通用继承。 重载或覆盖

Question

please compare two code snippets:

snippet1:

class Ideone
{
    public static void main (String[] args) throws java.lang.Exception
    {
        Child<String> p =new Child<String>();
        p.m("1");
    }
}
class Parent <T>{
    void m(T t){

    }
} 
class Child<T extends CharSequence> extends Parent<String>{
    void m(T t){

    }
} 

result( online compiler ):

Main.java:13: error: reference to m is ambiguous, both method m(T#1) in Parent and method m(T#2) in Child match pm("1"); ^ where T#1,T#2 are type-variables: T#1 extends Object declared in class Parent T#2 extends CharSequence declared in class Child

snippet2(only one change!!!):

class Ideone
{
    public static void main (String[] args) throws java.lang.Exception
    {
        Parent<String> p =new Child<String>();
        p.m("1");
    }
}
class Parent <T>{
    void m(T t){

    }
} 
class Child<T extends CharSequence> extends Parent<String>{
    void m(T t){

    }
} 

this code compiles good!( online compiler )

please clarify this diference.

Answer 1

So the thing is here that what you have going on actually isn't overriding. Notice that if you add the @Override annotation to m() in Child you'll get a compilation error in both cases:

Main.java:22: error: method does not override or implement a method from a supertype
    @Override

---

You can imagine Child actually looking like this:

class Child<T extends CharSequence> extends Parent<String>{
    void m(T t){

    }

    void m(String t) { // <-- This was the method inherited from Parent

    }
} 

So when you try

Child<String> p =new Child<String>();

The compiler sees the reference type Child<String> and sees that you actually have two methods that could work, as you have the m(String t) that was inherited from Parent<String> and m(T t) defined in Child , where T == String . Because now you effectively have two m(String t) methods, you'll have an ambiguous call.

Now, if you have

Parent<String> p =new Child<String>();

The compiler sees the reference type Parent<String> and uses that to resolve the call to m(String) . As Parent<String> only has one such method defined, there is no ambiguous method call, so the code compiles.

This is one of the reasons why the @Override annotation should always be used -- there's no confusion about whether you are overloading a method or overriding it.

---

Interesting fact: If memory serves this is actually one of the few times where generics are not erased. If you decompile Child you'll see the header

class Child<T extends java.lang.CharSequence> extends Parent<java.lang.String> 

Answer 2

The problem is that you are in fact not overriding the m(T) method of Parent . So, you have two separate functions available:

• Parent.m(String s) , because you forced the T in Parent to be String
• Child.m(T)

Imagine this declaration for Child:

class Child<T extends CharSequence> extends Parent<Integer>

Now, the Parent<T> gets to be Parent<Integer> , which means that the m method of Parent , now is a m(Integer i) method, while you have in your child class still a m(T) method available. Now the difference is clear.

You chose T to be a String , which coincidentally extends CharSequence , but that doesn't make it override the m(T) method of Parent. So, changing your signature to:

class Child<T extends CharSequence> extends Parent<T>

should work. Now you are really overriding the method of Parent in Child.

Answer 3

Your Child class gets around the rules of overriding (and goes into the realm of overloading) by declaring a method with a parameter that depends on a bounded type. That type may be String or it may not be, so there is no clash with the method declared in the parent class when compiling the two.

However, when compiling your Ideone class, by declaring the type argument as String in

Child<String> p = new Child<String>();

the type String is bound to the type parameter T which Child declares and uses in Child#m(..) . Therefore the method appears as

void m(String t) {}

But so does Parent#m(..) because of the type argument String in the Child class declaration.

class Child<T extends CharSequence> extends Parent<String> {

As such, the Child class has two m(String) methods for that invocation. The call is ambiguous.

In

Parent<String> p =new Child<String>();
p.m("1");

the Child class method is not visible since your reference is of type Parent . There is no ambiguity.