泛型
基础篇
一、为什么要泛型
1、原因
先看一个集合的例子（至于集合，前面有讲解，集合详解链接，不懂得可以先去看看那篇）
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import cn.hncu.bean.Person;
public class CollectionDemo {
public static void main(String[] args) {
Collection col = new ArrayList();
//增 add
col.add(new Person(23,"qwe")); //从jdk1.5以后，可以自动包装
col.add(new Person(22,"df"));
col.add(new Person(21,"af"));
col.add(new Person(24,"fgr"));
col.add(new Person(26,"et"));
col.add(new Person(27,"ghj"));//添加重复的元素，对于List是可以的，而对于Set是加不进的。
//删 remove 移除的是元素本身
//col.remove(3);//col.remove(2);
//改
//col.remove(1); col.add(4); //不合理，因为位置变了
//Object objs[] = col.toArray();
//col.clear();
//for(int i=0;i<objs.length;i++){
//if(objs[i].equals(1)){
//objs[i]=4;
//}
//col.add(objs[i]);
//}
Iterator<Object> it = col.iterator();
while(it.hasNext()){
Object obj = it.next();
if(obj instanceof Person){
System.out.println("Object:"+obj);
}else if(obj instanceof Integer){
System.out.println("int:"+obj);
}else{
System.out.println("Other:"+obj);
}
}
}
}
这个程序就是一个简单的集合，先输入和输出。咋一看没什么问题，就算放在myeclipse运行，结果也是对的。但是你会发现，在myeclipse中会出现很多黄色感叹号，这表示此程序有警告，也就是存在不安全因素。
会出现这些警告的原因是：集合是可以存放多种不同的种类的元素，但是在取出来的时候就不能确定放的时候到底是什么类型了。
书面解释：集合中可以存储任意类型对象，但是在取出时，如果要使用具体对象的特有方法时，需要进行向下转型，如果存储的对象类型不一致，在转型过程中就会出现ClassCastException异常。这样就给程序带来了不安全性。
在jdk1.5以后就有了解决方案——泛型技术：在存储元素时，就不允许存储不同类型的元素。存储了就编译失败。 所以就需要在存储元素时，在容器上明确具体的元素类型，这其实和数组定义很像。（数组定义：int[] ,double[] ,类名[],String[]等
等，看看写法应该能明白一二了吧，前面都明确了数组的类型）
要除去上面的黄色感叹号，只要改这两句即可：
Collection<Person> col = new ArrayList<Person>();
Iterator<Person> it = col.iterator();
2、好处
1）将运行时期的ClassCastException异常转移到了编译时期，进行检查，并以编译失败来体现。 这样有利于程序员尽早解决问题。
2）避免了向下转型(强转)的麻烦。
例：
import java.util.ArrayList;调用demo1()时，放的时候用了两个不同的类型元素，编译的时候没有报错，输出的时候，因为没给泛型，所以要强转，问题就出现在这，int型的8强转到string就会出错，也就是运行时出错。
import java.util.Iterator;
public class GenericDemo1 {
public static void main(String[] args) {
//demo1();
demo2();
}
private static void demo1() {
ArrayList aList = new ArrayList();
aList.add("abcd");
aList.add("abcewew");
aList.add("a333d");
aList.add(8);//编译没错，但运行时出错了。这是不安全的，对软件开发来讲，很不利。
Iterator it = aList.iterator();
while(it.hasNext()){
String str = (String) it.next();
str = str.toUpperCase();
System.out.println(str.length());
}
}
private static void demo2() {
ArrayList<String> aList = new ArrayList<String>();
aList.add("abcd");
aList.add("abcewew");
aList.add("a333d");
//aList.add(8);//加泛型后，该句会直接报错。泛型的好处(1)
Iterator<String> it = aList.iterator();
while(it.hasNext()){
String str = it.next();//加泛型后，不需要进行类型强转。泛型的好处(2)
str = str.toUpperCase();
System.out.println(str.length());
}
}
}
调用demo1()时，因为提前用了泛型，也就是规定了这个集合放什么样类型的数据，所以在写完add(8)的时候，就会直接报错。而且后面输出的时候，也不用再强转了。
总而言之，就是，java写了一个可以同时操作多种不同类型元素功能的容器，也就是集合，但是在运用的它的时候发现存在不安全因素，所以在运用它的时候又规定了只能用哪一种，也就是加的泛型。（如同数组）
二、泛型运用的原理
1、什么时候写泛型
只要在使用类或者接口时，该类或者接口在api文当描述时都带着<>，就需要在使用时定义泛型。 其实，泛型无非就是通过<>定义了一个形式参数，专门用于接收具体的引用类型。在使用时，一定要传递对应的实际参数类型。集合中泛型的应
用特别多见。
2、泛型的擦除
泛型技术是用于编译时期的技术，编译器会按照<>中的指定类型对元素进行检查，检查不匹配，就编译失败，匹配，就编译通过，通过后，生产的class文件中是没有泛型的，这就成为泛型的擦除。
3、泛型的补偿
运行时，可以根据具体的元素对象获取其具体的类型，并用该类型对元素进行自动转换。（也就是取出的时候，不用再用强转了）
三、泛型的使用
1、使用泛型的动机举例（以集合为例）：
对集合中存放元素的类型进行限定，防止后期出错。如果限定某个集合只能存放Person类对象（因为后期会把元素取出来当作Person对象来处理)，这样放其它类型的对象在编译时就会报错。相当于把一
个类泛化成很多个不同类型（具体化，限定化）的类。
泛型使用的代码如：
List<Person> persons = new ArrayList<Person>;
Map<String,String> m = new HashMap<String,String>;
2、泛型的含义
在定义泛型类或声明泛型类的变量时，使用尖括号来指定形式类型参数，称为类型形参，在调用时传递的实际类型成为类型实参。类型形参与类型实参之间的关系类似于形式方法参数与实际方法参数之间的关系，只是类型参数表示类型，而不
是表示值。
注意：当一个变量被声明为泛型时，只能被实例变量和方法调用，而不能被静态变量和方法调用。原因很简单，参数化的泛型是一些实例。静态成员是被类的实例和参数化的类所共享的，所以静态成员不应该有类型参数和他们关联。
四、泛型类（自定义）
1、定义成泛型类情况
当一个类要操作的引用数据类型不确定的时候，可以将该类型定义一个形参。用到的这类时，由使用者来通过传递类型参数的形式，来确定要操作的具体的对象类型。
这意味着在定义这个类时，需要在类上定义形参，用于接收具体的类型实参。这就是将泛型定义在类上，即泛型类。
例：
/*
* 泛型类的演示
*/
public class GenericDemo2 {
public static void main(String[] args) {
MyVessel<Worker> u = new MyVessel<Worker>();
//u.setObject(new Student());//不行，u中存放的是Worker，实参只能是Worker类型
u.setObject(new Worker());
Worker w = u.getObject();
System.out.println(w);
MyVessel<Student> v = new MyVessel<Student>();
//v.setObject(new Worker());//不行，实参只能是Student类型
}
}
class MyVessel<E>{ //从语法上讲把“E”取成别的名字如“QQ”也是可以的，但不规范。
private E obj;
public void setObject(E obj){
this.obj = obj;
}
public E getObject(){
return obj;
}
}
class Student{
String profession;
}
class Worker{
String company;
}
2、泛型类的好处
什么时候使用泛型类呢？只要类中操作的引用数据类型不确定的时候，就可以定义泛型类。 有了泛型类，省去了曾经的强转和类型转换异常的麻烦。
3、泛型方法的定义
1）与类的泛型捆绑
方法要操作的类型不确定的，但是和调用该方法的对象指定的类型是一致。
2）独立于类的泛型
方法要操作的类型不确定的，而且不一定和调用该方法的对象指定的类型是一致。
3）静态方法的泛型
静态方法不能访问类上定义的泛型，因为它没有对象。如果静态方法需要泛型，该泛型只能定义在方法上。
例：
/*
* 泛型方法演示
*/
public class GenericDemo3 {
public static void main(String[] args) {
Tool<String> t1 = new Tool<String>();
t1.show("abc");
//t1.show(new Integer(6));//不行，因为t1限定只能处理String型数据
Tool<Integer> t2 = new Tool<Integer>();
//t2.show("abc");//不行，因为t2限定只能处理Integer型数据
t2.show(new Integer(6));
String s = t1.myprint("aaa");
System.out.println(s);
int i = t1.myprint(new Integer(6));
//String s2 = t1.myprint(new Integer(6));//不行，因为方法上定义了泛型，且返回类型和方法的实参类型是一致的
System.out.println(i);
}
}
class Tool<W>{
//方法上的泛型和类的一致，或者说依赖于类的泛型 法1
public void show(W w){
System.out.println("show:"+w.toString());
}
//不带泛型，不安全。因为在调用方可以把该方法的返回值强转成其它类型，从而出现强转异常
public Object myprint0(Object a){
System.out.println("myprint:"+a);
return a;
}
//方法带泛型，但要求和类的泛型相互独立。可以限定返回类型和方法的实参相同，更安全，而且不用强转。 法2
public <A> A myprint(A a){
System.out.println("myprint:"+a);
return a;
}
//静态方法带泛型，泛型一定要独立于类，因为它没有对象。 法3
public static <A> A myprint2(A a){
System.out.println("myprint:"+a);
return a;
}
}
五、泛型接口
public class GenericDemo4 {
public static void main(String[] args) {
String str = new InterImpl().show("abc");
System.out.println("main:"+str);
//Integer i = new InterImpl2<Integer>().show(80);
InterImpl2<Integer> mm = new InterImpl2<Integer>();
//mm.show("aaa");//上一句加了泛型，因此这里会报告编译错误
int i = mm.show(80);
System.out.println(i);
}
}
interface Inter<V>{
public abstract V show(V v);
}
//实现泛型接口的类的定义。 方法中的参数类型和类声明实现接口时指定的类型一致，且已经确定为String!-----本例假设我们写这个类的时候知道该类就是专门处理String型数据的
class InterImpl implements Inter<String>{
@Override
public String show(String s) {
System.out.println(s);
return s;
}
}
//实现泛型接口的类的定义。 方法中的参数类型和类声明实现接口时指定的类型一致，但不确定!-----本例假设我们写这个类的时候不知道该类是处理什么类型的数据的，但有一点确定：声明类对象时指定什么类型(泛型的实参)，show方法就处理该类型
class InterImpl2<C> implements Inter<C>{
@Override
public C show(C s) {
System.out.println(s);
return s;
}
}
加强篇
一、泛型的通配符：?
当操作的不同容器中的类型都不确定的时候，而且使用的都是元素从Object类中继承的方法， 这时泛型就用通配符?来表示即可。（助理解的比方: 泛型中的多态应用)
import java.util.ArrayList;
import java.util.Iterator;
public class GenericAdvDemo1_1 {
public static void main(String[] args) {
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
ArrayList<Integer> a2 = new ArrayList<Integer>();
a2.add(100);
a2.add(6);
a2.add(8);
//printColl(a1);//此方法只能输出a1
//printColl2(a2);//<span style="font-family: Arial, Helvetica, sans-serif;">此方法只能输出a2</span>
printColl3(a1);//此方法既能输出a1也能输出a2，这就是泛型的通配符的用途
printColl3(a2);
}
/* 该解决方案从思路上讲是对的，但在语法上通不过。因为这是运行期的多态，而我们的泛型在编译期
public static void printColl(ArrayList<Object> a){
Iterator<Object> it = a.iterator();
while(it.hasNext()){
Object str = it.next();
System.out.println(str);
}
}
*/
public static void printColl(ArrayList<String> a){
Iterator<String> it = a.iterator();
while(it.hasNext()){
String str = it.next();
System.out.println(str);
}
}
public static void printColl2(ArrayList<Integer> a){
Iterator<Integer> it = a.iterator();
while(it.hasNext()){
Integer str = it.next();
System.out.println(str);
}
}
public static void printColl3(ArrayList<?> a){
Iterator<?> it = a.iterator();
while(it.hasNext()){
Object str = it.next();
System.out.println(str); //元素只能调用从Object类中继承的方法
}
}
}
二、泛型的限定
对操作的类型限制在一个范围之内。比如：定义一个功能，只操作Person类型或者Person的子类型。这时可以用:
? extends E:接收E类型或者E的子类型。这就是上限。
import java.util.ArrayList;
import java.util.Iterator;
public class GenericAdvDemo3 {
public static void main(String[] args) {
ArrayList<Person> a1 = new ArrayList<Person>();
a1.add(new Person("Jack1",20));
a1.add(new Person("Jack3",23));
a1.add(new Person("Jack2",22));
ArrayList<Integer> a2 = new ArrayList<Integer>();
a2.add(100);
a2.add(6);
a2.add(8);
ArrayList<Student> a3 = new ArrayList<Student>();
a3.add(new Student("aa",10));
a3.add(new Student("bb",20));
a3.add(new Student("cc",30));
printColl(a1);
//printColl(a2);
printColl(a3);
}
/*自己写带上限的泛型方法*/
public static void printColl(ArrayList<? extends Person> a){
Iterator<? extends Person> it = a.iterator();
while(it.hasNext()){
Person p = it.next();
System.out.println(p.getName()); //元素只能调用从Person类中继承的方法
}
}
}
? super E: 接收E类型或者E的父类型。 这就是下限。
API查看：Collection中的addAll()方法中的泛型就是一个上限的运用。TreeSet类的构造方法就分别用了上限和下限。
一般情况下:
只要是往容器中添加元素时，使用上限。 ? extends E
只要是从容器中取出元素时，是用下限。 ? super E
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class GenericAdvDemo2 {
public static void main(String[] args) {
//演示上限，应用场合：往集合中放元素
//extendsEDemo();
//演示下限，应用场合：从集合中取元素
superEDemo();
}
private static void extendsEDemo() {
Collection<Person> coll = new ArrayList<Person>();
coll.add(new Person("Jack",23));
coll.add(new Person("Tom",124));
coll.add(new Person("Rose",25));
Collection<Student> coll2 = new ArrayList<Student>();
coll2.add(new Student("Jack2",223));
coll2.add(new Student("Tom2",224));
coll2.add(new Student("Rose2",225));
TreeSet<Person> ts = new TreeSet<Person>(coll);
ts.add(new Student("aaa",100));
ts.addAll(coll2);//上限:coll2中的元素类型(泛型)必须是Person或Person的子类
Iterator<Person> it = ts.iterator();
while(it.hasNext()){
Person p = it.next();
System.out.println(p.toString());
}
//TreeSet<Student> ts2 = new TreeSet<Student>(coll2);
//Iterator<Student> it2 = ts2.iterator();
//while(it2.hasNext()){
//Student p = it2.next();
//System.out.println(p.toString());
//}
}
private static void superEDemo() {
//TreeSet<Student> ts = new TreeSet<Student>( new CompByName1() );
TreeSet<Student> ts = new TreeSet<Student>( new CompByName() );
ts.add(new Student("lisi1",21));
ts.add(new Student("lisi3",23));
ts.add(new Student("lisi2",22));
Iterator<Student> it = ts.iterator();
while(it.hasNext()){
Student p = it.next();
System.out.println(p.toString());
}
//TreeSet<Worker> ts2 = new TreeSet<Worker>( new CompByName2() );
TreeSet<Worker> ts2 = new TreeSet<Worker>( new CompByName() );
ts2.add(new Worker("lisi21",21));
ts2.add(new Worker("lisi23",23));
ts2.add(new Worker("lisi22",22));
Iterator<Worker> it2 = ts2.iterator();
while(it2.hasNext()){
Worker p = it2.next();
System.out.println(p.toString());
}
}
}
@SuppressWarnings("rawtypes")
class Person implements Comparable{
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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 compareTo(Object o) {
Person p = (Person) o;
return this.age-p.age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
class Student extends Person{
String profession;
public Student(String name, int age) {
super(name, age);
}
}
class CompByName1 implements Comparator<Student>{
@Override
public int compare(Student s1, Student s2) {
return s1.getName().compareTo(s2.getName());
}
}
class Worker extends Person{
String company;
public Worker(String name, int age) {
super(name, age);
}
}
class CompByName2 implements Comparator<Worker>{
@Override
public int compare(Worker s1, Worker s2) {
return s1.getName().compareTo(s2.getName());
}
}
//利用泛型中的“Comparator<? super E> comparator”即下限特性，做一个通用的比较器(比较所有Person及其子类对象0
class CompByName implements Comparator<Person>{
@Override
public int compare(Person s1, Person s2) {
return s1.getName().compareTo(s2.getName());
}
}