java 泛型

泛型的由来

要理解泛型，就要搞懂为什么要有泛型，它存在的合理性在哪？这里拿集合举例，集合就是一个筐子，没有泛型之前，这个筐子里可以放鸡、鸭、鱼，不同的种类放在一个筐子里不但混乱，而且拿的时候，会拿错，比如想从筐子里拿鹅却拿出来了鱼。类似下边的代码

    List list = new ArrayList();

    //各种类型杂糅在一起
    list.add(1);
    list.add("str");
    list.add(true);

    //大量的强转
    int i = (int) list.get(0);
    String s = (String) list.get(1);
    boolean flag = (boolean) list.get(2);

    //类型不安全，编译器不能发现错误，运行时才能发现
    //出现classclassexception
    String s2 = (String) list.get(0);

我们发现会有几个缺点
- 各种类型都可以在一个集合中，不方便处理
- 大量的强转，违背dont repeat yourself原则
- 类型不安全，运行时才能发现错误，不能提前发现

有了泛型后，可以分类处理了，鱼就要放在鱼的筐子里，鹅放在鹅的筐子里，鱼的筐子里不能放鹅，鹅的筐子里不能放鱼，拿的时候就肯定不会出错，即使放的时候放错了，编译器也会提醒你。类似下边的代码

    //整型的集合
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    int i = list.get(0);

    //字符串集合
    List<String> strList = new ArrayList<String>();
    strList.add("str");
    String s = strList.get(1);

    //如果放错了元素，编译错误
    //整型元素不能放入字符串集合，编译错误了...
    strList.add(1);

通过上边的对比，很明显，归类的筐子（泛型）更合理。

使用

现在我们设计一个类叫“搭档”，搭档可能分很多种，比如学生的搭档、工人的搭档、跳舞的搭档，如果没有泛型，我们可能需要分别设计同学搭档类、工人搭档类、跳舞搭档类，而有了泛型我可以设计一个搭档类，然后，使用泛型，比如

不使用泛型方法

//只举了学生搭档的代码，工人搭档、跳舞搭档类似
public class StudentParter<Student> {

    privat Student firsStudent;
    privat Student second;



    public StudentParter() {
        super();
    }


    public StudentParter(Student firsStudent, Student second) {
        super();
        Studenthis.firsStudent = firsStudent;
        Studenthis.second = second;
    }
}

泛型实现方法

public class Parter<T> {

    private T first;
    private T second;



    public Parter() {
        super();
    }


    public Parter(T first, T second) {
        super();
        this.first = first;
        this.second = second;
    }
    //getter and setter
}

Parter<Student> p = new Parter<Student, Student>(stu1, stu2);

Parter<Worker> p = new Parter<Worker, Worker>(w1, w2);

Parter<Dancer> p = new Parter<Dancer, Dancer>(d1, d2);

T是类型参数（Type parameter），按照约定是大写，经常用的有T、U、K、V，任意字母都可以，而且可以是多字母，创建对象时，我们可以使用指定的类型代替T。