java 范型详解

1.范型长啥样？

ArrayList<String> list = new ArrayList<String>();

这是我们最常见的了，然而对于很多java开发来说，只知道用java本身自带的一些范型类，而对于自己去创建范型类啥的，不太熟悉。
范型在java当中是一个比较难的基础点，做了好几年安卓开发，现在才真正地去理解，实在惭愧～

2. 什么是范型

范型是说所操作的数据类型，被指定为一个参数，本质是参数化类型。这种参数化类型，在类，接口，方法的创建中，可以分别称为范型类，范型接口，范型方法。

3. 为什么要使用范型

官方说法是：安全简单，能将运行时错误提前到编译时错误。(PS:官方说法嘛，都带点官腔，我们还是落地点吧～)
在项目当中，如果没用范型，通常是用类型强转。其实类型强转，用得好的话，是不会出现什么ClassCastException错误的，(关于类型强转，请参考另外一篇文章-java 强制类型转换)

关于在网络请求中，对返回数据串转model有几种方式：
1. 每个网络请求写一个实现类，然后在这个网络请求类中将要转的model通过范型传给最底层网络操作类(弊端：重复代码太多，而且要是网络请求多了，压根就不好维护)
2. 用一个单例类，每个请求写一个方法(优点是便于维护，但是使用单例，就不能传context对网络加载框啥的处理了，而且每个请求写一个方法，个人还是觉得不太省事)
3. 上一个项目，我的处理方法是:

private Model string2Model(String response){    Model model = null;    Gson gson = new Gson();    if(tag.equals(url1)){    model = gson.fromJson(response, SonModel1.class);    }else if(tag.equals(url2)){    model = gson.fromJson(response, SonModel2.class);    }}

关于代码model = gson.fromJson(response, SonModel1.class)为什么可以，请看另一篇文章java 强制类型转换。同事觉得我这种方式太low逼了，何况我们新项目接口有100多个，如果有100多个else if，看着太不爽了，我只能继续去改进，这时候，我想用范型做个优化。

4.什么是元组类库

元组和列表list一样，都可能用于数据存储，包含多个数据；但是和列表不同的是：列表只能存储相同的数据类型，而元组不一样，它可以存储不同的数据类型，比如同时存储int、string、list等，并且可以根据需求无限扩展。
直接上代码:

class Tuple1<K, V>{    private K k;    private V v;    public Tuple1(K k, V v){        this.k = k;        this.v = v;    }    public String toString(){        return k + "---" + v;    }}class Tuple2<K, V, M> extends Tuple1<K, V>{    private K k;    private V v;    private M m;    public Tuple2(K k, V v,M m){        super(k,v);        this.k = k;        this.v = v;        this.m = m;    }    public String toString(){        return k + "---" + v + "---" + m;    }}public class Test {    public static void main(String args[]) {        Tuple1 tuple1 = new Tuple1("dafei",27);        System.out.println(tuple1);        Tuple2 tuple2 = new Tuple2("dafei",27,"男");        System.out.println("扩展后的tuple....");        System.out.println(tuple2);    }}

输出结果如下：

dafei---27扩展后的tuple....dafei---27---男

5. 自定义泛型接口、泛型类

5.1 简介

泛型类中的类型参数几乎可以用于任何可以使用接口名、类名的地方，下面的代码示例展示了 JDK 5.0 中集合框架中的 Map 接口的定义的一部分：

public interface Map<K, V> {public void put(K key, V value);public V get(K key);}

当声明或者实例化一个泛型的对象时，必须指定类型参数的值：

Map<String, String> map = new HashMap<String, String>();

对于常见的泛型模式，推荐的名称是：

K ——键，比如映射的键。
V ——值，比如 List 和 Set 的内容，或者 Map 中的值。
E ——异常类。
T ——泛型。
泛型不是协变的

关于泛型的混淆，一个常见的来源就是假设它们像数组一样是协变的。其实它们不是协变的。

注意：List<Object>不是 List<String> 的父类型。

如果 A 扩展 B，那么 A 的数组也是 B 的数组，并且完全可以在需要 B[] 的地方使用 A[]：

Integer[] intArray = new Integer[10];Number[] numberArray = intArray;

上面的代码是有效的，因为一个Integer 是 一个 Number，因而一个 Integer 数组是 一个 Number 数组。但是对于泛型来说则不然。下面的代码是无效的：

List<Integer> intList = newArrayList<Integer>();List<Number> numberList = intList; //invalid

最初，大多数 Java 程序员觉得这缺少协变很烦人，或者甚至是“坏的（broken）”，但是之所以这样有一个很好的原因。如果可以将List 赋给 List，下面的代码就会违背泛型应该提供的类型安全：

List<Integer> intList = newArrayList<Integer>();List<Number> numberList = intList; //invalidnumberList.add(new Float(3.1415));

因为 intList 和 numberList 都是有别名的，如果允许的话，上面的代码就会让您将不是 Integers 的东西放进 intList 中。

5.2 代码

interface Generator<T> {      public T next();  }  class Coffee{      public String toString(){          return getClass().getSimpleName();      }  }  class Mocha extends Coffee{}  class Cappuccino extends Coffee{}  class Breve extends Coffee{}  class Latte extends Coffee{}  class CoffeeGenerator implements Generator<Coffee>{ //T为Coffee      private static Random rand = new Random(47);      private Class[] types = {Latte.class, Mocha.class, Cappuccino.class, Breve.class};      public Coffee next(){ //T为Coffee          try {              return (Coffee)                      types[rand.nextInt(types.length)].newInstance();          } catch (Exception e) {              throw new RuntimeException(e);          }       }  }  public class InterfaceGenTest {      public static void main(String[] args) {          CoffeeGenerator gen = new CoffeeGenerator();          for(int i=0; i<4; i++){              System.out.println(gen.next());          }      }  }  /*Cappuccino Mocha Cappuccino Latte*/  

6. 自定义泛型方法

泛型方法使得该方法能独立于类而产生变化。以下是一个基本的指导原则：无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型方法，因为它可以使事情更清楚明白。另外，对于一个static的方法而言，无法访问泛型类的类型参数。所以，如果static方法需要使用泛型能力，就必须使其成为泛型方法。
要定义泛型方法，只需将泛型参数列表置于返回值之前，就像下面这样：

public class GenericMethods {  //当方法操作的引用数据类型不确定的时候，可以将泛型定义在方法上      public <T> void f(T x){          System.out.println(x.getClass().getName());      }      public static void main(String[] args) {          GenericMethods gm = new GenericMethods();          gm.f(99);          gm.f("掌上洪城");          gm.f(new Integer(99));          gm.f(18.88);          gm.f('a');          gm.f(gm);      }  }  /* 输出结果： java.lang.Integer java.lang.String java.lang.Integer java.lang.Double java.lang.Character Generics.GenericMethods  */  

7. 构建复杂模型如list元组

泛型的一个重要好处是能够简单而安全地创建复杂的模型。如List元组。

class ThreeTuple2<A,B,C>{      public final A first;      public final B second;      private final C three;      public ThreeTuple2(A a,B b,C c){          first = a;          second = b;          three = c;      }      public String toString(){          return "(" + first + "," + second + "," + three + ")";      }  }  public class TupleList<A,B,C> extends ArrayList<ThreeTuple2<A,B,C>> {      static ThreeTuple2<Integer,String,Character> h(){          return new ThreeTuple2<Integer,String,Character>(99,"掌上洪城",'a');      }      public static void main(String[] args) {          TupleList<Integer,String,Character> ts = new TupleList<Integer,String,Character>();          ts.add(h());          ts.add(h());          for(ThreeTuple2<Integer,String,Character> ttp:ts)          System.out.println(ttp);              }  }  package Generics;  import java.util.ArrayList;  class ThreeTuple2<A,B,C>{      public final A first;      public final B second;      private final C three;      public ThreeTuple2(A a,B b,C c){          first = a;          second = b;          three = c;      }      public String toString(){          return "(" + first + "," + second + "," + three + ")";      }  }  public class TupleList<A,B,C> extends ArrayList<ThreeTuple2<A,B,C>> {      static ThreeTuple2<Integer,String,Character> h(){          return new ThreeTuple2<Integer,String,Character>(99,"掌上洪城",'a');      }      public static void main(String[] args) {          TupleList<Integer,String,Character> ts = new TupleList<Integer,String,Character>();          ts.add(h());          ts.add(h());          for(ThreeTuple2<Integer,String,Character> ttp:ts)          System.out.println(ttp);              }  }  /* 输出结果为： (99,掌上洪城,a) (99,掌上洪城,a)  */ 

8. 泛型的擦除

8.1 泛型的擦除

public class ErasedTypeEquivalence {      public static void main(String[] args) {          Class c1 = new ArrayList<String>().getClass();          Class c2 = new ArrayList<Integer>().getClass();          System.out.println(c1 == c2);      }  } /*      * Output: true      */// :~  

在泛型内部，无法获得任何有关泛型参数类型的信息。
ArrayList<String>和ArrayList<Integer>是相同的类型。

8.2 泛型的补偿

要想在表达式中使用类型，需要显式地传递类型的class对象。

class Building {  }  class House extends Building {  }  public class ClassTypeCapture<T> {      Class<T> kind;      public ClassTypeCapture(Class<T> kind) {          this.kind = kind;      }      public boolean f(Object arg) {          return kind.isInstance(arg);      }      public static void main(String[] args) {          ClassTypeCapture<Building> ctt1 = new ClassTypeCapture<Building>(Building.class);          System.out.println(ctt1.f(new Building()));          System.out.println(ctt1.f(new House()));          ClassTypeCapture<House> ctt2 = new ClassTypeCapture<House>(House.class);          System.out.println(ctt2.f(new Building()));          System.out.println(ctt2.f(new House()));      }  } /*      * Output: true true false true      */// :~  

9. 可以创建泛型数组吗？相应的应用场景怎么处理？

正如你在下面示例Erased.java中所见，不能创建泛型数组。一般的解决方案是任何想要创建泛型数组的地方都使用ArrayList:

public class Erased<T> {      private final int SIZE = 100;      public static void f(Object arg) {          if (arg instanceof T) {          } // Cannot make a static reference to the non-static type T          T var = new T(); // Error          T[] array = new T[SIZE]; // Error          T[] array = (T) new Object[SIZE]; // Unchecked warning      }  } /// :~  

使用ArrayList示例

public class ListOfGenerics<T> {      private List<T> array = new ArrayList<T>();      public void add(T item) {          array.add(item);      }      public T get(int index) {          return array.get(index);      }  } /// :~  

10. 泛型通配符‘？’怎么用？

可以解决当具体类型不确定的时候，这个通配符就是 ? ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

例如Class<?>classType = Class.forName("java.lang.String");

下面我们先看看这些程序：

//Code list 2void TestGen0Medthod1(List l) {　for (Object o: l)System.out.println(o);}

看看这个方法有没有异议，这个方法会通过编译的，假如你传入String，就是这样List＜String＞。
接着我们调用它,问题就出现了，我们将一个List＜String＞当作List传给了方法，JVM会给我们一个警告，说这个破坏了类型安全，因为从List中返回的都是Object类型的，而让我们再看看下面的方法。

//Code list 3void TestGen0Medthod1(List＜String＞ l) {　for (Object o: l)System.out.println(o);}

因为这里的List＜String＞不是List＜Object＞的子类,不是String与Object的关系，就是说List＜String＞不隶属于list＜Object＞,他们不是继承关系，所以是不行的，这里的extends是表示限制的。
类型通配符是很神奇的，List＜?＞这个你能为他做什么呢?怎么都是“？”，它似乎不确定，他总不能返回一个？作为类型的数据吧，是啊他是不会返回一个“？”来问程序员的？JVM会做简单的思考的，看看代码吧，更直观些。

//code list 4List＜String＞ l1 = newArrayList＜String＞();li.add(“String”);List＜?＞ l2 = l1;System.out.println(l1.get(0));

这段代码没问题的，l1.get(0)将返回一个Object。

11. 泛型限定（上限和下限）的表达式是怎样的？

上限：？extends E：可以接收E类型或者E的子类型对象。
下限：？super E：可以接收E类型或者E的父类型对象。
上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。

下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。

12. 可以将基本类型作为泛型参数吗？

泛型的类型参数只能是类类型（包括自定义类），不能是简单类型（基本数据类型）。

13、Java类库中的泛型有那些？

所有的标准集合接口都是泛型化的—— Collection< V >、List< V >、Set< V > 和 Map< K,V >。类似地，集合接口的实现都是用相同类型参数泛型化的，所以HashMap< K,V> 实现 Map< K,V> 等。
除了集合类之外，Java 类库中还有几个其他的类也充当值的容器。这些类包括 WeakReference、SoftReference 和 ThreadLocal。