Java 泛型 理解

泛型，实现了参数化类型的概念，使代码可以应用于多种类型。
容器类，范型的主要目的之一就是用来指定容器需要支持什么类型的对象，而且由编译器来保证类型的正确性。如List,Map,Set等
Object类型的对象，在没有泛型的Java SE5之前，可以用Object类型的对象来实现类似于泛型的功能。

public class Example{
  private Object a;
  public void Example(Object a) {this.a=a;}
  public void set(Object a) {this.a=a;}
  public Object get() {return a;}
  public static void main(String[] args) {
  Example e=new Example("This is a string");
  String s=(String) e.get();
  e.set(1314);
  Integer i=(Integer) e.get();
  }
}

类型参数，用尖括号括住，放在类名后面。使用的时候，再用实际的类型替换此类型参数。下面的T

public class Example<T>{
  private T a;
}

Java泛型的核心概念，告诉编译器想使用什么类型，然后编译器帮你处理一切细节。
泛型接口，泛型应用于接口

public interface Example<T>{T next();}

泛型方法，泛型应用于方法

public clss Example{
  public <T> void f(T x){ System.out.println( x.getClass().getName();}
  public static void main(String[] args) {
  Example e=new Example();
  e.f("This is a string");
  e.f(1314);
  e.f(1314.0);
  }
}

泛型类和泛型方法的使用选择，能只使用泛型方法办到的就使用泛型方法，相对来说比使用泛型类清楚明白。
!!! static方法无法访问泛型类的类型参数，所以static方法需要使用泛型能力，就必须使其成为泛型方法。
``
自动打包和自动拆包，Java泛型参数不支持基本类型，但SE5之后支持来自动打包自动拆包，在泛型方法的例子中可以看到对于一个数值1314，会被包装成Integer对象，这就是打包：将基本类型的值包装为对应的对象，如int对应Integer。
类型参数推断，只对赋值操作有效，其他时候不起作用，调用泛型方法在作为参数的时候，泛型方法的返回值被赋值给一个Object类型的变量。

Map<String, List<Integer>> e1=new HashMap<>();
Map e2=new HashMap<String, List<Integer>>();

可变参数和泛型方法，调用下面的方法可以实例化任意长度列表

public static <T> List<T> makeList(T... args){
  List<T> result=new ArrayList<>();
  for(T item:args) {result.add(item);}
  return result;
}

擦除Java是用擦除来实现泛型的，意味着在使用泛型的时候，任何具体的类型信息都被擦除掉了，我们唯一知道的就是在使用一个对象，下边的例子输出说明了这个问题。

//擦除例子
public static void main(String[] args) {
  System.out.println(new ArrayList<Integer>().getClass());
  System.out.println(new ArrayList<String>().getClass());
  System.out.println(Arrays.toString(new ArrayList<String>()
  .getClass().getTypeParameters()));
}

擦除例子输出
因为擦除问题的存在，与C++对比，Java泛型的泛化能力减弱很多，需要有一个折衷的方案来解决这个问题，就有了下边边界定义的出现

边界<T extends XClass>，关键字extends声明T必须具有类型XClass或者XClass的子类，这就解决了因为擦除无法在泛型代码内部获得关于参数类型任何信息的问题，告知编译器擦除的边界在哪里。
因为泛型的类型参数会擦除到它的第一边界，下面的例子Holder1，T会擦除到ArrayList，就好像在类的声明中把T换成了ArrayList一样，从直觉上看，觉得Holder1和Holder2好像也没啥区别。但是从getT的返回类型上看，T肯定是要比直接返回ArrayList更泛化一些，也就更灵活。
这也说明了，只有足够复杂的代码才有必要使用泛型，比如希望代码跨多个类工作时。

class Holder1<T extends ArrayList> {
    T t;
    Holder1(T t) {
        this.t = t;
    }
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
}
class Holder2 {
    ArrayList t;
    public ArrayList getT() {
        return t;
    }
    public void setT(ArrayList t) {
        this.t = t;
    }
}

擦除的补偿，因为在泛型类定义中，擦除后没有类型参数，我们无法在代码里使用new T()这样的写法实例化，但是可以通过传递一个工厂对象，来解决这个问题。最方便的就是Class对象，使用类型标签，通过newInstance()创建这个类型的新对象。但要保证传入的类型T是有默认构造函数的。

class Test{
    public static void main(String[] args) {
        ClassFactory<String> classFactory=new ClassFactory<String>(String.class);
    }
}
class ClassFactory<T> {
    T t;
    public ClassFactory(Class<T> t) {
        try {
            this.t=t.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

Class<T> t1和T t2，t1被声明成一个类类型变量，其值取决于T是什么类，可以是如String.class、Integer.class、XXX.class等，t2是T类型的实例
<?>，无界通配符，可以被认为是一种装饰，告诉编译器我想使用泛型，在这又不是要用原生Object类型，但是泛型参数又可以持有任何类型。
<? extends T>，
? super T