Java泛型

参考：

• 磊叔的技术博客 : 聊一聊-JAVA 泛型中的通配符 T，E，K，V，？
• tutorialspoint : Java - Generics Java - 泛型

泛型的好处

在没有泛型的情况的下，通过对类型 Object 的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是本身就是一个安全隐患。

那么泛型的好处：

1. 类型安全：泛型中只能保存一种类型的对象。
2. 不需要类型转换：不需要类型转换。
3. 编译时检查：在编译时检查所有与泛型相关的数据类型的错误，这样在运行时就不会出现问题。

比如 

// Java program to demonstrate that NOT using
// generics can cause run time exceptions

import java.util.*;

class Test
{
    public static void main(String[] args)
    {
        // Creatinga an ArrayList without any type specified
        ArrayList al = new ArrayList();

        al.add("Sachin");
        al.add("Rahul");
        al.add(10); // Compiler allows this

        String s1 = (String)al.get(0);
        String s2 = (String)al.get(1);

        // Causes Runtime Exception
        String s3 = (String)al.get(2);
    }
}

运行时异常

Exception in thread "main" java.lang.ClassCastException: 
   java.lang.Integer cannot be cast to java.lang.String
    at Test.main(Test.java:19)

而当使用泛型时：

// Using Java Generics converts run time exceptions into 
// compile time exception.
import java.util.*;

class Test
{
    public static void main(String[] args)
    {
        // Creating a an ArrayList with String specified
        ArrayList <String> al = new ArrayList<String> ();

        al.add("Sachin");
        al.add("Rahul");

        // Now Compiler doesn't allow this
        al.add(10); 

        String s1 = (String)al.get(0);
        String s2 = (String)al.get(1);
        String s3 = (String)al.get(2);
    }
}

编译时 error，编译不通过

15: error: no suitable method found for add(int)
        al.add(10); 

泛型通配符

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

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

泛型的运用

Generic Classes 泛型类

public class Area<T> {

    // T is the Datatype like String,
    // Integer of which Parameter type,
    // the class Area is of
    private T t;

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

    public T get() { return t; }

    public void getArea() {}

    public static void main(String[] args)
    {
        // Object of generic class Area with parameter Type
        // as Integer
        Area<Integer> rectangle = new Area<Integer>();
        // Object of generic class Area with parameter Type
        // as Double
        Area<Double> circle = new Area<Double>();
        rectangle.add(10);
        circle.add(2.5);
        System.out.println(rectangle.get());
        System.out.println(circle.get());
    }
}

Generic Methods 泛型方法（方法的 参数/返回值 泛型）

public class GenericMethodTest {
   // generic method printArray
   public static <E> void printArray( E[] inputArray ) {
      // Display array elements
      for(E element : inputArray) {
         System.out.printf("%s ", element);
      }
      System.out.println();
   }

   public static void main(String args[]) {
      // Create arrays of Integer, Double and Character
      Integer[] intArray = { 1, 2, 3, 4, 5 };
      Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
      Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

      System.out.println("Array integerArray contains:");
      printArray(intArray);   // pass an Integer array

      System.out.println("\nArray doubleArray contains:");
      printArray(doubleArray);   // pass a Double array

      System.out.println("\nArray characterArray contains:");
      printArray(charArray);   // pass a Character array
   }
}

上界和下界通配符（限制类型为xx子类）：

用来限制可以传递的参数的类型

• 上界通配符 < ? extends E> ：用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。
• 下界通配符 < ? super E>：用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object。

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

用在上下界通配符时 ？ 和 T 的区别

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 来保证多个参数具有相同类型的例子：

保证三个参数都是 Comparable<T> 的子类 , 并且是相同的类型

public class MaximumTest {
   // determines the largest of three Comparable objects
   
   public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
      T max = x;   // assume x is initially the largest
      
      if(y.compareTo(max) > 0) {
         max = y;   // y is the largest so far
      }
      
      if(z.compareTo(max) > 0) {
         max = z;   // z is the largest now                 
      }
      return max;   // returns the largest object   
   }
   
   public static void main(String args[]) {
      System.out.printf("Max of %d, %d and %d is %d\n\n", 
         3, 4, 5, maximum( 3, 4, 5 ));

      System.out.printf("Max of %.1f,%.1f and %.1f is %.1f\n\n",
         6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ));

      System.out.printf("Max of %s, %s and %s is %s\n","pear",
         "apple", "orange", maximum("pear", "apple", "orange"));
   }
}

 

Dog 是 Animal 的子类，但是 List<Dog> 不是 List<Animal> 的子类，这时可以用 List<? extends parentClass> 解决

punlic interface MyService {

    public List<? Extends Animal> myMehod();

}

public class MyServiceImpl1 implements MyService {

    public List<Dog> myMehod() {
          //.........
          return dogList;
    }
    
}

public class MyServiceImpl2 implements MyService {

    public List<Cat> myMehod() {
          //.........
          return catList;
    }
    
}