泛型类与泛型方法的说明

1. 泛型的提出

List中默认的类型是Object，当我们向List中传入数字和字符串的时候可以执行，但是当要输出的时候就让人头疼。这时候泛型就出来了，可以指定List中传入对象的类型。当传入与指定类型不一样的对象时就会直接报错，让代码更加规范。

2. 在集合中使用泛型

这里泛型不能是基本数据类型，型要求包容的是对象类型。List arr = new ArrayList();要改为List arr = new ArrayList();此时使用.add()方法会发现只允许我们放Integer类型，当我们想要加入不一样的类型时，编译不会通过。
代码测试

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<Integer> arr = new ArrayList<Integer>();
        arr.add(11);
        arr.add(12);
        arr.add(13);
        arr.add(14);
        for (Integer num: arr) {
            System.out.println(num);
        }
    }
}

在实例化集合类时，可以指明具体的泛型类型，指明完后，在集合类或接口中定义类或接口时，内部结构使用到类的泛型，都被指定为实例化的泛型类型。

3. 自定义泛型类

当我们创建的类的属性类型不太确定时，可以使用泛型。需要在类名上加入这里使用其他字母也可以。类的内部就可以使用类的泛型，同时要注意并不是说这个属性类型就是这个类的类型。

public class Student<T> {
    String name;
    int age;
    T stu;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", stu=" + stu +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public T getStu() {
        return stu;
    }

    public void setStu(T stu) {
        this.stu = stu;
    }

    public Student(String name, int age, T stu) {
        this.name = name;
        this.age = age;
        this.stu = stu;
    }

    public Student(){};

}

1. 使用泛型类

没有指明泛型类型，默认为Object类型，可以看到set时都可以执行。

public class Test {
    public static void main(String[] args) {
        //如果没有指明泛型类型，默认为Object类型
        Student student = new Student();
        student.setStu(88);
        student.setStu("Object");
    }
}

当指明泛型类型时

public class Test {
    public static void main(String[] args) {
        //指定泛型的类型为String
        Student<String> stringStudent = new Student<>("aa",12,"stu");
    }
}

此时时无法执行stringStudent.setStu(66);

2. 子类继承泛型类

这里新建一个ubStudent类继承Student
public class subStudent extends Student{ }
也可以在继承的时候就指明泛型的类型如下

public class subStudent extends Student<Integer>{
}

此时的泛型类型即为父类指定的泛型类型。
如果泛型没有被指定，均按照Object处理，但是并不等价与Object。
这里存在四种情况
父类class Student { }
子类不保留父类的泛型

1. 没有类型，擦除

class subStudent1 extends Student{}

2. 具体类型

class subStudent2 extends Student<Integer,String>{}

子类保留父类的泛型

3. 全部保留

class subStudent3<T1, T2> extends Student<T1,T2>{}

4. 部分保留

class subStudent4<T1> extends Student<T1,String>{}

4. 泛型方法

泛型方法会在方法中出现了泛型的结构，泛型参数与类的泛型参数没有关系。

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        Integer[] arr = {1,5,7,9};
        Test test = new Test();
        //调用泛型方法时，指明泛型参数的类型
        List<Integer> res = test.copyList(arr);
        System.out.println(res);
    }
//    public后面的是为了告诉编辑器不是存在一个类叫E
    public <E> List<E> copyList(E[] arr){
        ArrayList<E> list = new ArrayList<>();
        for(E e : arr){
            list.add(e);
        }
        return list;
    }

}

泛型方法，可以声明为静态的因为泛型参数是在调用方法时确定的。而静态方法中不能使用类的泛型。