泛型原理

1、http://blog.csdn.net/ol_beta/article/details/6192382

    本博客通过示例演示讲解了List<T>,编译器在编译之后，T本质就是一个Object。该例子值得一看

JDK1.5增加的新特性里面有一个就是泛型。对于泛型的评价，褒贬不一，废话不多说，先来看看他的原理。

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器拦截源程序中的非法输入，编译器编译带类型说明的集合时会去掉类型信息，对于参数化得泛型类型，getClass()方法的返回值和原始类型完全一样。

对于下面这个源程序： 

public class Oliver {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("str1");
        list.add("str2");
        String str = list.get(0);
    }
}

编译成Oliver.class后反编译的内容： 

public class Oliver {
    public Oliver() {
    }
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("str1");
        list.add("str2");
        String str = (String) list.get(0);
    }
}

也就是说java的泛型只是在编译器做了参数限制，其实对性能并没有什么优化！

由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它的类型数据。 
下面代码展示利用反射机制跳过编译器检查： 

public class Oliver {
    public static void main(String[] args) throws Exception {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.getClass().getMethod("add", Object.class).invoke(list, "ssss");
        System.out.println("list:" + list.get(0));
    }
}

输出结果： 
list:ssss

对于java泛型，Bruce Ecke（Thinking in Java作者）曾经给出这样的评论： 
Guess what. I really don't care. You want to call it "generics," fine, implement something that looks like C++ or Ada, that actually produces a latent typing mechanism like they do. But don't implement something whose sole purpose is to solve the casting problem in containers, and then insist that on calling it "Generics." Of course, Java has long precedence in arrogantly mangling well- accepted meanings for things: one that particularly stuck in my craw was the use of "design pattern" to describe getters and setters. In JDK 1.4 we were told some lame way to use assertions which was a backward justification for them being disabled by default. JDK 1.4 also had to invent its own inferior logging system rather than using the openly created, well-tested and well-liked Log4J. And we've also been told many times about how Java has been as fast or faster than C++, or about how one or another feature is great and flawless. I point to the threads implementation which has had major changes quietly made from version to version with not so much as a peep of apology or admission that "hey, we really screwed up here." Or maybe I was just not on that particular announcement list.

 2、http://irfen.iteye.com/blog/1888312   

一、Java泛型介绍

    泛型是Java 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

       Java泛型被引入的好处是安全简单。

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

 优点：

    泛型的好处是在编译的时候检查类型安全，

    并且所有的强制转换都是自动和隐式的，提高代码的重用率。

    泛型在使用中还有一些规则和限制：

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

2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

3、泛型的类型参数可以有多个。

4、泛型的参数类型可以使用extends语句，例如。习惯上成为“有界类型”。

5、泛型的参数类型还可以是通配符类型。

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

    泛型还有接口、方法等等，内容很多，需要花费一番功夫才能理解掌握并熟练应用。

二、Java泛型实现原理：类型擦出

       Java的泛型是伪泛型。在编译期间，所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出（type erasure）。

       Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。

    如在代码中定义的List<object>和List<String>等类型，在编译后都会编程List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。类型擦除也是Java的泛型实现方法与C++模版机制实现方式（后面介绍）之间的重要区别。

三、类型擦除后保留的原始类型

    原始类型（raw type）就是擦除去了泛型信息，最后在字节码中的类型变量的真正类型。无论何时定义一个泛型类型，相应的原始类型都会被自动地提供。类型变量被擦除（crased），并使用其限定类型（无限定的变量用Object）替换。

class Pair<T> {
  private T value;
  public T getValue() {
    return value;
  }
  public void setValue(T  value) {
    this.value = value;
  }
}

 Pair<T>的原始类型为：

class Pair {
  private Object value;
  public Object getValue() {
    return value;
  }
  public void setValue(Object  value) {
    this.value = value;
  }
}

    因为在Pair<T>中，T是一个无限定的类型变量，所以用Object替换。其结果就是一个普通的类，如同泛型加入java变成语言之前已经实现的那样。在程序中可以包含不同类型的Pair，如Pair<String>或Pair<Integer>，但是，擦除类型后它们就成为原始的Pair类型了，原始类型都是Object。

如果类型变量有限定，那么原始类型就用第一个边界的类型变量来替换。

比如Pair这样声明：

public class Pair<T extends Comparable& Serializable> {

    那么原始类型就是Comparable

    注意：

    如果Pair这样声明public class Pair<T extends Serializable&Comparable> ，那么原始类型就用Serializable替换，而编译器在必要的时要向Comparable插入强制类型转换。为了提高效率，应该将标签（tagging）接口（即没有方法的接口）放在边界限定列表的末尾。

    要区分原始类型和泛型变量的类型

    在调用泛型方法的时候，可以指定泛型，也可以不指定泛型。

    在不指定泛型的情况下，泛型变量的类型为 该方法中的几种类型的同一个父类的最小级，直到Object。

    在指定泛型的时候，该方法中的几种类型必须是该泛型实例类型或者其子类。

public class Test{
  public static void main(String[] args) {
    /**不指定泛型的时候*/
    int i=Test.add(1, 2); //这两个参数都是Integer，所以T为Integer类型
    Number f=Test.add(1, 1.2);//这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Number
    Object o=Test.add(1, "asd");//这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Object

    /**指定泛型的时候*/
    int a=Test.<Integer>add(1, 2);//指定了Integer，所以只能为Integer类型或者其子类
    int b=Test.<Integer>add(1, 2.2);//编译错误，指定了Integer，不能为Float
    Number c=Test.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float
  }

  //这是一个简单的泛型方法
  public static <T> T add(T x,T y){
    return y;
  }
}

    其实在泛型类中，不指定泛型的时候，也差不多，只不过这个时候的泛型类型为Object，就比如ArrayList中，如果不指定泛型，那么这个ArrayList中可以放任意类型的对象。

四、C++模板实现

    虽然我不懂C++，但是我也在网上找了下C++的实现方式。

    在c++中为每个模板的实例化产生不同的类型，这一现象被称为“模板代码膨胀”。

比如 vector<int>， vector<char>, vector<double>, 这里总共会生成3份不同的vector代码。