为什么要添加泛型？

List list = new ArrayList();
list.add("vince");
list.add(10);
list.add(new Object());
for(int i=0;i<list.length();i++){
}

以上操作主要存在两个问题：
1、当我们将一个对象放入集合中时，集合不会记住此对象的类型，当再次从集合中取出此对象时，该对象的编译类型编程了Object类型，但其运行时类型依然为其本身类型。
2、因此，取出集合元素时需要人为的强制类型转换到具体的目标类型，且很容易出现"java.lang.ClassCastException"异常
为了解决这种麻烦，答案就是：使用泛型

自定义泛型类

/**
 * 自定义泛型类
 * 1、T：参数化类型，在实际使用时才会指定具体的类型
 * 2、泛型只作用于编译器检查，在编译后会被擦除
 */

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;
    }
}


import org.junit.Test;
//调用这个泛型类，就可以传入自己想要的任何类型
public class TestNode {
    @Test
    public void testNode() {
        Node<String> strNode = new Node<>("vince");
        Node<Integer> intNode = new Node<>(10);
        System.out.println(strNode.getData());
        System.out.println(intNode.getData());
    }
}
结果：
vince
10

import org.junit.Test;
//调用这个泛型类，就可以传入自己想要的任何类型
public class TestNode {
    //举例1：
    @Test
    public void testNode() {
        Node<String> strNode = new Node<>("vince");
        Node<Integer> intNode = new Node<>(10);
        System.out.println(strNode.getData());
        System.out.println(intNode.getData());
    }


    //举例2：
    public static void getdata(Node<Number> node){
        System.out.println(node.getData());
    }

    @Test
    public void  node(){
        Node<Number> n1 = new Node<>(10);
        Node<Integer> n2 = new Node<>(20);
//        getdata(n1);
//        getdata(n2);  //不支持，会报错，因为方法getdata已经指定了参数的泛型类型为Number了
    }


    //举例3：使用通配符 ？  定义泛型的类型；此时只能输出，不能对属性修改设置
    public static void getdata2(Node<?> node){
        System.out.println(node.getData());
        //node.setData(10); //使用了通配符？定义了泛型的类型，此时不能对属性修改设置
    }

    @Test
    public void  node2(){
        Node<Number> n1 = new Node<>(10);
        Node<Integer> n2 = new Node<>(20);
        getdata2(n1);
        getdata2(n2);  //这样就可以输出任意的类型
    }

    //举例4：
    //泛型上限：表明只能使用其定义类型和及其子类，语法：? extends Number
    public static void getdata3(Node<? extends Number> node){
        System.out.println(node.getData());
        //node.serData(10); //使用了通配符？定义了泛型的类型，此时不能对属性修改设置
    }
    @Test
    public void  node3(){
        Node<Number> n1 = new Node<>(10);
        Node<Integer> n2 = new Node<>(20);
        getdata3(n1);
        getdata3(n2);  //这样就可以输出任意的类型
    }

    //举例5：
    //泛型下限：表明只能使用其定义类型和及其父类。语法：? super Integer
    public static void getdata4(Node<? super Integer> node){
        System.out.println(node.getData());
        //node.serData(10); //使用了通配符？定义了泛型的类型，此时不能对属性修改设置
    }
    @Test
    public void  node4(){
        Node<Number> n1 = new Node<>(10);
        Node<Integer> n2 = new Node<>(20);
        getdata4(n1);
        getdata4(n2);  //这样就可以输出任意的类型
    }

}