Android异步任务上的Java泛型

对于Android项目，我有许多响应任务要异步运行。这些任务只因它们生成的类的类型不同而不同。我是Java泛型新手，所以我很难用泛型T或ClassT替换News.class（仍在计算差异）。有人能指出我如何正确地考虑这一点吗

private class AcquireResponseTask<T> extends AsyncTask<RestClient, Void, T> 
{
     protected void onPostExecute(T news) 
     {
         process(news);
     }

    @Override
    protected T doInBackground(RestClient... rc)
    {

        return (T) DataToObject.acquireResponse(rc[0],
                News.class);
    }
 }

私有类收单机构响应任务扩展异步任务
{
受保护的void onPostExecute（T新闻）
{
过程（新闻）；
}
@凌驾
受保护的T doInBackground（RestClient…rc）
{
返回（T）数据到收单机构响应对象（rc[0]，
新闻类）；
}
}

您从以下位置返回什么：

return (T) DataToObject.acquireResponse(rc[0],
                News.class);

它是新闻对象

如果是，则：

private class AcquireResponseTask extends AsyncTask<RestClient, Void, News> 
{

@Override
protected News doInBackground(RestClient... rc)
{

    return (News) DataToObject.acquireResponse(rc[0],
            News.class);
}

@Override
protected void onPostExecute(News news) 
 {
     process(news);
 }

}

私有类收单机构响应任务扩展异步任务
{
@凌驾
受保护的新闻doInBackground（RestClient…rc）
{
返回（新闻）数据对象收单机构响应（rc[0]，
新闻类）；
}
@凌驾
受保护的void onPostExecute（新闻）
{
过程（新闻）；
}
}

使用泛型时需要记住的一点是，类型信息仅在编译时出现，而不是在运行时出现。如果您需要对该类型执行运行时操作（如转换为T），那么您需要显式地使用该类型的类对象

因此，您可以在构造函数中传入该类，然后稍后使用它进行转换：

private final Class<T> theTClass;

public AcquireResponseTask( Class<T> clazz ) {
    theTClass = clazz;
}

@Override
protected T doInBackground(RestClient... rc)
{

    return theTClass.cast( DataToObject.acquireResponse(rc[0],
            News.class));
}

private final Class和Class；
公共收单机构响应任务（类别clazz）{
theTClass=clazz；
}
@凌驾
受保护的T doInBackground（RestClient…rc）
{
返回class.cast（数据到对象收单机构响应（rc[0]，
新闻类),；
}

因此，以下是似乎有效的流程。对于我收到的任何请求，其中响应将是JSON数据，我希望GSON能够检索数据并将其解析为Java类对象——创建一个新的AcquisitionResponseTask，类型为“表示为Java类的JSON数据”，并使用class类型和processing function对象来处理具体细节

public interface ProcessResponse<T>
{
    void process(T response);
}

public class AcquireResponseTask<T> extends AsyncTask<RestClient, Void, T> 
{
    private Class<T> type;
    private ProcessResponse<T> func;

    public AcquireResponseTask(Class<T> classType, ProcessResponse<T> f)
    {
        type = classType;
        func = f;
    }

     protected void onPostExecute(T response) 
     {
         func.process(response);
     }

    @Override
    protected T doInBackground(RestClient... rc)
    {
        return (T) JSONToJava.acquireResponse(rc[0],
                type);
    }
 }  

公共接口ProcessResponse
{
空洞过程（T反应）；
}
公共类收单机构响应任务扩展异步任务
{
私人阶级类型；
私有进程响应函数；
公共收单机构响应任务（类类型，ProcessResponse f）
{
类型=类类型；
func=f；
}
受保护的void onPostExecute（T响应）
{
职能过程（响应）；
}
@凌驾
受保护的T doInBackground（RestClient…rc）
{
return（T）JSONToJava.acquisitoriesponse（rc[0]，
类型）；
}
}  

我不再为每种数据类型多次编写上述代码，而是为每种数据类型提供以下代码：

class TopicsResponseProcessor implements ProcessResponse<Topics>
    {
        public void process(Topics response)
        {
            createTopicsList(response);
        }

    }

new AcquireResponseTask<Topics>(Topics.class,TopicsResponseProcessor ()).execute(UrlBuilder.getTopics());

类TopicsResponseProcessor实现ProcessResponse
{
公开作废流程（主题响应）
{
createTopicsList（响应）；
}
}
新收单机构响应任务（Topics.class，topicssresponseprocessor（））.execute（UrlBuilder.getTopics（））；

我正在尝试删除特定的类新闻引用，并将其替换为泛型。为什么要这样做？解释原因以便我能提供更多帮助。这与我的想法非常接近。