如何将通用参数传递给方法？

Question

I am trying to store objects that are a sub-class of an abstract class, but there is a problem illustrated here:

abstract class Letter {
    public void store_object(Letter letter) {
        HashMap<Class<? extends Letter>, ? extends Letter> map = new HashMap<>();
        map.put(letter.getClass(), letter); <-- this line throws an error
    }
}
class A extends Letter {}
class B extends Letter {}

The reason map.put throws an error is that letter is not a sub-class of Letter (it is a direct instance of Letter ).

Is there a way to change the method parameter to be a generic sub-class of Letter? Something like:

public void store_object(? extends Letter letter) {

or

public void store_object(Object<? extends Letter> letter) {

The error is:

no suitable method found for put(Class<CAP#1>,NewClass19.Letter)
    method Map.put(Class<? extends NewClass19.Letter>,CAP#2) is not applicable
      (argument mismatch; NewClass19.Letter cannot be converted to CAP#2)
    method AbstractMap.put(Class<? extends NewClass19.Letter>,CAP#2) is not applicable
      (argument mismatch; NewClass19.Letter cannot be converted to CAP#2)
    method HashMap.put(Class<? extends NewClass19.Letter>,CAP#2) is not applicable
      (argument mismatch; NewClass19.Letter cannot be converted to CAP#2)
  where CAP#1,CAP#2 are fresh type-variables:
    CAP#1 extends NewClass19.Letter from capture of ? extends NewClass19.Letter
    CAP#2 extends NewClass19.Letter from capture of ? extends NewClass19.Letter

Answer 1

I'm really not sure what you're trying to do here, but this will make your code compile:

abstract class Letter {
    public <T extends Letter> void store_object(T letter) {
        HashMap<Class<? extends Letter>, T> map = new HashMap<>();
        map.put(letter.getClass(), letter); // <-- this line throws an error
    }
}
class A extends Letter {}
class B extends Letter {}

Why are you generating a new HashMap every time the store_object method is called? What is your real problem? Please read What is the XY problem?

Related: Canonical Java Generics FAQ

---

By the way, Object<Anything> is always wrong because Object is not parameterized.

---

So I saw your edit, and FYI this compiles for me:

private static HashMap<Class<? extends Test>, Test> map = new HashMap<>();

static void addTest(Test test) {
    map.put(test.getClass(), test);
}

What's your problem exactly?

Answer 2

Given B extends A , Class<? extends B> Class<? extends B> is not a subtype of Class<? extends A> Class<? extends A> , so using a generic bound of Class<? extends Letter> Class<? extends Letter> is useless.

Instead, specify the key type as simply <Class<?> and your code will compile (and you actually don't lose anything by doing this):.

Answer 3

It needs to be <? super Letter> <? super Letter> instead. There's a nice acronym to help you remember PECS

If you want to use generic parameters do :

public <T extends Letter> void method(T arg1) 

**^ oops there are no lower bounds (super) on type parameters

Edit: Just saw your edit. Originally I thought you were just placing objects into some collection. The static map declaration type arguments are correct. because this one instance will be used by everything for both usage and storage, so it needs to be <Class<? extends>, VCorePanel> <Class<? extends>, VCorePanel> .

static Map<Class<? extends VCorePanel>, VCorePanel> self...pm;
public static showPanel(T newInstance){
    ...
    VCorePanel OldInstance = self_panel_map.get(newInstance.getClass()); //use
    ...
    self_panel_map.put(newInstace.getClass(), newInstance); //storage
}

ps. if you are using java 8, you can just pass in a constructor as opposed to using the reflection library. look into it if you'd like.