Java泛型的学习

前言

泛型的本质就是将数据类型参数化, 普通方法的参数值可以变，但是参数的数据类型是不能变的，那么需要使用不同数据类型参数时，我们通常的做法就是重载方法，而泛型则可以将数据类型也搞成跟参数的值一样可以变的。

所以说泛型表示具体的数据类型未知，泛型其实就是一个参数变量，用来接收数据类型的名称。当我们在定义接口、类、方法时，不知道使用什么数据类型的时候，可以使用泛型。

泛型参数名称可以任何字符，甚至单词，不过通常使用比较多了就是 E 和 T，E 表示 Element，T 表示 Type。

泛型分为泛型接口、泛型类和泛型方法。泛型接口、泛型类大家都比较熟悉，例如 List 就是泛型接口，而 ArrayList 就是泛型类, 我们经常看到 List 的声明，new ArrayList() 的定义，尖括号里面的 E 就是泛型参数名称，参数值就是你在创建对象的时候指定的具体数据类型，例如你创建集合对象的时候可以指定 E 是 String，或者 Integer，当然也可以指定自己定义的类(例如：CarBean)。在实际的工作中，泛型方法用的比较多，特别是解析自定义数据结构非常有用，类似于 toString 这种场景是百试不爽。

泛型接口

泛型接口中的泛型参数的值是在写实现类的时候指定具体的值，或者在引用实现子类的示例对象时指定具体的值，但是引用实现子类对象时，实现子类也必须是泛型类才行。

定义实现类时指定泛型具体的数据类型

例如，定义一个泛型接口 Interator 和实现类 Scanner 的泛型实现如下：

public interface interator {
	E next();
}

Scanner 类实现了 Iterator 接口，并指定接口的泛型参数值为 String，所以重写的 next() 方法中的泛型参数值就是 String：

public final class Scanner implements Iterator {
	public String next(){}
}

定义实现类时，泛型与接口相同

在定义实现类时，接口使用什么泛型参数名，实现类就使用什么泛型参数名。其实就是定义一个泛型类，只不过这个泛型的泛型参数名称需要和泛型接口的泛型参数名相同。创建对象的时候确定泛型的具体类型。

注：在创建对象时指定泛型具体的数据类型，那么具体的数据类型应该是保存在所创建的对象中，当访问某个含有泛型参数的变量或者调用某个含有泛型参数的方法时，会把这个数据类型传递过去。

例如，List 接口和 ArrayList 实现类的泛型实现如下：

public interface List {
	boolean add(E e);
	E get(int index);
}

pubic class ArrayList implements List {
	public boolean add(E e);
	public E get(int index);
}

泛型接口的示例代码

泛型接口：

package priv.lwx.javaprac.genericinterface;

/**
 * 泛型接口示例
 *
 * @author liaowenxiong
 * @date 2021/11/22 15:02
 */

public interface GenericInterface {
    void toString(E e);
}

泛型接口的第一种使用方式：定义实现类时指定泛型具体的数据类型

package priv.lwx.javaprac.genericinterface;

/**
 * 泛型接口的第一种使用方式：
 * 定义实现类时指定泛型具体的数据类型
 *
 * @author liaowenxiong
 * @date 2021/11/22 15:42
 */

public class GenericInterfaceImpl01 implements GenericInterface{
    @Override
    public void toString(Double aDouble) {
        System.out.println(aDouble);
    }
}

泛型接口的第二种使用方式：在定义实现类时，接口使用什么泛型参数名，实现类就使用什么泛型参数名。其实就是定义一个泛型类，只不过这个泛型的泛型参数名称需要和泛型接口的泛型参数名相同。创建对象的时候确定泛型的具体类型。

package priv.lwx.javaprac.genericinterface;

/**
 * 泛型接口的第二种使用方式：
 * 在定义实现类时，接口使用什么泛型参数名，实现类就
 * 使用什么泛型参数名。其实就是定义一个泛型类，只不过这个泛型的泛型参数名称需
 * 要和泛型接口的泛型参数名相同。创建对象的时候确定泛型的具体类型。
 *
 * @author liaowenxiong
 * @date 2021/11/22 15:04
 */

public class GenericInterfaceImpl02 implements GenericInterface {
    @Override
    public void toString(E e) {
        System.out.println(e);
    }
}

测试类代码：

package priv.lwx.javaprac.genericinterface;

/**
 * 泛型接口测试
 *
 * @author liaowenxiong
 * @date 2021/11/22 15:31
 */

public class GenericInterfaceDemo01 {
    public static void main(String[] args) {
        /*
        泛型接口的第一种使用方式测试：
        定义实现类时指定了具体的泛型类型，那么使用接口类型的变量接收实现类
        对象，在调用方法时会有风险
        */
        GenericInterface gi1 = new GenericInterfaceImpl01();
        gi1.toString(123); // 参数类型是Object,编译通过，运行时报错：Integer cannot be cast to Double

        /*
        只能使用实现类变量接收对象才能避免风险，参数类型是确定的
         */
        GenericInterfaceImpl01 gi2 = new GenericInterfaceImpl01();
        gi2.toString(23.99);

        /*
        泛型接口第二种使用方式测试：
        定义实现类时跟随接口的泛型，那么使用接口类型的变量接收实现类对象时，接口
        指定什么数据类型，那么创建的对象中有关变量或方法的泛型参数就自动使用什么
        数据类型
         */
        GenericInterface gi3 = new GenericInterfaceImpl02();
        gi3.toString("liaowenxiong");

        GenericInterfaceImpl02 gi4 = new GenericInterfaceImpl02();
        gi4.toString(2.9);
    }
}

泛型类

声明定义泛型类，那么在创建泛型类对象时，指定具体的泛型参数值，即具体的数据类型。如果创建对象的时候不指定具体的数据类型，默认数据类型是 Object。

例如，ArrayList 类在声明定义的时候不知道集合中会存储什么类型的数据，所以类型使用泛型：

注：在创建对象时指定泛型具体的数据类型，那么具体的数据类型应该是保存在所创建的对象中，当访问某个含有泛型参数的变量或者调用某个含有泛型参数的方法时，会把这个数据类型传递过去。

演示代码

先声明定义两个 JavaBean 类型：

1.CarBean

public class CarBean {
    private String brand;
    private String name;
    private String price;

    public CarBean() {
    }

    public CarBean(String brand, String name, String price) {
        this.brand = brand;
        this.name = name;
        this.price = price;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        CarBean carBean = (CarBean) o;
        return Objects.equals(brand, carBean.brand) &&
                Objects.equals(name, carBean.name) &&
                Objects.equals(price, carBean.price);
    }

    @Override
    public int hashCode() {
        return Objects.hash(brand, name, price);
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getName() {
        return name;
    }

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

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }
}

2.HouseBean

public class HouseBean {
    private String brand;
    private String name;
    private String price;

    public HouseBean() {
    }

    public HouseBean(String brand, String name, String price) {
        this.brand = brand;
        this.name = name;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getName() {
        return name;
    }

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

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "HouseBean{" +
                "brand='" + brand + '\'' +
                ", name='" + name + '\'' +
                ", prive='" + price + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        HouseBean houseBean = (HouseBean) o;
        return brand.equals(houseBean.brand) &&
                name.equals(houseBean.name) &&
                price.equals(houseBean.price);
    }

    @Override
    public int hashCode() {
        return Objects.hash(brand, name, price);
    }
}

再声明定义一个泛型类：

public class GenericGoods { // 尖括号表示声明泛型参数名（或泛型变量名）为 T
        private T goods;
        private String info_goods;

    public GenericGoods(T goods) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        this.goods = goods;
        this.info_goods = setData(goods);
    }

    public GenericGoods(T goods, String info_goods) {
        this.goods = goods;
        this.info_goods = info_goods;
    }
    /**
 	 * 声明定义一个方法，将指定的goods对象中的所有成员变量的值取出来，并以“变量名=变量值”这样的格式进行拼接后返回该字符处。
 	 * 这里使用泛型声明参数类型，这样就可以接收任意类型的参数，然后利用反射技术获取对象所属类型的变量名和变量值，再拼接成字符串返回
	 */

    private String setData(T goods) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        StringBuffer sb = new StringBuffer();
        String getterMethodName = "";
        String fieldName = "";
        Method mObject = null;
        String info_goods = "";
        // 获取对象所属类型的全部字段（字段是指类所声明的静态变量和成员变量）
        Field[] fields = goods.getClass().getDeclaredFields();
        if (fields.length > 0) {
            for (Field f : fields) {
                // 设置允许访问私有域
                f.setAccessible(true);
                // 获取字段名称
                fieldName = f.getName();
                // 将字段名称按符号“#”进行拼接
                sb.append(fieldName + "#");
                // 拼接getter方面名称
                if (fieldName.length() > 1) {
                    // 组装getter方法名
                    // substring(0,1)表示截取索引值从0到1的字符串，但是不含索引值为1的字符，其实就是截取第一个字符，并且转换成大写
                    // substring(1)表示截取索引值为1后面的所有字符串，包含索引值为1的字符
                    getterMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                    // 将拼接的getter方法名打印出来
                    System.out.println(getterMethodName);
                } else {
                	// 否则说明字段名称仅有一个字符，直接转换成大写，再拼接 get 即可
                    getterMethodName = "get" + fieldName.toUpperCase();
               		// 将拼接的getter方法名打印出来
                    System.out.println(getterMethodName);
                }
                // 获取goods所属类型中指定名称的方法对象
                mObject = goods.getClass().getMethod(getterMethodName);
                // 获取对象goods的成员变量的值，并且使用“变量名=变量值&”这样的格式拼接起来
                // mObject.invoke(goods)是指调用对象goods的方法mObject，其实就是调用getter方法获取相关成员变量的值
                info_goods += fieldName + "=" + mObject.invoke(goods) + "&";
                // 截取info_goods中索引值从0到info_goods最后一个索引值的子字符串，不包含最后一个索引值的字符，其实就是将最后一个字符“&”过滤掉
                info_goods = info_goods.substring(0, info_goods.length() - 1);
            }
            // 打印输出所有字段名称
            System.out.println(sb);
        }

        return info_goods;
    }

    public T getGoods() {
        return goods;
    }

    public void setGoods(T goods) {
        this.goods = goods;
    }

    public String getInfo_goods() {
        return info_goods;
    }

    public void setInfo_goods(String info_goods) {
        this.info_goods = info_goods;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        GenericGoods that = (GenericGoods) o;
        return Objects.equals(goods, that.goods) &&
                Objects.equals(info_goods, that.info_goods);
    }

    @Override
    public int hashCode() {
        return Objects.hash(goods, info_goods);
    }
}

main 方法测试：

public class Demo04Generic {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        // 创建一个汽车产品
        CarBean cb = new CarBean();
        cb.setBrand("奔驰");
        cb.setName("S60");
        cb.setPrice("100000.00");
		// 创建一个通用商品对象，指定泛型参数具体的值，即指定具体的泛型类型，即指定具体的数据类型，那么创建的对象中有使用泛型参数的地方，具体的数据类型就已经明确了
        GenericGoods gg = new GenericGoods(cb); 
        String info_goods = gg.getInfo_goods();
        System.out.println(info_goods);
    }
}

泛型方法

泛型方法的定义语法格式：修饰符 返回值类型 方法名(泛型变量名 参数名) {方法体}。 调用方法的时候确定泛型参数的值（即具体的数据类型），即调用方法的时候，传递什么类型的参数，泛型就是什么类型。

演示代码

public  String toString(T obj) { // 方法所声明的泛型参数名和类的泛型参数名相同，不会造成冲突
        StringBuffer info_obj = new StringBuffer();
        StringBuffer fieldNames = new StringBuffer();
        Method m = null;
        String getMethodName = "";
        String fieldName = "";

        Field[] fields = obj.getClass().getDeclaredFields();
        System.out.println("对象所属类型是：" + obj.getClass().getName());

        if (fields.length > 0) 
            for (int i = 0; i