如何使用泛型类作为参数并扩展类型？

Question

I am attempting to use generics in my project to have a base class that can make use of different types of objects. But I am having trouble when trying to pass these generic typed classes as parameters in some cases.

So I guess my question is, is there any way to use a certain generic typed interface and pass in extensions of the generic type?

I am sorry if I am phrasing this strangely, I am not very used to trying to explain these types of questions. I would be glad for some kind of insight into generics, I feel like I can't get a grip on how they really worked. I have read many posts about them but I couldn't find any that describe my problem or really help me understand it all.

I have tried numerous variations on extending the generic type T, also trying to use wildcards. But I always just end up with way to many nested generics and captures of wildcards and I just make a mess.

I have this interface:

public interface NiceObject<T extends SomeClass> {}

And then I want to be able to extend it with different implementations:

public class EpicClass extends SomeClass {}

public class CoolObject implements NiceObject<EpicClass> {}

This works fine for me, but when I attempt to pass an implementation of NiceObject as a parameter of type NiceObject<T> where T is an extension of SomeClass it tells me that the type is not applicable.

public void coolMethod(NiceObject<SomeClass> obj);

CoolObject obj = new CoolObject();
coolMethod(obj);
// this does not work

I have also tried changing the method in some ways:

public void coolMethod(NiceObject<?> obj);

public void coolMethod(NiceObject<? extends SomeClass> obj);

public <S extends SomeClass> void coolMethod(NiceObject<S> obj);

// None of these produce my desired result
// I just end up with non-applicable parameters somewhere in my program.

EDIT I'll try to make my question a bit clearer:

NiceObject<EpicClass> obj = new CoolObject();
coolMethod(obj);

// Message:
// The method coolMethod(NiceObject<SomeClass>) in the type NiceMethods
// is not applicable for the arguments (NiceObject<EpicClass>)

What confuses me is that EpicClass is clearly an extension of SomeClass , shouldn't the compiler be able to accept it as a SomeClass because it inherits the same properties as one?

EDIT 2 It seems like I have resolved my issue now. I have a tendency to solve my problem right after I make a post about it.

As a comment proposed, it was more about the problems it caused in other parts of the program. I didn't want to mix in other parts of my program because the structure of it and my overuse of generics is kind of dumb and I did not want to make it even more confusing.

When I modified the coolMethod() to be able to accept any kind of NiceObject<SomeClass> other problems appeared. I had methods in a NiceObject that had to use it's own type of NiceObject as parameters. I solved it by creating a method that would return itself and subtypes would implement that method.

public interface NiceObjectUser <N extends NiceObjectUser<N>> {
     public N getSelf();
}

I also did other silly things to make the errors disappear and I had to refactor quite a few other classes. in the end though, it works so whatever.

I do appreciate the answer which explained some things about generics which I have now accepted. I now feel like I have a greater level of understanding of generics.

Answer 1

The issue here is that even though EpicClass is a subtype of SomeClass , NiceObject<EpicClass> is a subtype of NiceObject<SomeClass> . To see why, consider:

class Box<T> {
  private T value;
  T get() {
    return value;
  }

  void set(T value) {
    this.value = value;
  }
}

Now think of two classes like Object and String , where String is a subtype of Object . Let's say we allowed Box<String> to be a subtype of Box<Object> . That would mean you can use a Box<String> anywhere that was expecting a Box<Object> . Now think about code like this:

Box<String> stringBox = new Box<String>();
Box<Object> objectBox = stringBox;
objectBox.set(new NonStringObject());
String string = stringBox.get(); // Error! Got a NonStringObject() from a string box!

In general, the fact that a box might consume a T or produce a T means that subtyping rules don't work the way you might expect. In general the proposed alternatives you posted are the way to go when you run into a problem like this; in order to figure out why they're not working we're going to have to know more about the specifics of what you're trying to do.