13、泛型

1、为什么需要泛型
2、什么是泛型
3、自定义泛型接口、泛型类
4、通配符
5、泛型方法
6、泛型的嵌套使用
GenericDemo

1、为什么需要泛型

List list = new ArrayList();
list.add(“vince”);
list.add(10);
list.add(new Person());
list.add(obj);

List中可以添加任意类型，因为参数是Object，这样一个我们在遍历这个集合时：

for(int i=0;i<list.size();i++){
    //此处需要判断元素的类型， 才能执行不同的操作
}

以上操作主要存在两个问题：

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

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

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

2、什么是泛型

JDK 1.5之后出现了新的技术 —— 泛型（Generic），此技术的最大特点是类中的属性的类型可以由外部决定。泛型，即“ 参数化类型” 。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

List<String> list = new ArrayList<String>();//... = new ArrayList<>(); //... = new ArrayList();
list.add("vince");
list.add("bin");
//list.add(100); // 提示编译错误
for (int i = 0; i < list.size(); i++) {
    String name = list.get(i); // 2
    System.out.println("name:" + name);
}

3、自定义泛型接口、泛型类

泛型类和方法定义：

class Node<T>{
    private T data;
    public Node(){}
    public Node(T data){
        this.data = data;
    }
    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
}

interface Shopping{public void shopping(T name);}

在泛型接口、泛型类和泛型方法的定义过程中，我们常见的如T、 E、 K、 V等形式的参数常用于表示泛型形参，由于接收来自外部使用时候传入的类型实参，从编码的角度也称为参数化类型了。

泛型只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦除，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

4、通配符

问题：

Node<Number> c1 = new Node<Number>();
Node<Integer> c2 = new Node<Integer>() ;
c1 = c2; // 此时无法转换
public static void getData(Node<Number> data) {
    System.out.println("data :" + data.getData());
}

此时，我们可以使用通配符来解决

“ ?” 表示的是可以接收任意的泛型类型，但是只是接收输出，并不能修改。

public static void getData(Node<?> data) {
    System.out.println("data :" + data.getData());
}

泛型上限就指一个的操作泛型最大的操作父类，例如，现在最大的上限设置成“ Number” 类型，那么此时，所能够接收到的类型只能是Number及其子类（Integer）。
泛型的上限通过以下的语法完成：
? extends 类

public static void getUpperNumberData(Node<? extends Number> data){ //只能是Number类及其子类
    System.out.println("data :" + data.getData());
}

泛型的下限指的是只能设置其具体的类或者父类。设置的语法如下：
? super 类

5、泛型方法

泛型除了在类中定义之外，还可以在方法上定义，而且在方法上使用泛型，此方法所在的类不一定是泛型的操作类。

定义一个方法，实现任意类型数组中两个位置值的调换

public static <T> T[] func(T[] array,int i,int t){
    T temp = array[i];
    array[i] = array[t];
    array[t] = temp;
    return array;
}

6、泛型的嵌套使用

在使用集合Map的时候，我们可以这样遍历：

Set<Entry<Integer, String>> entrys = map.entrySet();

GenericDemo

import org.junit.Test;
import java.util.*;
public class GenericDemo {
    @Test
    public void test5(){
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"vince");
        map.put(2,"tom");
        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        for(Map.Entry entry: entrySet){
            System.out.println(entry.getKey()+"-"+entry.getValue());
        }
    }
    @Test
    public void test4(){
        String[] arrays = {"vince","jack","Tom","lily"};
        String[] strs = func(arrays, 0, 1);
        System.out.println(Arrays.toString(strs));
    }
    @Test
    public void test3(){
        Node<Number> n1 = new Node<>(10);
        Node<Integer> n2 = new Node<>(20);
//        getData(n1);
//        getData(n2);//报错
//        n1 = n2;  不支持
//        getData2(n2);
        getUpperNumberData(n1);
        getUpperNumberData(n2);
    }
    public static void getData(Node<Number> node){
        System.out.println(node.getData());
    }
    /**
     * 使用通配符定义泛型类型，此时只能输出，不能修改
     * @param node
     */
    public static void getData2(Node<?> node){
//        node.setData(20);
        System.out.println(node.getData());
    }
    public static void getUpperNumberData(Node<? extends Number> data){
        //只能是Number类及其子类
        System.out.println("data :" + data.getData());
    }
    /**
     * 泛型方法
     * @param array
     * @param i
     * @param t
     * @param <T>
     * @return
     */
    public static <T> T[] func(T[] array,int i,int t){
        T temp = array[i];
        array[i] = array[t];
        array[t] = temp;
        return array;
    }
    @Test
    public void test2(){
        Node<String> stringNode = new Node<>("vince");
        Node<Integer> intNode = new Node<>(10);
        System.out.println(stringNode.getData());
        System.out.println(intNode.getData());
    }
    @Test
    public void test1(){
        List<String> list = new ArrayList<>();
        list.add("vince");
        //list.add(10);
        //list.add(new Object());
        for (int i = 0; i < list.size(); i++) {
            //如果我们不能确定集合中的元素类型，那么我们需要在处理元素时
            //要判断元素的类型，才能做相应的操作
        }
    }
}

1、 为什么需要泛型

2、什么是泛型

3、 自定义泛型接口、 泛型类

4、 通配符