13章、Java泛型——泛型的定义与作用

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

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<T>{	
		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 类

6、泛型的嵌套使用

在使用集合Map的时候，我们可以这样遍历：
Set<Entry<Integer, String>> entrys = map.entrySet();

package com.vince;

import org.junit.Test;

import java.util.*;

/**
 * Created by vince on 2017/6/15.
 */
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","yom"};
        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++) {
            //如果我们不能确定集合中的元素类型，那么我们需要在处理元素时
            //要判断元素的类型，才能做相应的操作

        }
    }
}

package com.vince;

/**
 * Created by vince on 2017/6/15.
 * 泛型类
 * T : 参数化类型，在实际使用时才会指定具体的类型
 * 泛型只作用于编译期检查，在编译后，会被檫除
 */
public 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;
    }
}