Java泛型

Java 泛型（Generics） 是 JDK 5 中引入的一个新特性。可以在编译时提供更强的类型检查 ，并且在编译后能够保留类型信息，避免了在运行时出现类型转换异常。

泛型 3 种用法

泛型一般有三种使用方式:泛型类 、泛型接口 、泛型方法。

泛型类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{

    private T key;

    public Generic(T key) {
        this.key = key;
    }

    public T getKey(){
        return key;
    }
}


//实例化泛型类
Generic<Integer> genericInteger = new Generic<Integer>(123456);

泛型接口

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


//泛型接口
public interface Generator<T> {
    public T method();
}


//实现接口，不指定类型
class GeneratorImpl<T> implements Generator<T>{
    @Override
    public T method() {
        return null;
    }
}


//实现泛型接口，指定类型
class GeneratorImpl implements Generator<String> {
    @Override
    public String method() {
        return "hello";
    }
}

泛型方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


//泛型方法
public static < E > void printArray( E[] inputArray )
{
         for ( E element : inputArray ){
            System.out.printf( "%s ", element );
         }
         System.out.println();
}


//使用
//创建不同类型数组：Integer, Double 和 Character
Integer[] intArray = { 1, 2, 3 };
String[] stringArray = { "Hello", "World" };
printArray( intArray  );
printArray( stringArray  );

案例：通用结果返回类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


public class BaseResponse<T> implements Serializable {

  private int code;

  private T data;

  private String message;

  public BaseResponse(int code, T data, String message) {
    this.code = code;
    this.data = data;
    this.message = message;
  }

  public BaseResponse(int code, T data) {
    this(code, data, "");
  }

  public BaseResponse(ErrorCode errorCode) {
    this(errorCode.getCode(), null, errorCode.getMessage());
  }
}



public class ResultUtil {

  /**
   * 成功
   *
   * @param data
   * @param <T>
   * @return
   */
  public static <T> BaseResponse<T> success(T data) {
    return new BaseResponse<>(200, data, "ok");
  }

  /**
   * 失败
   *
   * @param errorCode
   * @return
   */
  public static BaseResponse error(ErrorCode errorCode) {
    return new BaseResponse<>(errorCode);
  }

  /**
   * 失败
   *
   * @param errorCode
   * @return
   */
  public static BaseResponse error(ErrorCode errorCode, String message) {
    return new BaseResponse(errorCode.getCode(), null, message);
  }
}