【Java 泛型】泛型用法 ( 泛型类用法 | 泛型方法用法 | 泛型通配符 ? | 泛型安全检查 )（二）

/**
 * 泛型类
 *  该 T 类型作为参数使用
 *  T 是参数化类型 , 可以由外部传入
 *
 * @param <T>
 */
public class Student<T> {
    private String name;
    private int age;
    /**
     * 该数据的类型未知
     *  使用泛型表示 , 运行时确定该类型
     */
    private T data;
    public Student(String name, int age, T data) {
        this.name = name;
        this.age = age;
        this.data = data;
    }
    /**
     * 该方法不是泛型方法
     *  该方法是普通方法 , 返回值类型是 T 类型
     * @return
     */
    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
    /**
     * 泛型方法 , 是将某个类型作为参数传入
     *      方法指定泛型 , 写法如下 ;
     *
     * 该方法是泛型方法
     *      方法指定了 2 个泛型
     *      泛型个数 , 泛型的个数可以有很多个
     *      多个泛型之间 , 使用逗号隔开
     *
     * 泛型方法指定的泛型 T 与类中的泛型 T 没有任何关系
     *      这两个 T 可以是不同的类型
     *
     * 泛型方法中定义的泛型 T
     *      与参数类型的 T
     *      返回值类型的 T
     *      方法内部的 T
     *      都是同一个类型
     *
     * 与泛型类中的 T 完全没有关系
     *
     * @param <T>
     * @param <A>
     * @return
     */
    public <T, A> T getData2(T arg){
        T data = arg;
        return data;
    }
    public <T> T getData4(T arg){
        T data = arg;
        return data;
    }
    /**
     * 如果静态方法中使用类 类中的泛型
     *      这种使用时错误的
     *
     * 如果必须在 静态方法 中使用泛型 T
     *      则该泛型 T 必须是静态方法的泛型
     *      不能是类的泛型
     *
     * @param arg
     * @return
     */
    public static <T> T getData3(T arg){
        T data = arg;
        return data;
    }
}

import java.util.ArrayList;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        // 指定 泛型类 的泛型为 String 类型
        //      那么在该类中凡是使用到 T 类型的位置 , 必须是 String 类型
        //      泛型类的 泛型声明 , 使用时在 类名后面 声明
        Student<String> student = new Student("Tom", 16, "Cat");
        String data = student.getData();
        // 如果不 指明泛型类型
        //      则 泛型类型 默认为 Object 类型
        Student student1 = new Student("Tom", 16, "Cat");
        // 获取的 泛型类型的变量也是 Object 类型 , 需要强转为 String
        String data1 = (String) student1.getData();
        // 使用 <?> 通配符作为泛型
        //      默认将泛型指定为 Object 类型
        Student<?> student2 = new Student("Tom", 16, "Cat");
        String data2 = (String) student1.getData();
        // 泛型的安全检查
        // 推荐写法
        Student<String> student3 = new Student<>("Tom", 16, "Cat");
        // 不推荐写法
        Student student4 = new Student<String>("Tom", 16, "Cat");
        // 指定 泛型方法 的泛型类
        //      泛型方法 的泛型声明 , 在调用时 方法名的前面 声明
        student.<String, Integer>getData2("Mouse");
        // 泛型方法 中 也可以不声明泛型类型
        //      传入的参数是 泛型 T 类型
        //      如果给传入参数设置 String , 隐含将泛型 T 设置为 String 类型
        String data3 = student.getData2("Mouse");
        // 编译器 在 编译期 进行检查
        List<String> list1 = new ArrayList<>();
        list1.add(1);
        // 编译器 在 编译期 不进行检查
        List list2 = new ArrayList<String>();
        //list2.add(1);
    }
}