Java泛型：如何扩展另一个泛型类的泛型类

Question

First, I have a simple template, nothing fancy:

public abstract class ListOfK<K> {
   private List<K> insides = new ArrayList<>(); 
}

Next, I'm creating a service interface using the template

public abstract interface SomeService<K extends ListOfK<K>> {
    int calculateSomething (K input);
    int calculateAnother (ListOfK<K> list);
}

So far so good with the abstraction.

Now, let's get to the implementation

public class ListOfString extends ListOfK<String> {

}

and implementation of SomeService:

public class SomeServiceImpl extends SomeService<String> {
  @Override
  public int calculateSomething(String input) {
    return 0;  // TODO impl
  }

  @Override
  public int calculateAnother(ListOfK listOfK) {
    return 0;  // TODO impl
  }
}

Somehow, when SomeServiceImpl extends SomeService<String> , it marks Type parameter java.lang.String is not within its bound; should extend ListOfK<String> Type parameter java.lang.String is not within its bound; should extend ListOfK<String>

What should I input as implementation of SomeService so it doesn't give error? Or do I make mistake with SomeService? I just want a class whom input is a another class using Generic.

Thanks in advance.

Answer 1

The key insight here is that K in the context of the ListOfK class is not the same type as K in the context of the SomeService class. In fact, in your definition of SomeService , you're saying that K needs to itself be a ListOfK , which I suspect is your problem.

• Does calculateSomething need to take (1) a single value, or (2) a ListOfK of values?
• Does calculateAnother need to take (1) a ListOfK of values, or (2) a ListOfK of ListOfK values?

I think you want option 1, but you've actually chosen option 2.

To fix this, don't constrain K in SomeService :

public interface SomeService<K> {
    int calculateSomething(K input);
    int calculateAnother(ListOfK<K> list);
}

Answer 2

The issue lies in the way you are defining the SomeService interface. Your code of <K extends ListOfK<K>> says that "we need a class K which extends ListOfK , which uses K as its type parameter." So that class would have to look something like:

public class Test extends ListOfK<Test> {

Which doesn't make any sense. It shouldn't only use itself inside of the list. If you change the interface to something like:

public abstract interface SomeService<K extends ListOfK<?>> {

It should fix your issue.