Java泛型

一. 泛型概念的提出（为什么需要泛型）？

首先，我们看下下面这段简短的代码:

public static void main(String[] args) {
        List list = new ArrayList();
            list.add("hello");
            list.add("world");
            list.add(100);

        //遍历集合
        Iterator it = list.iterator();
        while (it.hasNext()){
            String s = (String)it.next();//1
            System.out.println(s);
        }
    }

定义了一个List类型的集合，先向其中加入了两个字符串类型的值，随后加入一个Integer类型的值。这是完全允许的，因为此时list默认的类型为Object类型。在之后的循环中，由于忘记了之前在list中也加入了Integer类型的值或其他编码原因，很容易出现类似于//1中的错误。因为编译阶段正常，而运行时会出现“java.lang.ClassCastException”异常。因此，导致此类错误编码过程中不易发现。

在如上的编码过程中，我们发现主要存在两个问题：

1.当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，该对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。

2.因此，//1处取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现“java.lang.ClassCastException”异常。

那么有没有什么办法可以使集合能够记住集合内元素各类型，且能够达到只要编译时不出现问题，运行时就不会出现“java.lang.ClassCastException”异常呢？答案就是使用泛型。

二.什么是泛型？

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
下面看一个例子

 public static void main(String[] args) {
     
        List<String> list = new ArrayList<String>();
                list.add("hello");
                list.add("world");
                //list.add(100);   // 1  提示编译错误

        //遍历集合
        Iterator<String> it  = list.iterator();
        while (it.hasNext()){
            String s = it.next();// 2 无须进行强制类型转换
            System.out.println(s);
        }
    }

采用泛型写法后，在//1处想加入一个Integer类型的对象时会出现编译错误，通过List，直接限定了list集合中只能含有String类型的元素，从而在//2处无须进行强制类型转换，因为此时，集合能够记住元素的类型信息，编译器已经能够确认它是String类型了。

三.泛型类

泛型类的定义格式: 修饰符 class 类名 <类型>{}
范例：public class Generic < T> {}
此处T可以随便为任意标识，常见的如 T,E,K,V 等

public static void main(String[] args) {
        Student student = new Student();
        student.setName("凯里欧文");
        System.out.println(student.getName());

        Teacher teacher = new Teacher();
        teacher.setAge(29);
        System.out.println(teacher.getAge());
    }
    
  class Teacher {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

class Student {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}//以上为非泛型类写法
----------------------------------------------
//以下为泛型类写法
public static void main(String[] args) {
      
        Generic01<String> g1 = new Generic01<>();
        g1.setT("凯里欧文");
        System.out.println(g1.getT());

        Generic01<Integer> g2 = new Generic01<>();
        g2.setT(29);
        System.out.println(g2.getT());
    }
    //泛型类
public class Generic01 <T>{
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}    

在这段代码中，泛型类Generic01 代替了类Student和类Teacher。

四，泛型方法

泛型方法的格式：修饰符 <类型> 返回值类型 方法名（类型 变量名）{ }
范例：public < T> void show(T t) { }

public static void main(String[] args) {
      
        Generic g = new Generic();
        g.show("凯里欧文");// 1
        g.show(29);// 2
    }
    
 public class Generic {
  
    public <T> void show(T t){
    }
}

在这段代码中1，2 处的类型不同，但是依然能够调用。

五，泛型接口

泛型接口的定义格式：修饰符 interface 接口名 <类型>{}
范例：public interface Generic {}

public class GenericDemo {
    public static void main(String[] args) {
    	GenericI<String> i = new GenericImpl<>();
        i.show("凯里欧文");
    	
        GenericI<Integer> i1 = new GenericImpl<>();
        i1.show(29);
    }
}
//接口
public interface GenericI<T> {
    void show(T t);
}
//对应实现类
public class GenericImpl<T> implements GenericI<T> {
    
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

在使用泛型类时，虽然传入了不同的泛型实参，但并没有真正意义上生成不同的类型，传入不同泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型（本实例中为Generic），当然，在逻辑上我们可以理解成多个不同的泛型类型。

究其原因，在于Java中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

六，类型通配符

为了表示各种泛型List的父类，可以使用类型通配符

类型通配符:

1.List<?>:表示元素类型末知的List,它的元素可以匹配任何的类型

这种带通配符的List仅表示它是各种泛型List的父类， 并不能把元素添加到其中

2.如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限类型通配符上限: <? extends类型>

List<? extends Number>:它表示的类型是Number或者其子类型

3.除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限类型通配符下限: <? super类型>

List<? super Number>:它表示的类型是Number或者其父类型

public class GenericDemo {
    public static void main(String[] args) {
      
   //类型通配符: <?>

        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();

//类型通配符上限: <? extends 类型>

       // List<? extends Number> list4 = new ArrayList<Object>();
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();

//类型通配符下限:<? super 类型 >

        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
       // List<? super Number> list9 = new ArrayList<Integer>();
    }
}

类型通配符一般是使用 ? 代替具体的类型实参。注意了，此处是类型实参，而不是类型形参！且List<?>在逻辑上是List、List…等所有List<具体类型实参>的父类。类型通配符上限通过形如List<? extends Number>形式定义，相对应的，类型通配符下限为List<? super Number>形式，其含义与类型通配符上限正好相反由此，我们依然可以定义泛型方法，来完成此类需求

对于泛型，最主要的还是需要理解其背后的思想和目的。