关于java中的公共响应类

class="baidu_pl">

class="article_content clearfix">

class="htmledit_views">

BaseResponse公共响应类

class="language-class="tags" href="/tags/JAVA.html" title=java>java">package com.simple.dto;

/**
* 公共响应类
* @param <T>
*/
public class BaseResponse<T> {

private static final int CODE_SUCCESS = 200;
private static final int CODE_FAIL = 500;
private static final int CODE_ERROR = 500;
private static final int CODE_NO_LOGIN = 300;
private int code;
private String msg;
private T data;

public BaseResponse(int code, String msg, T data) {
this.setCode(code);
this.setMsg(msg);
this.setData(data);
}

public static <T> BaseResponse<T> success() {
return new BaseResponse<T>(CODE_SUCCESS, "success", null);
}
public static <T> BaseResponse<T> success(String message) {
return new BaseResponse<T>(CODE_SUCCESS, message, null);
}
public static <T> BaseResponse<T> success(T data) {
return new BaseResponse<T>(CODE_SUCCESS, "success", data);
}
public static <T> BaseResponse<T> success(String message, T data) {
return new BaseResponse<T>(CODE_SUCCESS, message, data);
}

public static <T> BaseResponse<T> error() {
return new BaseResponse<T>(CODE_ERROR, "fail", null);
}
public static <T> BaseResponse<T> error(String message) {
return new BaseResponse<T>(CODE_ERROR, message, null);
}
public static <T> BaseResponse<T> error(T data) {
return new BaseResponse<T>(CODE_ERROR, "fail", data);
}
public static <T> BaseResponse<T> error(String message, T data) {
return new BaseResponse<T>(CODE_ERROR, message, data);
}

public static <T> BaseResponse<T> badrequest() {
return new BaseResponse<T>(CODE_FAIL, "no identifier arguments", null);
}
public static <T> BaseResponse<T> badrequest(String message) {
return new BaseResponse<T>(CODE_FAIL, message, null);
}
public static <T> BaseResponse<T> badrequest(T data) {
return new BaseResponse<T>(CODE_FAIL, "no identifier arguments", data);
}
public static <T> BaseResponse<T> badrequest(String message, T data) {
return new BaseResponse<T>(CODE_FAIL, message, data);
}

public static <T> BaseResponse<T> noLogin(String message) {
return new BaseResponse<T>(CODE_NO_LOGIN, message, null);
}

public int getCode() {
return code;
}

public void setCode(int code) {
this.code = code;
}

public String getMsg() {
return msg;
}

public void setMsg(String msg) {
this.msg = msg;
}

public T getData() {
return data;
}

public void setData(T data) {
this.data = data;
}

}

回顾一下泛型<T> 与 <?>：

jdk1.5以后引入了泛型的概念，即：<>，规定了集合中元素类型

比如下面代码：

class="language-class="tags" href="/tags/JAVA.html" title=java>java">List list1 = new ArrayList();
List<String> list2 = new ArrayList();

list1.add(1);

list1.add("1");

list2.add(1);//明显会报错

泛型规范了集合的元素的类型（让集合知道了自己应该装的是什么类型），不符合，编译不通过。

分别代表：T - Type， E - Element，N - Number

作用分析，如下

class="language-class="tags" href="/tags/JAVA.html" title=java>java">public class Demo01 {

@Test
public void test() {
Box<String> b = new Box<>();
b.get();
}
}
class Box<T>{
public T get(T t) {return t;}

}

Box类声明了泛型T，但是T的类型，是由引用者声明，一旦声明了T的类型，比如String；Box中的get方法的参数类型，返回值类型，也都是String。总而言之，该类中所有出现T的地方，都只接受T类型的参数。

<?>通配符：

在类上声明 <?>，是没有意义的。
表示不确定的类型

等价于： <? extends Object>
他叫作：类型通配符
出现于方法的参数里

class="language-class="tags" href="/tags/JAVA.html" title=java>java">public static void getData(Box<?> data) {
System.out.println("data :" + data.getData());
}

作用：限制参数类型，
- <?>：限制参数类型为 Object和其子类（不知道或者不关心参数的具体类型）；
- <? extends Number> ：限制参数类型为Number和其子类；
- <? super Number> ：限制参数类型为Number和其父类；

简单总结：

作用在于声明整个类/接口，一旦使用了某种类型，该类/接口中，其余出现T的位置，也都是T类型；
<?>：是<? extends Object>简写，限制了某个方法传入参数的类型；
通配符

    表示不确定的类型
    函数里面可以对T进行操作
    当变量表达两个参数之间或参数与返回值的关系，即两处被使用
    可以使用不同的大写字母(效果一样)

场景

    ArrayList al=new ArrayList();指定集合元素只能是T类型
    ArrayList<?> al=new ArrayList<?>();集合元素可以是任意类型，这种没有意义，一般是方法中，只是为了说明用法
    ArrayList<? extends E> al=new ArrayList<? extends E>();
    泛型的限定：
    ? extends E:接收E类型或者E的子类型。
    ？super E:接收E类型或者E的父类型。