Java学习之泛型

泛型，也许这个词造出来就不是用来让我顾名思义的。所以今天来挖挖泛型的背景和其使用方法。
第一个问题Java在设计时为什么需要泛型？
集合本身来讲是可以存储任何类型的对象；但这又造成一个麻烦，取的时候比较费事。一般情况下，我们都是需要集合只存储一种数据类型。Java为我们提供了一种方式，可以保证一个集合在定义时，就明确里面装什么类型的。这就叫：泛型。
那么问题来了，泛型咋用呢？
定义泛型的语法格式：
集合类类型<引用数据类型> 集合变量名 = new 集合类类型<引用的数据类型>();
格式1：(推荐使用) ArrayList strList = new ArrayList();
这个集合中只能存储String类型，如果想存储其它类型，在编译时就被阻止；
格式2： ArrayList strList = new ArrayList();

使用泛型集合存储自定义对象;

import java.util.List;
import java.util.Vector;
package com.mytest.demo21_使用泛型集合存储自定义对象;

public class Student {
	private String name;
	private int age;
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Student() {
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}
public class Demo {
	public static void main(String[] args) {
		List<Student> stuList = new Vector<Student>();
		
		Student stu1 = new Student("邓超",20);
		Student stu2 = new Student("李晨",22);
		Student stu3 = new Student("AngelaBaby",23);
		
		stuList.add(stu1);
		stuList.add(stu2);
		stuList.add(stu3);
		
		//遍历取出
		for(int i = 0;i < stuList.size() ; i++){
		 Student stu = stuList.get(i);
		 System.out.println(stu.getName() + "," + stu.getAge());
		}		
	}
}

例如：集合类，都支持泛型
泛型类：类本身支持泛型的语法
让我们的MyArrayList支持泛型
1.在类名后加：<变量名>
变量名：可以是大写，可以小写，可以多个，用逗号隔开
这个变量名就类似于一个说明：它说明一个类型；在使用是的编译器确定。

public class MyArrayList<T> {
	private Object[] objArray = new Object[10];
	private int count = 0;
	boolean add(T obj){
		objArray[count] = obj;
		count++;
		return true;
	}	
}

public class Demo {
	public static void main(String[] args) {
		MyArrayList<String> list = new MyArrayList<String>();
		list.add("10");
	//	list.add(20);
		
	}
}

泛型的通配符：
1.泛型通配符<?>
任意类型，如果没有明确，那么就是Object以及任意的Java类了
2.? extends E
向下限定，E及其子类
一：引用可以指向什么类型的对象：E的子类泛型的集合；
二：不能向集合中添加任何类型的元素，因为不确定是哪个E的子类类型；
三：取出时必须使用E或者E的父类型接收;
3.? super E
向上限定，E及其父类
一：引用可以指向什么类型的对象：任何B及B的父类类型的集合
二：可以添加什么类型的元素？任何的B及B的子类对象都可以；
三：取出来的是什么类型的？任何类型都不可以；

class A{}
class B extends A{}
class C extends B{}
class D extends B{}
public class Demo {
	public static void main(String[] args) {
		List<?> list1 = new ArrayList();
		List<?> list2 = new ArrayList<Object>();
		List<?> list3 = new ArrayList<Student>();
		List<?> list4 = new ArrayList<String>();
		List<?> list5 = new ArrayList<Integer>();
		 /* 因为List<?>的声明，不确定是什么类型，所以什么类型都不可以添加；
		 但是这个引用可以指向任何类型的集合；
		 一般不用来存东西；
		 一般用于方法的返回值，用于从里面取东西；*/
		list5.add("aaa");
		list5.add(20);
		list5.add(new Student("张三",20));
		
		//2.? extends E:
		List<? extends B> list6 = new ArrayList<>();
		//一：引用可以指向什么类型的对象：B的子类泛型的集合；
		list6 = new ArrayList<B>();
		list6 = new ArrayList<C>();
	//	list6 = new ArrayList<A>();//NO
	
		//二：可以添加什么类型的元素？
		//使用? extends E 不能向集合中添加任何类型的元素，因为不确定是哪个B的子类类型；
		/*list6.add(new B());//No
		list6.add(new C());//No
		list6.add(new A());//No
		list6.add("aaa");//No
		list6.add(20);//No
		list6.add(new Object());//No
		*/
		
		//三：取出来的是什么类型的？必须使用B或者B的父类型接收
		A a = list6.get(0);//OK的，多态
		B b = list6.get(0);//OK的，多态
	//	C c = list6.get(0);//No
		
		//? super E
		//一：引用可以指向什么类型的对象：任何B及B的父类类型的集合
		List<? super B> list7 = new ArrayList<>();
		list7 = new ArrayList<A>();
		list7 = new ArrayList<B>();
	//	list7 = new ArrayList<C>();//No
	//	list7 = new ArrayList<D>();//No
		
		//二：可以添加什么类型的元素？任何的B及B的子类对象都可以；
	//	list7.add(new A());//No
		list7.add(new B());//OK的，多态
		list7.add(new C());//OK的，多态
		
		//三：取出来的是什么类型的？任何类型都不可以
		/*A a1 = list7.get(0);//No
		B b1 = list7.get(0);//No
		C c1 = list7.get(0);//No
		D d1 = list7.get(0);//No
		*/
    }
}

下面我们来扒扒这个泛型在使用过程中可能会出现的一些错误，其中有哪些是理解易出错还是压根就难以理解，就简单举个栗子吧！
兼容性（也就是哪些写法是可以通过编译的）：

Collection c = new Vector();//考虑到对以前代码的兼容性，编译器是可以通过的。
参数化类型可以引用一个原始类型的对象，编译时会报告警告。

Collection c = new Vector();//原来的方法接收一个集合参数，新的类型也要能传进去。原始类型可以引用一个参数化类型的对象，编译时会报告警告。

Vector v = new Vector( ); //错误！
如果以后从v中取出的对象当作String用，而v实际指向的对象中可以加入任意的类型对象。

Vector v = new Vector( ); //错误！
如果以后可以向v中加入任意的类型对象，而v实际指向的集合中只能装String类型的对象
编译器不允许创建泛型变量的数组。

Vector vectorList[ ] = new Vector[10]; //错误！
在创建数组实例时，数组的元素不能使用参数化的类型。

经过这些例子的练手，我可以更好地理解出泛型的设计目的了。
总体而言，泛型是对Java语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。当没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，更加方便。