未选中的强制转换：&#39;java.lang.Class <capture<?> &gt;&#39;to&#39;java.lang.Class <T>

Question

I am trying to write the following method in my super class:

public <T extends Downloader> T getDownloader(Context context, Integer... positions) throws Exception {

    Class<T> mClass = (Class<T>)Class.forName(getDownloaderClassName());
    T downloader = mClass.cast(mClass.getConstructors()[0].newInstance(context));
    if (downloader != null)
        downloader.setPositions(positions);

    return downloader;
}

Yet, I don't know how to avoid AndroidStudio telling me

Unchecked cast: 'java.lang.Class<capture<?>>' to 'java.lang.Class<T>

Either I get it regarding the first line, or, if I change

Class<T> to Class<?>

Then I have to perform a direct cast

(T)mClass.getConstructors....

To be more precise, this super class is abstract, and getDownloaderClassName() is actually defined as follows:

public abstract String getDownloaderClassName();

So that the daughter classes can choose with descendant of Downloader they need to retrieve using getDownloader().

Answer 1

Ok, I guess I am confused between T and ?, So I found a warning free way of doing it:

   public Downloader getDownloader(Context context, Integer... positions) throws Exception {

    Class<? extends Downloader> mClass = getDownloaderClassName();
    Downloader downloader = mClass.cast(mClass.getConstructors()[0].newInstance(context));
    if (downloader != null)
        downloader.setPositions(positions);

    return downloader;
}

public abstract Class<? extends Downloader> getDownloaderClassName();

and then, the abstract method just becomes:

@Override
public Class<? extends Downloader> getDownloaderClassName() {
    return DemoDownloader.class;
}

in the descendants.

I guess I'll just have to cast the result of getDownloader when I need specific fields or methods.

Answer 2

The signature public <T extends Downloader> T getDownloader(Context context, Integer... positions) is not type safe. It makes getDownloader a generic method, which means that it must work correctly no matter what the caller wants T to be, without knowing what T is . Note that T does not show up in any of the parameter types. This means that the same exact call with the same exact arguments, must somehow return type Downloader1 if that's what one caller wants and also return type Downloader2 if that's what another caller wants, without the getDownloader method having any information about what the caller wants! This is clearly impossible, unless getDownloader always returns null .

The signature public Downloader getDownloader(Context context, Integer... positions) is different, because it says that the getDownloader method returns type Downloader . Your getDownloader method chooses the type of the thing to return (as long as it's a subtype of Downloader ); the caller doesn't choose the type, and cannot make any assumptions about the thing returned except that it's an instance of Downloader . That is type safe.