程序员的成长之路

互联网/程序员/成长/职场 

来源：http://rrd.me/ekGHE

前言

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

泛型带来的好处

在没有泛型的情况的下，通过对类型 Object 的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。

对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是本身就是一个安全隐患。

那么泛型的好处就是在编译的时候能够检查类型安全，并且所有的强制转换都是自动和隐式的。

public class GlmapperGeneric<T> {





        private T t;





    public void set(T t) { this.t = t; }





    public T get() { return t; }







    public static void main(String[] args) {





        // do nothing





    }







  /**





    * 不指定类型





    */





  public void noSpecifyType(){





    GlmapperGeneric glmapperGeneric = new GlmapperGeneric();





    glmapperGeneric.set("test");





    // 需要强制类型转换





    String test = (String) glmapperGeneric.get();





    System.out.println(test);





  }







  /**





    * 指定类型





    */





  public void specifyType(){





    GlmapperGeneric<String> glmapperGeneric = new GlmapperGeneric();





    glmapperGeneric.set("test");





    // 不需要强制类型转换





    String test = glmapperGeneric.get();





    System.out.println(test);





  }





}

泛型中通配符

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

• ？表示不确定的 java 类型
• T (type) 表示具体的一个java类型
• K V (key value) 分别代表java键值中的Key Value
• E (element) 代表Element

？ 无界通配符

List<Animal> listAnimals

List<? extends Animal> listAnimals

static int countLegs (List<? extends Animal > animals ) {





    int retVal = ;





    for ( Animal animal : animals )





    {





        retVal += animal.countLegs();





    }





    return retVal;





}







static int countLegs1 (List< Animal > animals ){





    int retVal = ;





    for ( Animal animal : animals )





    {





        retVal += animal.countLegs();





    }





    return retVal;





}







public static void main(String[] args) {





    List<Dog> dogs = new ArrayList<>();





     // 不会报错





    countLegs( dogs );





    // 报错





    countLegs1(dogs);





}

上界通配符 < ? extends E>

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

• 如果传入的类型不是 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

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 {







}

？和 T 的区别

// 可以





T t = operate();







// 不可以





？ car = operate();

区别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)

GlmapperGeneric<String> glmapperGeneric = new GlmapperGeneric<>();





List<String> dest = new ArrayList<>();





List<Number> src = new ArrayList<>();





glmapperGeneric.testNon(dest,src);

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

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

T extends A

? extends A





? super A

Class<T> 和 Class<?> 区别

// 通过反射的方式生成  multiLimit





// 对象，这里比较明显的是，我们需要使用强制类型转换





MultiLimit multiLimit = (MultiLimit)





Class.forName("com.glmapper.bridge.boot.generic.MultiLimit").newInstance();

// 可以





public Class<?> clazz;





// 不可以，因为 T 需要指定类型





public Class<T> clazzT;

public class Test3<T> {





    public Class<?> clazz;





    // 不会报错





    public Class<T> clazzT;





}

往期精彩回顾

朕已阅