当类中没有定义泛型类型变量时，处理泛型类成员

Question

Please have a look at the following code:

public class MyClass<T extends MyObject> {
    private Class<T> clazz;
    public void setClass1(Class<T> clazz) {
        this.clazz = clazz;
    }
    public Class<T> getClass1() {
        return clazz;
    }
    public T getObject1() {
        T o = null;
        try {
            o = clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return o;
    }
}

The above works great but requires the class type T to be known before any MyClass object is created. Now if I want to delay specifying T until setClass1() is ever called, I have to remove <T extends MyObject> from MyClass declaration to something like below:

public class MyClass {
//  private Class<T> clazz; // doesn't work anymore as T is unknown, so do the following instead
    private Class<? extends MyObject> clazz;
    public <T extends MyObject> void setClass1(Class<T> clazz) {
        this.clazz = clazz; // OK
    }
    public void setClass2(Class<? extends MyObject> clazz) {
        this.clazz = clazz; // OK
    }
    public <T extends MyObject> Class<T> getClass1() {
        return clazz; // Error, need casting to Class<T>
    }
    public Class<? extends MyObject> getClass2() {
        return clazz; // OK
    }
    public <T extends MyObject> T getObject1() {
        T o = null;
        try {
            o = clazz.newInstance(); // Error, must cast to T
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return o;
    }
    public MyObject getObject2() {
        MyObject o = null;
        try {
            o = clazz.asSubclass(MyObject.class).newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return o; // OK, but lost the difference between ? extends MyObject and MyObject
    }
}

First, why getClass1() gives error, while setClass1() is OK?

Second, why the return in getObject1() must be cast to (T) ?

Third, how do you fix getObject1() without unnecessary casting nor @SuppressWarnings("unchecked") ?

Fourth, in my case would changing from using setClass1() , getClass1() , getObject1() to setClass2() , getClass2() , getObject2() better?

Answer 1

First, why getClass1() gives error, while setClass1() is OK?

In setClass() you assign a Class<? extends MyObject> Class<? extends MyObject> to a variable of type Class<? extends MyObject> Class<? extends MyObject> . That is allowed.

In getClass() , you want to retrieve a Class<T> from a variable of type Class<? extends MyObject> Class<? extends MyObject> . But the compiler has no way to know if what is stored in the variable is really a Class<T> or perhaps a Class<U> . So this is forbidden.

Second, why the return in getObject1() must be cast to (T)?

Class<? extends MyObject>.newInstance() Class<? extends MyObject>.newInstance() returns an object of type ? extends MyObject ? extends MyObject . This is not the same as T . That's why you have to cast.

Third, how do you fix getObject1() without unnecessary casting nor @SuppressWarnings("unchecked")?

As explained, the version above does not contain an unnecessary cast. You either have to make T a generic parameter of the class itself or you need the cast.

Answer 2

private Class<? extends MyObject> clazz;

public <T extends MyObject> void setClass1(Class<T> clazz) {
    this.clazz = clazz; // OK
}

In this example, clazz is defined as a reference that can hold any kind of Class objects that are of some unknown type that is a subclass of MyObject .

The any part is important. This is why setClass1 works since it assigns effectively the same thing to clazz - a subtype of MyObject . Because of this, the compiler will not complain.

Your method setClass1 is effectively a more generic version of this method:

public void setClass3(Class<MyObject> clazz) {
    this.clazz = clazz; // OK
}

since setClass3 assigns the most concrete type Class<MyObject> to clazz , which can hold any Class that is MyObject or a subclass of it.

Moving on.

  public <T extends MyObject> Class<T> getClass1() {
        return clazz; // Error, need casting to Class<T>
  }

This will not work since T is a subclass of MyObject , but can you be certain that clazz holds Class<MyObject> or Class<T> for some value of T?

For example, imagine you also have these classes defined somewhere:

public class MySubObject1 extends MyObject {...}

and

public class MySubObject2 extends MyObject {...}

Imagine that the wildcard type ? represents MySubObject1 while T represents MySubObject2 and since they bear no relationship to each other, the compiler will complain. Remember, you cannot do this:

    MySubObject1 so1 = new MySubObject2(); // compiler error

    MySubObject2 so2 = new MySubObject1(); // compiler error

A similar problem exists in getObject1 - the compiler cannot know that T represents a class or a superclass of clazz (remember it can hold any subclass of MyObject ), that's why the casting is necessary.

With your current design, you cannot really avoid casting and @SuppressWarnings("unchecked") in getObject1 . If possible, try to avoid mixing generic types and wildcards.

One more thing. getClass2 forces its users to deal with a wildcard - not a great API design decision.

Methods in your public class MyClass class have potential type safety issues.

Are you sure that your original public class MyClass<T extends MyObject> class doesn't meet your needs? It looks fine to me, except the clazz.newInstance(); part since it requires MyObject and every one of its subclasses to have a zero argument constructor.