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。