在Java中创建泛型类和参数

我有一个通用的sendRequest（）方法，用于从服务器返回json结果。我现在正在回调实例中解析结果，但我更愿意将类型传递给sendRequest（）方法，以便在回调之前解析和处理异常。我该怎么做？我在下面包含了相关代码和一些注释

public void sendRequest(int method, String url, final RequestListener listener) {
    StringRequest postRequest = new StringRequest(method, url,
            new Response.Listener<String>()
            {
                @Override
                public void onResponse(String response) {
                    listener.gotResponse(response, null);

                    // Instead of parsing this into a user object, I'd like to parse it into
                    // a type that I pass into the sendRequest() method.
                    try {
                        User user = User.parseJson(new JSONObject(response));
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }
            }

公共void sendRequest（int方法、字符串url、最终RequestListener）{
StringRequest postRequest=新的StringRequest（方法、url、，
新的Response.Listener（）
{
@凌驾
公共void onResponse（字符串响应）{
getresponse（response，null）；
//与其将其解析为用户对象，不如将其解析为
//传入sendRequest（）方法的类型。
试一试{
User=User.parseJson（新的JSONObject（响应））；
}捕获（JSONException e）{
e、 printStackTrace（）；
}
}
}

在这里为您写了一些东西，我认为您可以将其应用到您的示例中：

import java.util.*；
公猫{
公共静态void main（字符串…参数）{
Cat=新的Cat（）；
cat.send（Dog.class）；
cat.send（Mouse.class）；
}
公共无效发送（类clazz）{
试一试{
T=clazz.newInstance（）；
t、 parse（）；
}捕获（例外e）{
}
}
}
可解析接口{
void parse（）；
}
类Dog实现可解析的{
公共空解析（）{
System.out.println（“狗解析”）；
}
}
类鼠标实现可解析{
公共空解析（）{
System.out.println（“鼠标解析”）；
}
}

---

您的方法是静态的，所以您可能只需要执行

T.parseJson（）

。不确定将泛型类型传输到匿名侦听器是否不会有任何问题，但我希望它能工作。

首先请注意，您有现成的

JsonObjectRequest

，它将直接将响应转换为

JSONObject

，这似乎比中的

StringRequest

更好您的情况下，但由于您想更进一步，我建议创建一个基于通用解组器的

public interface JsonUnmarshaller<T> {
    T parse(JSONObject object) throws JSONException;
}

公共接口JSONumarshaller{
T parse（JSONObject对象）抛出JSONException；
}

自定义请求可以如下所示：

public class JSONRequest extends Request<T> {
    private final Listener<T> mListener;
    private final JsonUnmarshaller<T> unmarshaller;

    public JSONRequest(int method, String url, Listener<T> listener,
        ErrorListener errorListener, JsonUnmarshaller<T> unmarshaller) {
        super(method, url, errorListener);
        mListener = listener;
        this.unmarshaller = unmarshaller;
    }

    @Override
    protected void deliverResponse(T response) {
        mListener.onResponse(response);
    }
    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse response) {
        String parsed;
        try {
            parsed = new String(
                response.data, HttpHeaderParser.parseCharset(response.headers)
            );
        } catch (UnsupportedEncodingException e) {
            parsed = new String(response.data);
        }
        try {
            return Response.success(
                unmarshaller.parse(new JSONObject(parsed)), 
                HttpHeaderParser.parseCacheHeaders(response)
            );
        } catch (JSONException je) {
            return Response.error(new ParseError(je));
        }
    }
}

public类JSONRequest扩展请求{
私人最终聆听者；
私有最终JSONumarshaller解组器；
公共JSONRequest（int方法、字符串url、侦听器、，
ErrorListener ErrorListener，JSONumarshaller解组器）{
super（方法、url、errorListener）；
mListener=监听器；
this.unmarshaller=unmarshaller；
}
@凌驾
受保护的无效交付响应（T响应）{
mListener.onResponse（response）；
}
@凌驾
受保护的响应parseNetworkResponse（NetworkResponse响应）{
字符串解析；
试一试{
已解析=新字符串(
response.data，HttpHeaderParser.parseCharset（response.headers）
);
}捕获（不支持的编码异常e）{
parsed=新字符串（response.data）；
}
试一试{
回答：成功(
parse（新JSONObject（已解析）），
HttpHeaderParser.parseCacheHeaders（响应）
);
}捕获（JSONException je）{
返回Response.error（newparseerror（je））；
}
}
}

那么你的方法是：

public <T> void sendRequest(int method, String url, final RequestListener 
                            listener, JsonUnmarshaller<T> unmarshaller) {
    JSONRequest postRequest = new JSONRequest(...

public void sendRequest（int方法、字符串url、最终RequestListener
侦听器，JSONMarshaller（解组器）{
JSONRequest postRequest=新的JSONRequest（。。。

我觉得没有阅读文档很傻，他们在那页上的例子正是我想要的。谢谢！