回归Java：泛型使用

什么是泛型

  
  
泛型（Generics ）是把类型参数化，运用于类、接口、方法中，可以通过执行泛型类型调用分配一个类型，将用分配的具体类型替换泛型类型。
然后，所分配的类型将用于限制容器内使用的值，这样就无需进行类型转换，
还可以在编译时提供更强的类型检查。 

  
  
泛型，即“参数化类型”。
一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。

那么参数化类型怎么理解呢？
顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，
此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

为什么需要泛型

• 首先，我们看下下面这段简短的代码:
  

  
  
public class GenericTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("qqyumidi");
        list.add("corn");
        list.add(100);
        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i); // 1
            System.out.println("name:" + name);
        }
    }
}

        定义了一个List类型的集合，先向其中加入了两个字符串类型的值，随后加入一个Integer类型的值。这是完全允许的，因为此时list默认的类型为Object类型。在之后的循环中，由于忘记了之前在list中也加入了Integer类型的值或其他编码原因，很容易出现类似于//1中的错误。因为编译阶段正常，而运行时会出现“java.lang.ClassCastException”异常。因此，导致此类错误编码过程中不易发现。

 在如上的编码过程中，我们发现主要存在两个问题：

   
   
1.当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，
改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。
2.因此，//1处取出集合元素时需要人为的强制类型转化到具体的目标类型，
且很容易出现“java.lang.ClassCastException”异常。
那么有没有什么办法可以使集合能够记住集合内元素各类型，且能够达到只要编译时不出现问题，
运行时就不会出现“java.lang.ClassCastException”异常呢？答案就是使用泛型。

泛型有什么用

  
  
泛型主要有两个好处：
（1）消除显示的强制类型转换，提高代码复用
（2）提供更强的类型检查，避免运行时的ClassCastException

什么时候使用泛型

   
   
只要类中操作的引用数据类型不确定，就可以定义泛型类。通过使用泛型类，可以省去强制类型转换和类型转化异常的麻烦。

泛型的使用

  
  
类型参数（又称类型变量）用作占位符，指示在运行时为类分配类型。
根据需要，可能有一个或多个类型参数，并且可以用于整个类。
根据惯例，类型参数是单个大写字母，该字母用于指示所定义的参数类型。

• 下面列出每个用例的标准类型参数：
  

   
   
E：元素
K：键
N：数字
T：类型
V：值
S、U、V 等：多参数情况中的第 2、3、4 个类型
?  表示不确定的java类型（无限制通配符类型）

• 泛型类
  

    
    
当一个类要操作的引用数据类型不确定的时候，可以给该类定义一个形参。
用到这个类的时候，通过传递类型参数的形式，来确定要操作的具体的对象类型。

      
      

       
       
        
        
在JDK1.5之前，为了提高代码的通用性，通常把类型定义为所有类的父类型：Object，
这样做有两大弊端：
1. 在具体操作的时候要进行强制类型转换；
2. 这样还是指定了类型，还是不灵活，对具体类型的方法未知且不安全。
      
      
      
      

       
       

      
      
        
泛型类的格式：在类名后面声明类型变量<E>，泛型类可以有多个类型变量， 如：
      
      

       
       
        
        
public class MyClass<K, V>
      
      
      
      

       
       

      
      
什么时候使用泛型类？
      
      

       
       
        
        
只要类中操作的引用数据类型不确定，就可以定义泛型类。通过使用泛型类，可以省去强制类型转换和类型转化异常的麻烦。
      
      
      
      

       
       

      
      
  

• 泛型方法
  

    
    
泛型方法也是为了提高代码的重用性和程序安全性。
编程原则：
      
      

       
       
        
        
尽量设计泛型方法解决问题，如果设计泛型方法可以取代泛型整个类，应该采用泛型方法。
      
      
      
      

       
       

      
      
泛型方法的格式：
      
      

       
       
        
        
类型变量放在修饰符后面和返回类型前面， 
如：
public static <E> E getMax(T... in)
public static <T, U extends DLRspBase> U getContent(String method, T t, Class<U> u)
      throws InstantiationException, IllegalAccessException {}
      
      

• 定义泛型方法语法格式如下：
  

      

• 调用泛型方法语法格式如下：
  

 

• 说明一下，定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。
  
• Class<T>的作用就是指明泛型的具体类型，而Class<T>类型的变量c，可以用来创建泛型类的对象。
  
• 为什么要用变量c来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。
  
•  泛型方法要求的参数是Class<T>类型，而Class.forName()方法的返回值也是Class<T>，因此可以用Class.forName()作为参数。其中，forName()方法中的参数是何种类型，返回的Class<T>就是何种类型。在本例中，forName()方法中传入的是User类的完整路径，因此返回的是Class<User>类型的对象，因此调用泛型方法时，变量c的类型就是Class<User>，因此泛型方法中的泛型T就被指明为User，因此变量obj的类型为User。
  
• 当然，泛型方法不是仅仅可以有一个参数Class<T>，可以根据需要添加其他参数。
  
• 为什么要使用泛型方法呢？因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。
  

• 泛型接口
  

    
    
将泛型原理用于接口实现中，就是泛型接口。
  泛型接口的格式：泛型接口格式类似于泛型类的格式，接口中的方法的格式类似于泛型方法的格式。

• 泛型接口例子：
  • MyInterface.java

    
    
public interface MyInteface<T> {
	public T read(T t);
}

• Generic2.java

     
     
public class Generic2 implements MyInterface<String>{
	public static void main(String[] args) {
		Generic2 g = new Generic2();
		System.out.println(g.read("hahaha"));
	}
	@Override
	public String read(String str) {
		return str;
	}
}

泛型的限定

类型变量的限定

• 如果在方法前指定了<T>，那么就是说，方法的这个泛型类型变量和类定义时的泛型类型无关，这个特性让泛型方法可以定义在普通类中而不是泛型类中。
  
• 我们都知道，泛型中可以限定类型变量必须实现某几个接口或者继承某个类，多个限定类型用&分隔，类必须放在限定列表中所有接口的前面。

        
        
  import java.io.Serializable;
  /**
   * ICE
   * 2016/10/17 0017 14:12
   */
  public class Demo {
      public static void main(String[] args) {
          D<A> d = new D<>();
          A a = new A();
          d.test1(a);
          B b = new B();
          d.test1(b);
          C c = new C();
          d.test1(c);
  <span style="white-space:pre">	//test2泛型方法传入的类型是String，不是 D<A> d = new D<>();定义的A类型</span>
          d.test2("test");
      }
  }
  class A implements Serializable, Cloneable {
      @Override
      public String toString() {
          return "A{}";
      }
  }
  class B extends A {
      @Override
      public String toString() {
          return "B{}";
      }
  }
  class C extends A {
      @Override
      public String toString() {
          return "C{}";
      }
  }
  class D<T extends A & Serializable & Cloneable> {
      public void test1(T t) {
          System.out.println(t);
      }
      public <T> void test2(T t) {
          System.out.println(t);
      }
  }

  输出：

         
         
  A{}
  B{}
  C{}
  test

通配符 类型

    
    
类型通配符一般是使用 ? 代替具体的类型实参
      
      

       
       
        
        
通配符“？”同样可以对类型进行限定。可以分为子类型限定、超类型限定和无限定。
通配符不是类型变量，因此不能在代码中使用"?"作为一种类型。
      
      

     
     
<? extends T>：是指 “ 上界通配符 （Upper Bounds Wildcards） ”
<? super T>：是指 “ 下界通配符 （Lower Bounds Wildcards） ”

子类型限定

       
       
表示类型的上界，类似泛型的类型变量限定，格式是：？ extends X。
作用：主要用来安全地访问数据，可以访问X及其子类型。
         
         

          
          
           
           
 一个类型变量或通配符可以有多个限定，多个限定用“&”分隔开，且限定中最多有一个类，可以有多个接口；
如果有类限定，类限定必须放在限定列表的最前面。如：T extends MyClass1 & MyInterface1 & MyInterface2
         
         
         
         

          
          

         
         

超类型限定

        
        
表示类型的下界，格式是：？ super X。
特点：
1、限定为X和X的超类型，直至Object类，因为不知道具体是哪个超类型，因此方法返回的类型只能赋给Object。
2、因为X的子类型可以向上转型为X，所以作为方法的参数时，可以传递null，X以及X的子类型
作用：主要用来安全地写入数据，可以写入X及其子类型。

无限定

        
        
无限定不等于可以传任何值，相反，作为方法的参数时，只能传递null，作为方法的返回时，只能赋给Object。

通配符类型--总结：

         
         
如果频繁支持读取数据，不要求写数据，使用<? extends T>。即生产者 使用 <? extends T>
如果频繁支持写入数据，不特别要求读数据，使用<? super T>。即消费者 使用 <? super T>
如果都需要支持，使用<T>。

泛型擦除

Java的泛型在编译期间，所有的泛型信息都会被擦除掉。

   
   
Class c1 = new ArrayList<Integer>().getClass();  
Class c2 = new ArrayList<Long>().getClass();   
System.out.println(c1 == c2); 

          这就是 Java 泛型的类型擦除造成的，因为不管是 ArrayList<Integer> 还是 ArrayList<Long>，在编译时都会被编译器擦除成了 ArrayList。Java 之所以要避免在创建泛型实例时而创建新的类，从而避免运行时的过度消耗。

   
   
究其原因，在于Java中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，
在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，
也就是说，成功编译过后的class文件中是不包含任何泛型信息的。
泛型信息不会进入到运行时阶段。
对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

泛型类型信息

• 那么，如果我们确实某些场景，如HTTP或RPC或jackson需要获取泛型进行序列化反序列化的时候，需要获取泛型类型信息。
  
• 可以参照如下：

        
        
  import java.lang.reflect.ParameterizedType;
  import java.lang.reflect.Type;
  /**
   *  获取运行时的泛型类型信息
   *
   * @author Sven Augustus
   */
  public class Test2 {
  	static class ParameterizedTypeReference<T> {
  		protected final Type type;
  		public ParameterizedTypeReference() {
  			Type superClass = this.getClass().getGenericSuperclass();
  			//if (superClass instanceof Class) {
  	// throw new IllegalArgumentException(
  //"Internal error: TypeReference constructed without actual type information");
  			//	} else {
  				this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
  			//}
  		}
  		public Type getType() {
  			return type;
  		}
  	}
  	public static void main(String[] args) {
  // System.out.println(new ParameterizedTypeReference<String>().getType());
  // java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType
  // 此处会输出报错，因此ParameterizedTypeReference 应不能直接实例化，可以考虑加abstract
  		System.out.println(new ParameterizedTypeReference<String>() { }.getType());
  // ParameterizedTypeReference 的匿名内部类，可以触发super()，
  //即 ParameterizedTypeReference()的构造器逻辑，正常运行
  	}
  }

注意一个关键点：

    
    
可以通过定义类的方式（通常为匿名内部类，因为我们创建这个类只是为了获得泛型信息）在运行时获得泛型参数。

泛型数组 （可能导致类型不安全）

   
   
注意：Java中没有所谓的泛型数组一说

   
   
List<String>[] lsa = new ArrayList<String>[10]; // error

    
    
如果可以的话，可能导致类型不安全。如：
Object o = lsa;
Object []oa = (Object[])o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li;
String s = lsa[1].get(0); // runtime error

参考来源： http://mp.weixin.qq.com/s/v-h9w6TP99uYFihJ8slklQ

参考来源： http://www.cnblogs.com/lwbqqyumidi/p/3837629.html