泛型

一、概念

是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型，泛型也可以看成是一个变量，用来接收数据类型。

E e:Element 元素
T t:Type 类型

ArrayList集合在定义的时候，不知道集合中都会存储什么类型的数据，所以类型使用泛型，ArrayList源码：

public class ArrayList<E>{
    //ArrayList中的add()方法：  
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    //ArrayList中的get()方法：   
    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }

}

创建集合对象的时候，就会确定泛型的数据类型，例如：

    ArrayList<String> list = new ArrayList<String>();

E可以看成是一个变量，数据类型会作为参数传递，把String赋值给泛型E，那么之前ArrayList中的泛型就会变成String类型，泛型同样可以赋值为自定义数据类型

public class ArrayList<String>{
    //ArrayList中的add()方法：  
    public boolean add(String e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    //ArrayList中的get()方法：   
    public String get(int index) {
        rangeCheck(index);
        return elementData(index);
    }

}

二、与传统Object类型的优缺点

创建集合对象的时候，不使用泛型：

好处：
    不使用泛型，默认的数据类型就是Object类型，可以存储任意类型的数据
弊端：
    不安全，会引发异常、
例子：
        //定义一个ArrayList集合，不使用<>括号表示不使用泛型，即集合中的元素为Object类型
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);
        //使用迭代器遍历list集合
        //获取迭代器
        Iterator iterator = list.iterator();
        //使用迭代器中的方法hasNext()和next()遍历集合
        while (iterator.hasNext()){
            //取出元素也是Object类型
            Object obj = iterator.next();
            //想要使用String类特有的方法，如length()获取字符串的长度，需要向下转型
            String s = (String)obj;
            System.out.println(s.length());
        }

打印结果，会出现类转换异常

---

创建集合对象的时候，使用泛型：

好处：
    1.避免了类型转换异常的麻烦，存储的是什么类型，取出的就是什么类型
    2.把运行期异常（代码运行之后会抛出的异常），提升到了编译期（写代码的时候会报错）
弊端：
    泛型是什么类型，就只能存储什么类型的数据，这个弊端几乎可以忽略
例子：
        //定义一个ArrayList集合，使用泛型
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        list.add(1);

存String类型之外的数据类型，则立马报错

三、泛型的定义与使用

泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。讲数据类型作为参数进行传递。

1、定义一个含有泛型的类

创建一个正常类

/**
 * 正常创建一个类
 */
public class GenericClass {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

创建一个泛型类

/**
 * 定义一个含有泛型的类，模拟ArrayList集合
 * 泛型是一个未知的数据类型，当我们不确定使用什么数据类型的时候，就可以使用泛型
 * 泛型可以接受任意的数据类型，可以使用Integer，String，Student...
 * 创建对象的时候确定泛型的数据类型
 */
public class GenericClass2<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

进行测试

/**
 * 泛型测试类
 */
public class DemoTest {
    public static void main(String[] args) {
        //不写泛型默认为Object类型
        GenericClass genericClass = new GenericClass();
        genericClass.setName("只能是字符串");
        Object object = genericClass.getName();

        //创建GenericClass对象，泛型使用Integer类型
        GenericClass2<Integer> genericClass2 = new GenericClass2<>();
        genericClass2.setName(1);

        //创建GenericClass对象，泛型使用String类型
        GenericClass2<String> genericClass3 = new GenericClass2<>();
        genericClass3.setName("泛型使用了字符串，所以这里是字符串");
    }
}

2、定义一个含有泛型的方法

/**
 * 定义一个普通类
 */
public class GenericMethod {
    /**
     * 定义一个带有泛型的方法
     * 含有泛型的方法的定义格式：
     *      修饰符 <泛型> 返回值类型 方法名(参数列表){//参数列表中使用泛型，如果返回值类型前面没有定义泛型，则不能使用泛型
     *          方法体
     *      }
     * @param <E> 泛型类型的参数
     */
    public <E> void method1(E e){
        System.out.println("普通方法");
        System.out.println(e);
    }

    /**
     * 定义一个带有泛型的静态方法
     * @param <E> 泛型类型的参数
     */
    public static <E> void method2(E e){
        System.out.println("静态方法");
        System.out.println(e);
    }
}

使用

/**
 * 泛型测试类
 */
public class DemoTest {
    public static void main(String[] args) {
        GenericMethod genericMethod = new GenericMethod();
        //调用普通方法，参数为String类型
        genericMethod.method1("张三");
        //调用普通方法，参数为Integer类型
        genericMethod.method1(1);
        //使用对象调用静态方法，参数为String类型
        genericMethod.method2("李四");
        //使用类调用静态方法，参数为Integer类型
        GenericMethod.method2(10);
    }
}

结果

3、定义一个含有泛型的接口

接口同样可以使用泛型

/**
 * 定义一个使用泛型的接口
 * @param <I>
 */
public interface GenericInterface<I> {
    public abstract void method(I i);
}

实现接口的第一种方式

/**
 * 含有泛型接口的第一种使用方式：
 *      在实现的时候就指定泛型的数据类型
 * 实例
 *      迭代器源码
 *          public interface Iterator<E>
 *      Scanner类源码
 *          public final class Scanner implements Iterator<String>, Closeable
 */
public class GenericInterfaceImpl1 implements GenericInterface<String>{
    /**
     * 指定数据类型为String类型，重写的方法的参数也会改变
     * @param s
     */
    @Override
    public void method(String s) {
        System.out.println("重写的方法");
        System.out.println(s);
    }
}

测试

/**
 * 泛型测试类
 */
public class DemoTest {
    public static void main(String[] args) {
        GenericInterfaceImpl1 genericInterfaceImpl1 = new GenericInterfaceImpl1();
        genericInterfaceImpl1.method("张三");
    }
}

实现接口的第二种方式

/**
 * 实现使用泛型的接口时不指定数据类型，在创建对象的时候再指定
 * @param <I> 
 */
public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
    /**
     * 重写方法
     * @param i 
     */
    @Override
    public void method(I i) {
        System.out.println("重写方法");
        System.out.println(i);
    }
}

测试

/**
 * 泛型测试类
 */
public class DemoTest {
    public static void main(String[] args) {
        GenericInterfaceImpl2<String> stringGenericInterfaceImpl2 = new GenericInterfaceImpl2<String>();
        stringGenericInterfaceImpl2.method("王二麻子");
        GenericInterfaceImpl2<Integer> integerGenericInterfaceImpl2 = new GenericInterfaceImpl2<>();
        integerGenericInterfaceImpl2.method(2);
    }
}

四、泛型的通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示，但是一旦使用了泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身的方法无法使用

1、通配符的基本使用

如果不使用高级用法，那么接受的时候使用的是什么泛型，传进来的也必须是什么泛型，Object类型也一样，这个时候，我们就可以使用通配符 ？ 来接

/**
 * 泛型测试类
 */
public class DemoTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(2);
        //遍历集合
        printArray(list);
        printArray(integers);
    }

    /**
     * 定义一个可以遍历所有ArrayList集合的方法
     * @param list 
     */
    public static void printArray(ArrayList<?> list){
        //获取迭代器
        Iterator iterator = list.iterator();
        //使用迭代器遍历集合
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

测试

2、通配符的高级用法–受限泛型

设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置，但是在Java的泛型中可以指定一个泛型的上下限。

泛型的上限：

• 格式：类型名称<? extends 类> 对象名称
• 意义：只能接受该类型及其子类

泛型的上限：

• 格式：类型名称<? super 类> 对象名称
• 意义：只能接受该类型及其父类型

具体用法

/*
 * 泛型的上限限定
 */
public class GenericClass3 {
    public static void main(String[] args) {
        Collection<String> stringCollection = new ArrayList<>();
        Collection<Integer> integerCollection = new ArrayList<>();

        //Integer extends Number extends Object
        //String extends Object
        //因为String类型，不是Number类型的父类，也不是它的子类，更和它没关系，所以，1和3报错
        //而Integer是Number类的子类，所以2没错，而4报错
        getElement1(stringCollection);//1
        getElement1(integerCollection);//2
        getElement1(stringCollection);//3
        getElement2(integerCollection);//4

    }

    /*
     * 只接受泛型类型为Number
     * @param e
     */
    public static void getElement1(Collection<? extends Number> e){}
    public static void getElement2(Collection<? super Number> e){}
}

五、类型擦除

Java语言的泛型采用的是擦除法实现的伪泛型，泛型信息（类型变量、参数化类型）编译之后通通被除掉了。使用擦除法的好处就是实现简单、非常容易Backport，运行期也能够节省一些类型所占的内存空间。而擦除法的坏处就是，通过这种机制实现的泛型远不如真泛型灵活和强大。Java选取这种方法是一种折中，因为Java最开始的版本是不支持泛型的，为了兼容以前的库而不得不使用擦除法。

泛型类型只有在静态类型检查期间才出现，在此之后，程序中的所有泛型类型都将被擦除，替换成它们非泛型上界。参考文章
验证：

/**
 * 泛型测试类
 */
public class DemoTest {
    public static void main(String[] args) {
        Class stringsClass = new GenericClass2<String>().getClass();
        Class integersClass = new GenericClass2<Integer>().getClass();
        //这两个看起来是完全不一样的类
        System.out.println(integersClass == stringsClass);
    }
}

输出结果：