史上最通俗易懂的Java泛型

一、什么是泛型

佛说:“泛型就是参数化类型"，佛还说，"泛型的意义在于代码的复用".

举个例子，有一个类，如下

public class ResultEnttity {
	private int code;
	private String msg;
	private String data;
	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 String getData() {
		return data;
	}
	public void setData(String data) {
		this.data = data;
	}

​这个类用来保存返回给前台的结果，code表示结果代码，msg是消息，data是具体处理的数据.
此时data是String型,当我们保存整型时，可以拼接一个空字符串，如

	public static void main(String[] args) throws InterruptedException {
			int data =520;
			ResultEnttity eentity =new ResultEnttity(200, "", data+"");
			System.out.println(eentity.getData());
	}

但是这么做感觉不优雅，本来数据就是整形，要转成String返回，此时可以使用泛型来解决，修改ResultEnttity，加个泛型

public class ResultEnttity<T> {
	private int code;
	private String msg;
	private T data;
	public ResultEnttity(int code, String msg, T data) {
		super();
		this.code = code;
		this.msg = msg;
		this.data = data;
	}
	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;
	}


}

此时使用就更优雅了，在类名后加入<>，里面是具体类型

如果要存放整数，可以看到，getData().getClass()方法会根据泛型是什么类型，而获取什么类型，并且指定泛型后，无法存放其他类型的数据。

但是也可以不指定泛型，可以存放任何类型，而getClass()的时候，是具体的存放的类型，如下

二、泛型方法

比如有一个HashMap，如果想提取里面的所有value，返回List，可以这样做

	public static void main(String[] args) throws InterruptedException {
		Map<String,String> map1 =new HashMap<>();
		map1.put("1", "1");
		map1.put("2", "2");
		System.out.println(getValue(map1));
	}
	
	private static List<String> getValue(Map<String,String> maps) {
		Collection<String> list =maps.values();
		return new ArrayList<String>(list);
		
	}

}

但是有一天Map的泛型变成了 Map<String,Integer> 也要提取这里面的所有value，那么这个方法可就用不上了，此时可以使用泛型方法解决这个“多种类型”value的需求。

	public static void main(String[] args) throws InterruptedException {
		Map<String,String> map1 =new HashMap<>();
		
		map1.put("1", "1");
		map1.put("2", "2");
		System.out.println(getValue(map1));
		
		Map<String,Integer> map2 =new HashMap<>();
		map2.put("1", 1);
		map2.put("2", 2);
		map2.put("3", 3);
        System.out.println(getValue(map2));
	}

	private static <T>   List<T> getValue(Map<String,T> maps) {
		Collection<T> list =maps.values();
		return new ArrayList<T>(list);
	}

大概思想是，你给你传什么类型，我给你吐出什么类型

二、泛型接口

接口名后加入<T>,并且声明了三个方法

print show getAll 中的T即具体实现类的时给出的类型

public interface IPaint<T> {
	 T print();
	 
	 void show(T t);
	 
	 List<T> getAll();
}

具体实现类，如果没有给出泛型，则默认的都是Object类型

public class Main implements IPaint<String>{
		
	public static void main(String[] args) throws InterruptedException {
			Main main =new Main();
			main.print();
			main.show("show");
			System.out.println(main.getAll());
	}

	@Override
	public String print() {
		System.out.println("print方法");
		return "print方法";
	}

	@Override
	public void show(String t) {
		System.out.println(t);
		
	}

	@Override
	public List<String> getAll() {
		String[] array = {"a","b"};
		return Stream.of(array).collect(Collectors.toList());
	}
}