java方法中的两种泛型类型

我正在使用Reformation2构建一些同步json代理

我的服务器的响应始终采用以下格式：

{status:code, something:{complex object}}

所以我有：

public class BasicResponse<T> {

    private T data;

    @SerializedName("status")
    private String status;

 }

公共类基本响应{
私有T数据；
@序列化名称（“状态”）
私有字符串状态；
}

我的解析器有一个映射，它动态定义类型，并根据服务器响应中“某物”的名称创建一个

BasicResponse

事实上，一切都很好，当“某物”返回我使用数组处理的对象列表时

但是我想将数组更改为任何类型的集合，我真的不想更改解析器，所以我创建了一个方法：

private <U> BasicResponse<U> handleResponse(Response<? extends BasicResponse<U>> resp){

        BasicResponse handledResponse = null;


        if (resp != null && resp.isSuccessful() && resp.body() != null) {
            resp.body();

            if(handledResponse.getData().getClass().isArray())


handledResponse.setData(Arrays.asList(handledResponse.getData()));
//a lot of others stuff
return handledResponse;
}

---

private BasicResponse handleResponse（Response因此，如果我理解正确，您希望单个方法能够处理数组和原子元素的混合类型BasicResponse输入，但返回总是列表类型的BasicResponse

您不能使用类型参数（代码中的U）将组件类型从输入绑定到返回。原因是X和X[]（无论X是什么）没有排除任何其他类型响应数据的公共超类

一种方法是提供lambda，将输入类型转换为输出类型，如下所示：

private <U,V> BasicResponse<U> handleResponse(final Response<BasicResponse<V>> resp, final Function<U, V> cast) {
   if (resp == null || !resp.isSuccessful() || resp.body() == null)
       return null;
   else 
       return new BasicResponse<>(cast.apply(resp.body().getData()));
}
...
Response<BasicResponse<String[]>> arrayResp = ...;
BasicResponse<List<String>> listBasicResp = 
    handleResponse(arrayResponse, (v) -> Arrays.asList(v));
...
Response<BasicResponse<String>> atomicResp = ...;
BasicResonse<List<String>> listBasicResp2 = 
    handleResponse(atomicResponse, (v) -> Collections.singletonList(v));

private BasicResponse handleResponse（最终响应响应，最终函数转换）{
if（resp==null | |！resp.issusccessful（）| | resp.body（）==null）
返回null；
其他的
返回新的BasicResponse（cast.apply（resp.body（）.getData（））；
}
...
响应arrayResp=。。。；
BasicResponse列表BasicResp=
handleResponse（arrayResponse，（v）->Arrays.asList（v））；
...
响应原子响应=。。。；
BasicResonse列表BasicResp2=
HandlerResponse（atomicResponse，（v）->Collections.singletonList（v））；

请注意，只要提供适当的lambda来进行翻译，就可以为输入和结果基本响应混合不同的组件类型。我想说的是，在大多数情况下，这不应该是一个问题，事实上，没有任何东西会阻止用户代码进行这样的翻译，即使您不促进某个方法这样做。

如果要为组件类型绑定的这两种特定情况提供预制方法，则只需添加两个附加的HandlerResponse方法，在上述方法中进行委托，并提供适当的lambda：

private <U> BasicResponse<List<U>> handleSingleObjectResponse(final Response<BasicResponse<U>> resp) {
     return handleResponse(resp, (v) -> Collections.singletonList(v));
}

private <U> BasicResponse<List<U>> handleArrayResponse(final Response<BasicResponse<U[]>> resp) {
     return handleResponse(resp, (v) -> Arrays.asList(v));
}

private BasicResponse handleSingleObjectResponse（最终响应响应）{
returnhandleresponse（resp，（v）->Collections.singletonList（v））；
}
私人基本响应手动响应（最终响应响应）{
返回handleResponse（resp，（v）->Arrays.asList（v））；
}

请注意，您不能重载与擦除后相同的方法名，它们都共享签名：（Response）