泛型在项目中的使用

泛型的主要使用

        在项目中我们使用最多泛型最多的就是来写工具类。避免我们写很多重复性的代码。

业务场景

        假设有这样一个场景，厂商对外提供了几十个或者几百个接口。我们要对接口进行数据处理，比如接口是通过json传入的字符串，以下内容number(编号),name(名称)，topic(主题)，content(内容)，label（标签），contentType(内容类型)。

       这只是举个例子实际上参数比这个多的多，要求现在所有的接口都必须有number(编号),name(名称)，content(内容)这三个属性，其余的根据业务的需求数量不等，现在要求调用接口的开发人员将所有的字段拼接在一起以一种密钥进行加密，构建成一个sercet（密钥)，这个密钥当然是只有厂商和厂商对外开放的人才知道。这样给厂商一个加密的密钥，厂商就能解析出所有内容，假设加密方式就是MD5加密吧。

请求参数1：

    private String number;
    private String name;
    private String topic;
    private String content;
    private String label;
    private String contentType;

 请求参数2：

    private String number;
    private String name;
    private String content;
    private String contentType;

请求参数3：

    private String number;
    private String name;
    private String content;

        这里简单举例一下，实际上会比这个多不会比这个少，现在让他表示为参数数量不一定就行。现在写一个工具类实现以上要求。

但是像我这样写效率很低需要判断是否有这个属性，属性多的话需要进行很多判断，大家可以写更有效率的判断，例如利用链表快速查询查询是否有属性，最后在进行是加密就可以了，这里简单演示一下没有加密。如果没有那个属性直接处理异常就行了，返回的就是null。

代码示例：

 /**这是方法上声明泛型，也可以在类上声明*/
    public static  <T> String getSercet(T t){
        Class<?> aClass = t.getClass();
        String name1="";
        String number1="";
        String topic1="";
        String content1="";
        String label1="";
        String contentType1="";
        String sercrt="";
        try {
            /**通过反射获取字段属性*/
            Field name = aClass.getDeclaredField("name");
            Field number = aClass.getDeclaredField("number");
            Field topic = aClass.getDeclaredField("topic");
            Field content = aClass.getDeclaredField("content");
            Field label = aClass.getDeclaredField("label");
            Field contentType = aClass.getDeclaredField("contentType");
            /**如果不存在就是null，叠加的时候为null值*/
            if (name!=null){
                /**属性为私有属性所以需要开启暴力访问，通过地址获取属性*/
                name.setAccessible(true);
                /**利用泛型转换为自己想要的属性*/
                 name1 = (String) name.get(t);
            }
            if (number!=null){
                number.setAccessible(true);
                number1 = (String) number.get(t);
            }
            if (topic!=null){
                topic.setAccessible(true);
                topic1 = (String) topic.get(t);
            }
            if (content!=null){
                content.setAccessible(true);
                content1 = (String) content.get(t);
            }
            if (label!=null){
                label.setAccessible(true);
                label1 = (String) label.get(t);
            }
            if (contentType!=null){
                contentType.setAccessible(true);
                contentType1 = (String) contentType.get(t);
            }
            sercrt=name1+number1+topic1+content1+label1+contentType1;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sercrt;
    }

       当然平时用的还有以下几种

 /**object类型不定数组*/
    public void test2(Object... objects){}

    /**String类型不定数组*/
    public void test3(String... str){}

    /**任意类型不定数组*/
    public <T>void test4(T... ts){};

这种不定数组只是一个长度不确定的数组，可以for循环遍历取值，也可以用steam流转化为集合再进行操作，下面就举个例子吧。

steam操作：steam流不熟悉的请关注我的博客，会出讲解教程。

 public void test2(Object... objects){
        List<Object> oldcollect = Arrays.stream(objects).collect(Collectors.toList());
        List<Object> newcollect1 = oldcollect.stream().map(item -> {
            /**在这里进行代码操作后返回结果*/
            return item;
        }).collect(Collectors.toList());
    }

迭代器操作:

 public void test2(Object... objects){
        for (Object object : objects) {
            
        }
    }

常用泛型的 T，E，K，V，？

以上五种为常用的

本质上这些个都是通配符，没啥区别，只不过是编码时的一种约定俗成的东西。比如上述代码中的 T ，我们可以换成 A-Z 之间的任何一个 字母都可以，并不会影响程序的正常运行，但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。通常情况下，T，E，K，V，？ 是这样约定的：

？ 表示不确定的 java 类型

T (type) 表示具体的一个java类型

K V (key value) 分别代表java键值中的Key Value

E (element) 代表Element

？ 无界通配符

先从一个小例子看起，原文在 这里 。

我有一个父类 Animal 和几个子类，如狗、猫等，现在我需要一个动物的列表，我的第一个想法是像这样的：

List<Animal> listAnimals

但是老板的想法确实这样的：

List<? extends Animal> listAnimals

为什么要使用通配符而不是简单的泛型呢？通配符其实在声明局部变量时是没有什么意义的，但是当你为一个方法声明一个参数时，它是非常重要的。

static int countLegs (List<? extends Animal > animals ) {
    int retVal = 0;
    for ( Animal animal : animals )
    {
        retVal += animal.countLegs();
    }
    return retVal;
}

static int countLegs1 (List< Animal > animals ){
    int retVal = 0;
    for ( Animal animal : animals )
    {
        retVal += animal.countLegs();
    }
    return retVal;
}

public static void main(String[] args) {
    List<Dog> dogs = new ArrayList<>();
     // 不会报错
    countLegs( dogs );
    // 报错
    countLegs1(dogs);
}

当调用 countLegs1 时，就会飘红，提示的错误信息如下：

所以，对于不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号，即 ），表示可以持有任何类型。像 countLegs 方法中，限定了上届，但是不关心具体类型是什么，所以对于传入的 Animal 的所有子类都可以支持，并且不会报错。而 countLegs1 就不行。

上界通配符 < ? extends E>

上届：用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。

在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类，这样有两个好处：

• 如果传入的类型不是 E 或者 E 的子类，编译不成功

• 泛型中可以使用 E 的方法，要不然还得强转成 E 才能使用

private <K extends A, E extends B> E test(K arg1, E arg2){
    E result = arg2;
    arg2.compareTo(arg1);
    //.....
    return result;
}

类型参数列表中如果有多个类型参数上限，用逗号分开

下界通配符 < ? super E>

下界: 用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object

在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。

private <T> void test(List<? super T> dst, List<T> src){
    for (T t : src) {
        dst.add(t);
    }
}

public static void main(String[] args) {
    List<Dog> dogs = new ArrayList<>();
    List<Animal> animals = new ArrayList<>();
    new Test3().test(animals,dogs);
}
// Dog 是 Animal 的子类
class Dog extends Animal {

}

dst 类型 “大于等于” src 的类型，这里的“大于等于”是指 dst 表示的范围比 src 要大，因此装得下 dst 的容器也就能装 src 。

上界通配符主要用于读数据，下界通配符主要用于写数据。

？和 T 的区别

？和 T 都表示不确定的类型，区别在于我们可以对 T 进行操作，但是对 ？不行，比如如下这种 ：

// 可以
T t = operate();

// 不可以
？car = operate();

简单总结下：

T 是一个 确定的 类型，通常用于泛型类和泛型方法的定义，？是一个 不确定 的类型，通常用于泛型方法的调用代码和形参，不能用于定义类和泛型方法。

区别1：通过 T 来 确保 泛型参数的一致性

// 通过 T 来 确保 泛型参数的一致性
public <T extends Number> void
test(List<T> dest, List<T> src)

//通配符是 不确定的，所以这个方法不能保证两个 List 具有相同的元素类型
public void
test(List<? extends Number> dest, List<? extends Number> src)

像下面的代码中，约定的 T 是 Number 的子类才可以，但是申明时是用的 String ，所以就会飘红报错。

不能保证两个 List 具有相同的元素类型的情况

GlmapperGeneric<String> glmapperGeneric = new GlmapperGeneric<>();
List<String> dest = new ArrayList<>();
List<Number> src = new ArrayList<>();
glmapperGeneric.testNon(dest,src);

上面的代码在编译器并不会报错，但是当进入到 testNon 方法内部操作时（比如赋值），对于 dest 和 src 而言，就还是需要进行类型转换。

区别2：类型参数可以多重限定而通配符不行

使用 & 符号设定多重边界（Multi Bounds)，指定泛型类型 T 必须是 MultiLimitInterfaceA 和 MultiLimitInterfaceB 的共有子类型，此时变量 t 就具有了所有限定的方法和属性。对于通配符来说，因为它不是一个确定的类型，所以不能进行多重限定。

区别3：通配符可以使用超类限定而类型参数不行

类型参数 T 只具有 一种 类型限定方式：

T extends A

但是通配符 ? 可以进行 两种限定：

? extends A
? super A

`Class`和 `Class`区别

前面介绍了 ？和 T 的区别，那么对于，Class<T>和 <Class<?>又有什么区别呢？
Class<T>和 Class<?>

最常见的是在反射场景下的使用，这里以用一段发射的代码来说明下。

// 通过反射的方式生成  multiLimit
// 对象，这里比较明显的是，我们需要使用强制类型转换
MultiLimit multiLimit = (MultiLimit)
Class.forName("com.glmapper.bridge.boot.generic.MultiLimit").newInstance();

对于上述代码，在运行期，如果反射的类型不是 MultiLimit 类，那么一定会报 java.lang.ClassCastException 错误。

对于这种情况，则可以使用下面的代码来代替，使得在在编译期就能直接 检查到类型的问题：

Class<T>在实例化的时候，T 要替换成具体类。Class<?>它是个通配泛型，? 可以代表任何类型，所以主要用于声明时的限制情况。比如，我们可以这样做申明：

// 可以
public Class<?> clazz;
// 不可以，因为 T 需要指定类型
public Class<T> clazzT;

所以当不知道定声明什么类型的 Class 的时候可以定义一 个Class。