一、泛型类用法

---

泛型类用法 : 使用时先声明泛型 , 如果不声明泛型 , 则表示该类的泛型是 Object 类型 ;

泛型类代码 :

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

指明泛型类型 : 指定 泛型类 的泛型为 String 类型 , 那么在该类中凡是使用到 T 类型的位置 , 必须是 String 类型 , 泛型类的 泛型声明 , 使用时在 类名后面 声明 ;

        // 指定 泛型类 的泛型为 String 类型
        //      那么在该类中凡是使用到 T 类型的位置 , 必须是 String 类型
        //      泛型类的 泛型声明 , 使用时在 类名后面 声明
        Student<String> student = new Student("Tom", 16, "Cat");
        String data = student.getData();

不指明泛型类型 : 如果不 指明泛型类型 , 则 泛型类型 默认为 Object 类型 ; 如下面的示例 , 获取的 泛型类型的变量也是 Object 类型 , 需要强转为 String 类型 ;

        // 如果不 指明泛型类型
        //      则 泛型类型 默认为 Object 类型
        Student student1 = new Student("Tom", 16, "Cat");
        // 获取的 泛型类型的变量也是 Object 类型 , 需要强转为 String
        String data1 = (String) student1.getData();

二、泛型方法用法

---

泛型方法 : 给下面的泛型方法 , 传入 String 作为参数 , 则 泛型方法中的 T 的类型就是 String 类型 ;

    public <T, A> T getData2(T arg){
        T data = arg;
        return data;
    }

指定泛型的方法 : 指定 泛型方法 的泛型类 , 泛型方法 的泛型声明 , 在调用时 方法名的前面 声明 ; 这种用法很少见 ;

        // 指定 泛型方法 的泛型类
        //      泛型方法 的泛型声明 , 在调用时 方法名的前面 声明
        student.<String, Integer>getData2("Mouse");

不指定泛型的方法 : 泛型方法 中 也可以不声明泛型类型 , 传入的参数是 泛型 T 类型 , 如果给传入参数设置 String , 隐含将泛型 T 设置为 String 类型 ;

        // 泛型方法 中 也可以不声明泛型类型
        //      传入的参数是 泛型 T 类型
        //      如果给传入参数设置 String , 隐含将泛型 T 设置为 String 类型
        String data2 = student.getData2("Mouse");

三、泛型通配符 <?>

---

如果现在的泛型类型不确定 , 则使用 ? 作为通配符 , 该用法与将泛型类型指定为 Object 类型用法相同 ;

? 通配符用法示例 :

        // 使用 <?> 通配符作为泛型
        //      默认将泛型指定为 Object 类型
        Student<?> student2 = new Student("Tom", 16, "Cat");
        String data2 = (String) student1.getData();

上述 ? 通配符用法等效于下面的不指定泛型的用法 :

        // 如果不 指明泛型类型
        //      则 泛型类型 默认为 Object 类型
        Student student1 = new Student("Tom", 16, "Cat");
        // 获取的 泛型类型的变量也是 Object 类型 , 需要强转为 String
        String data1 = (String) student1.getData();

四、泛型安全检查

---

注意下面 $2$ 种泛型的用法 , 推荐使用第一种方法 ;

        // 泛型的安全检查
        // 推荐写法
        Student<String> student3 = new Student<>("Tom", 16, "Cat");
        // 不推荐写法
        Student student4 = new Student<String>("Tom", 16, "Cat");

使用 new 关键字创建对象 , 是发生在运行时 , 也就是 new Student<String>("Tom", 16, "Cat") 代码是在运行时才会执行 , 根本起不到 编译时 安全检查 的作用 , 从 安全检查 方面考虑 , 这种写法没有意义 ;

以 List 泛型为例 :

• 编译期进行安全检查示例 :

        // 编译器 在 编译期 进行检查
        List<String> list1 = new ArrayList<>();
        list1.add(1);

会报如下错误 ;

• 编译期不进行安全检查示例 :

        // 编译器 在 编译期 不进行检查
        List list2 = new ArrayList<String>();
        list2.add(1);

该代码没有任何报错 ;

五、完整代码示例

---

1、泛型类 / 方法

/**
 * 泛型类
 *  该 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;
    }
}

2、main 函数

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

泛型

泛型简介

1. 泛型可以理解为参数化类型,主要作用在类,方法和接口上。
2. Java泛型 与 C++ 模板 : Java 中的泛型 , 是仿照 C++ 中的模板开发的 , 目的是让开发者可以写出通用,灵活的代码 。
3. 伪泛型 : Java中的泛型 , 是伪泛型 , Java 泛型开发好之后 , 在编译阶段就将泛型相关的信息消除了 , 不会泛型留到运行时。

泛型类型 :

• 泛型方法 : 方法有参数 , 方法的参数 可以指定成一些 泛型 ;
• 泛型类 : 类 也可以有参数 , 将 类型 作为 参数 传入类中 ;
• 泛型接口 : 接口 的 参数 , 也可以是泛型 ;

将类型传入泛型方法 , 泛型类, 泛型接口中 , 可以动态地指定一些类型 ;
泛型的作用 :

• 安全检查 : 在编译阶段 , 就可以进行 代码检查, 将更少的错误带到运行时 ;
• 避免强转 : 避免类型的强转导致不必要的安全问题 ;
• 提高性能 : 使用泛型可以提高 Java 的性能 ;

泛型类

泛型类 : 在类名后面使用声明泛型 , 则在该类中, 可以使用该泛型类型 T 类型 ;特别注意 , 该类中的 如下2个方法不是泛型方法 ; 其中的参数 , 返回值类型是T , 但这个T是作为一个正常的类型使用的 , 并不是声明在方法 中的泛型 ;
如果类,接口,方法是泛型类, 泛型接口,泛型方法, 则该类 , 接口 , 方法必须由 修饰 , 有个带尖括号的 T ;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

完整的泛型类

/**
 * 泛型类
 *  该 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 类型作为参数使用
 *  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;
    }

    /**
     * 泛型方法 , 是将某个类型作为参数传入
     *      方法指定泛型 , 写法如下
     *
     * 该方法是泛型方法
     *      方法指定了 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;
    }
}

静态方法的泛型

静态方法泛型 : 如果静态方法中使用了类中的泛型T, 作为参数或返回值 , 这种使用时错误的 ;
如果必须在静态方法中使用泛型T, 则该泛型T必须是静态方法的泛型 , 不能是类的泛型 ;
错误用法：
正确用法 :

泛型类与泛型方法完整示例

/**
 * 泛型类
 *  该 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;
    }

    /**
     * 如果静态方法中使用类 类中的泛型
     *      这种使用时错误的
     *
     * 如果必须在 静态方法 中使用泛型 T
     *      则该泛型 T 必须是静态方法的泛型
     *      不能是类的泛型
     *
     * @param arg
     * @return
     */
    public static <T> T getData3(T arg){
        T data = arg;
        return data;
    }
}

泛型的定义：

在定义类的时候并不会设置类的属性和方法的参数的具体类型，而是在类实际用的时候再定义。它存在的意义是帮我们在编译期间检查我们的类型是否正确。

//定义一个Point类
class Point{
    private Object x;
    private Object y;

    public Object getX() {
        return x;
    }

    public void setX(Object x) {
        this.x = x;
    }

    public Object getY() {
        return y;
    }

    public void setY(Object y) {
        this.y = y;
    }
}

public class Generic {
    public static void main(String[] args) {
        //创建Point类对象
        Point point = new Point();
        //定义X和Y
        point.setX("东经80度");
        point.setY("北纬20度");
        //转成字符串类型
        String x = (String) point.getX();
        String y = (String) point.getY();
        //打印
        System.out.println("x = "+x);
        System.out.println("y = "+y);
    }
}

我们先定义一个Point类，其中的X和Y属性我们都用定义为Object类，在使用的时候转成字符串，再进行打印。

但是当我们setY的时候给了它一个整数，但是后面转换成字符串的时候，编译器并没有个我们提示类型错误，只有到运行的时候在产生报错。

告诉我们34行产生类型转化错误，所以就产生类泛型，目的是可以帮助我们在编译器期间就可以告诉我们类型错误，及时修改！

泛型类：

基本语法：

class exampleClass<T>{
}

这里的尖括号中的T表示类型参数，可以指代任何类型。
这里的T可以用任意符号代替，但是java中会给出了一些标准。

T:代表一般的类
E:代表Element元素和Exception异常
K:代表key
V:代表Value，通常会配合K一起使用（只能出现一个K，K有它对应的Value，键值对）
S:代表Subtype子类型

我们利用泛型类将上面的代码再写一遍

//定义一个泛型Point类
class Point<T>{
    private T x;
    private T y;

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public T getY() {
        return y;
    }

    public void setY(T y) {
        this.y = y;
    }
}


public class Generic {
    public static void main(String[] args) {
        //创建Point类对象
        Point<String> point = new Point<String>();
        //定义X和Y
        point.setX("东经80度");
        point.setY("北纬30度");
        //转成字符串类型
        String x = (String) point.getX();
        String y = (String) point.getY();
        //打印
        System.out.println("x = "+x);
        System.out.println("y = "+y);
    }
}

和之前的代码没有太多的差距，但是我们再将Y定义成一个int类型的数据看一下效果。

编译器提醒我们在32行出现了错误需要我们进行修改！这就是泛型存在的意义。

泛型方法：

基本语句：

class exampleClass<T>{
      public <E> E exampleMethod(E e){
         System.out.println(e);
         return e;
      }
}

第一个<E>表示这个方法是一个泛型方法；
第二个E表示方法的返回值类型是E；
括号中的E表示传入的参数的类型是E，这个E被称为是参数化类型。
泛型类和泛型方法是可以共存的，在泛型类中有泛型方法，他们俩尖括号中的内容不是一定要相同的，泛型方法的参数类型是单独的 ，与泛型类无关！

泛型接口：

基本语法：

interface IMessage<T>{
public void print(T t);
}

子类实现这个接口：
（1）子类仍然是泛型类：

//定义一个泛型接口
interface IMessage<T>{
    //抽象方法
    public void print(T t);
}
//定义一个类实现泛型接口
class MessageImpl1<T> implements IMessage<T>{
    //覆写泛型接口的方法
    @Override
    public void print(T t) {
        System.out.println(t);
    }
}

（2）子类给出具体类型（子类就不是泛型类了）：

//给出具体类型的类就不是泛型类了
class MessageImpl2 implements IMessage<Integer>{
    //覆写接口方法
    @Override
    public void print(Integer integer) {
        
    }
}

通配符：

问号通配符：<?>
当我们定义了一个泛型类，在写一个方法的时候，要将这个泛型类当做参数传入，但是我们这是不能确定这个泛型类的具体类型，所以就有了问号通配符，帮我们接受这个泛型类包含的所有数据类型。

//泛型类
class exampleClass2<T>{
    T t;
    //定义fun方法
    //利用问号通配符，接收泛型类所包含的所有数据类型
    public static void fun(exampleClass2<?> exampleClass){
        System.out.println(exampleClass);
    }
}

但是用问号通配符的方法不可以修改泛型类对象的值，因为我们在这是不知道该属性的类型，所有不能进行修改。我们只能获取它的值，不能修改！

这里77行我们试图修改，编译器就会提醒有错误。

上限通配符：<? extends A>

//泛型类
class exampleClass3<T>{
    T t;
    //上限通配符
    public static void fun(exampleClass3<? extends Number> exampleClass3){
        System.out.println(exampleClass3);
    }
}

上限通配符与问号通配符的不同就是让问号继承了一个父类，这个这个方法只会接受这个父类及其子类的类型。
这里也是不清楚该方法具体传入的参数的类型，所以也是只能获取不能修改。

95行修改时报错。
下限通配符：<? super B>

//泛型类
class exampleClass4<T>{
    T t;
    //下限通配符
    public static void fun(exampleClass4<? super Number> exampleClass4){
        System.out.println(exampleClass4);
    }
}

下限通配符表示方法只能接收该类及其所有的父类的类型。
这里我们清楚所有的传入数据不是当下这个就是它的父类，所以可以通过向上转型进行修改，这里是一个天然的向上转型。

这里我们在修改的时候就不会报错。

三种通配符的使用特点：
1、三种通配符都可以用在方法上
2、只有上限通配符还可以用在泛型类和泛型接口的声明上
3、问号通配符和上限通配符只能获取数据不能修改
4、只有下限通配符可以对元素进行修改

类型擦除：

泛型只存在于编译阶段，当进入JVM中所有的泛型内容都会被擦除。普通泛型擦除为Object；有泛型上限的擦除为相应的泛型上限；有泛型下限的，擦除为相应的反省下限。反省的存在就只是为了在编译阶段帮助程序员检查类型错误的，所以在运行是它的意义就失去了。