Java 泛型

一、泛型的由来

　　咱们先看下面这段代码：

                List list = new ArrayList();
		list.add(24);  //向集合中添加一个 Integer 类型的数据
		list.add("Tom");	//向集合中添加一个 String 类型的数据
		
		for(int i = 0 ; i < list.size() ; i++){
			Object obj = list.get(i);  //注意这里每一个类型都是 Object
			System.out.println(obj);
		}
		
		//若是咱们遍历的时候就想获得本身想要的数据类型
		for(int i = 0 ; i < list.size() ; i++){
			String obj = (String) list.get(i);  //在取 Integer 的时候会报类型转换错误
			System.out.println(obj);
		}

　　报错信息以下：

　　也就是 集合中第二个数据是 Integer，可是咱们取出来的时候将其转换为 String 了，因此报错。

　　那么这个如何解决呢？

　　①、咱们在遍历的时候，根据每一个数据的类型判断，而后进行强转。

那么咱们说这个集合只有两条数据，咱们能够进行判断强转，若是数据有成千上万条呢，咱们都经过这样判断强转确定不可取

　　②、在往集合中加入数据的时候，咱们就作好限制，好比这个集合只能添加 String 类型的；下一个集合只能添加 Integer 类型的，那么咱们在取数据的时候，因为前面已经限制了该集合的数据类型，那么就很好强转了。

　　这第二种解决办法，也就是咱们这篇文章讲的 泛型

 

二、什么是泛型？

　　泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操做的数据类型被指定为一个参数。这种参数类型能够用在类、接口和方法的建立中，分别称为泛型类、泛型接口、泛型方法。

　　在Java SE 1.5以前，没有泛型的状况的下，经过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要作显式的强制类型转换，而这种转换是要求开发者对实际参数类型能够预知的状况下进行的。对于强制类型转换错误的状况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

 

三、泛型的基本用法

　　3.1 对于上面的问题咱们只须要将上述代码的 List list = new ArrayList()  改成   List<String> list = new ArrayList<String>();

                List<String> list = new ArrayList<String>();
		//list.add(22);  //向集合中添加一个 Integer 类型的数据时，编译器会报错
		list.add("Bob");  //向集合中添加一个 String 类型的数据
		list.add("Tom");	//向集合中添加一个 String 类型的数据
		
		//若是咱们遍历的时候就想获得本身想要的数据类型
		for(int i = 0 ; i < list.size() ; i++){
			String obj = list.get(i);  //这里就不须要强转了，前面添加的是什么类型，这里获取的就是什么类型
			System.out.println(obj);
		}            

　　

　　

　　3.2 泛型是在编译阶段有效

 

        List<String> list1 = new ArrayList<String>();
	List list2 = new ArrayList();
	Class c1 = list1.getClass();
	Class c2 = list2.getClass();
	System.out.println(c1==c2); //true    

 

　　上述代码，因为咱们知道反射是在运行时阶段，c1==c2为 true,说明了编译以后的 class 文件中是不包含任意的泛型信息的。若是不信，咱们能够看 class 文件的反编译信息

        java.util.List list1 = new ArrayList();
        java.util.List list2 = new ArrayList();
        Class c1 = list1.getClass();
        Class c2 = list2.getClass();
        System.out.println(c1.equals(c2));

　　咱们能够看到 反编译以后的 list1和 list2彻底同样。

　　结论：Java 泛型只在编译阶段有效，即在编译过程当中，程序会正确的检验泛型结果。而编译成功后，class 文件是不包含任何泛型信息的

 

 

　　3.3 泛型类和泛型方法

 

public class Box<T> {
	private T box;
	public T getBox(T t){
		this.box = t;
		return t;
	}
	public void getType(){
		System.out.println("T的实际类型为："+box.getClass().getName());
	}
	
	public static void main(String[] args) {
		Box box = new Box();
		System.out.println(box.getBox(1));
		box.getType();
		
		System.out.println(box.getBox("Tom"));
		box.getType();
	}

}

 

　　输出结果为：

1
T的实际类型为：java.lang.Integer

Tom
T的实际类型为：java.lang.String

　　

　　3.4 泛型通配符

　　在泛型中，咱们能够用 ？ 来代替任意类型

 

　　　　 public List wildCard(List<?> list){
		
		return list;
	}

	public static void main(String[] args) {
		GenericTest gt = new GenericTest();
		//构造一个 Interger 类型的集合
		List<Integer> integer = new ArrayList<Integer>();
		integer.add(1);
		System.out.println(gt.wildCard(integer));
		//构造一个 String 类型的集合
		List<String> str = new ArrayList<String>();
		gt.wildCard(str);
		//构造一个 Object 类型的集合
		List<Object> obj = new ArrayList<Object>();
		obj.add(1);
		obj.add("a");
		System.out.println(gt.wildCard(obj));
		//构造一个 任意类型的 集合,这和 List<Object> 存放数据没啥区别
		List list = new ArrayList();
		gt.wildCard(list);
		
	}

 

　　

 

　　3.5 泛型的上限和下限

　　①、上限： 语法（？ extends className）,即只能为 className 或 className 的子类

//通配符的下限，只能是 Number 或 Number的子类
	public List wildCard(List<? extends Number> list){
		
		return list;
	}

	public static void main(String[] args) {
		GenericTest gt = new GenericTest();
		//构造一个 Interger 类型的集合
		List<Integer> integer = new ArrayList<Integer>();
		integer.add(1);
		System.out.println(gt.wildCard(integer));
		//构造一个 String 类型的集合
		List<String> str = new ArrayList<String>();
		//gt.wildCard(str);   //编译报错
		//构造一个 Object 类型的集合
		List<Object> obj = new ArrayList<Object>();
		obj.add(1);
		obj.add("a");
		//System.out.println(gt.wildCard(obj)); //编译报错
		
	}

　　①、下限： 语法（？ super className）,即只能为 className 或 className 的父类

//通配符的上限，只能是 Number 或 Number的父类
	public List wildCard(List<? super Number> list){
		
		return list;
	}

	public static void main(String[] args) {
		GenericTest gt = new GenericTest();
		//构造一个 Interger 类型的集合
		List<Integer> integer = new ArrayList<Integer>();
		integer.add(1);
		//System.out.println(gt.wildCard(integer));  //编译报错
		//构造一个 String 类型的集合
		List<String> str = new ArrayList<String>();
		//gt.wildCard(str);   //编译报错
		//构造一个 Object 类型的集合
		List<Object> obj = new ArrayList<Object>();
		obj.add(1);
		obj.add("a");
		System.out.println(gt.wildCard(obj)); 
	}

　　

四、泛型的注意事项

　　4.一、不能用基本类型来定义泛型，如 int、float

List<int> list = new ArrayList<int>(); //不能用 int 这样的基本类型定义泛型

　　关于这一点很好想明白，由于 集合中只能存放引用类型的数据，即便你存入基本类型的，Java仍是会经过自动拆箱和自动装箱机制将其转换为引用类型

　　

　　4.二、若是使用 ？ 接收泛型对象时，则不能设置被泛型指定的内容

List<?> list = new ArrayList<>();
		list.add("aa");  //错误，没法设置

　　

　　4.三、泛型方法的定义与其所在的类是不是泛型类是没有任何关系的，所在的类能够是泛型类，也能够不是泛型类

 

　　4.四、泛型类没有继承关系，即String 为 Object 类型的子类，则 List<String> 是 List<Object> 的子类这句话是错误的

缘由：假设上面那句话是正确的，那么因为泛型的产生机制就是放什么类型的数据进去，取出来的就是什么类型，而不用进行类型转换，这里把 String 类型的数据放入Object 类型的泛型集合中，那么取出来的应该就是 String 　　　　　类型的数据，而实际上取出来的是 Object 类型的数据，这与泛型的产生机制相违背，故不成立！