C++泛型 && Java泛型实现机制

C++泛型 
　　C++泛型跟虚函数的运行时多态机制不同，泛型支持的静态多态，当类型信息可得的时候，利用编译期多态能够获得最大的效率和灵活性。当具体的类型信息不可得，就必须诉诸运行期多态了，即虚函数支持的动态多态。

　　对于C++泛型，每个实际类型都已被指明的泛型都会有独立的编码产生，也就是说list<int>和list<string>生成的是不同的代码，编译程序会在此时确保类型安全性。由于知道对象确切的类型，所以编译器进行代码生成的时候就不用运用RTTI，这使得泛型效率跟手动编码一样高。 
　　显然这样的做法增加了代码空间，相比运行时多态，是以空间换时间。

Java泛型 
　　当编译器对带有泛型的 Java 代码进行编译时，它会去执行类型检查和类型推断，然后生成普通的不带泛型的字节码，这种字节码可以被一般的 Java 虚拟机接收并执行，这种技术被称为擦除（erasure）。

　　可见，编译器可以在对源程序（带有泛型的 Java 代码）进行编译时使用泛型类型信息保证类型安全，同时在生成的字节码当中，将这些类型信息清除掉。 
　　如在代码中定义的List<object>和List<String>等类型，在编译后都会编程List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。

擦除的原则： 
　　1）所有参数化容器类都被擦除成非参数化的（raw type）；如List<E>、List<List<E>>都被擦除成List； 
　　2）所有参数化数组都被擦除成非参数化的数组；如List<E>[]，被擦除成List[]； 
　　3）Raw type的容器类，被擦除成其自身，如List 被擦除成List； 
　　4）原生类型（int,String还有wrapper类）都擦除成他们的自身； 
　　5）参数类型E，被擦除成Object； 
　　6）所有约束参数如<? Extends E>、<X extends E>都被擦除成E； 
　　7）如果有多个约束，擦除成第一个，如<T extends Object & E>，则擦除成Object；

来看个例子：

public class Pair<T> {
    public Pair(T first,T second) {
        this.first = first;
        this.second = second;
    }
    public T getFirst() { return first; }
    public T getSecond() { return second; }
    public void setFirst(T first) { this.first = first; }
    public void setSecond(T second) { this.second = second; }
    private T first;
    private T second;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

　　擦除后变为：

public class Pair {
    public Pair(Object first,Object second) {
        this.first = first;
        this.second = second;
    }
    public Object getFirst() { return first; }
    public Object getSecond() { return second; }
    public void setFirst(Object first) { this.first = first; }
    public void setSecond(Object second) { this.second = second; }
    private Object first;
    private Object second;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

public class QMI<T extends List> {
    public Interval(T value) {
        this.value = value;
    }
    private T value;
}

• 1
• 2
• 3
• 4
• 5
• 6

　　擦除后：

public class QMI {
    public Interval(List value) {
        this.value = value;
    }
    Private List value;
}

• 1
• 2
• 3
• 4
• 5
• 6

　　那么，进行类型擦除后，在调用时怎么知道其真实类型，放心吧，编译器帮我们做好了一切，以后上面的Pair为例： 
　　 原代码为：

    Pair<String> pair = new Pair<>("", "");
    pair.setFirst("QMI");
    pair.setSecond("Kang");
    String first = pair.getFirst();
    String second = pair.getSecond();

• 1
• 2
• 3
• 4
• 5

　　反编译后为：

    Pair pair = new Pair("", "");
    pair.setFirst("QMI");
    pair.setSecond("Kang");
    String first = (String)pair.getFirst();
    String second = (String)pair.getSecond();

• 1
• 2
• 3
• 4
• 5

　　可以看到，编译器帮我们做了自动类型转换。

　　对于泛型，我们可以利用Java单根继承特性实现类似效果，但是因为此时编译器并不做类型检查，这种检查是在运行时进行的，推迟了发现程序中错误的时间。

　　而利用泛型机制，编译器承担了全部的类型检查工作，确保类型的安全性。以List<Object>和List<String>为例来具体分析：

public void test() {
    List<String> list= new ArrayList<String>();
    List.add(123); //编译错误
}  

• 1
• 2
• 3
• 4

　　这里，声明为List的集合中却被添加了一个Integer类型的对象。这显然是违反类型安全的原则的，在某个时候肯定会抛出ClassCastException。因此，编译器禁止这样的行为。编译器会尽可能的检查可能存在的类型安全问题。对于确定是违反相关原则的地方，会给出编译错误。当编译器无法判断类型的使用是否正确的时候，会给出警告信息。此种机制有利于尽早地发现并改正错误。

　　让我再来看一个问题：

public class QmiV<T> {
    private T value;

    public T getValue() {
        return this.value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

　　擦除后：

public class QmiV<Object> {
    private Object value;

    public Object getValue() {
        return this.value;
    }

    public void setValue(Object value) {
        this.value = value;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

//子类
public class QmiVD extends QmiV<Person> {

    @Override
    public Person getValue() {
        return super.getValue();
    }

    @Override
    public void setValue(Person value) {
        super.setValue(value);
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

　　擦除后：

public class QmiVD extends QmiV<Person> {
    public QmiVD() {
    }

    public String getValue() {
        return (Person)super.getValue();
    }

    public void setValue(Person value) {
        super.setValue(value);
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

　　可以看到，对于setValue方法，父类的类型是Object，而子类的类型是Person，参数类型不一样，所以这里实现的不是重写，而是重载。 
实际中，是利用桥方法解决这个问题的。

　　桥方法就是生成一个中间层，其参数类型都是Object，也就是说，子类中真正覆盖父类两个方法的就是两个我们看不到的桥方法。桥方法的内部再去调用我们自己重写的那两个方法。

总结： 
　　C++泛型和Java泛型非常类似，但是有着本质不同。 
　　首先，Java 语言中的泛型不能接受基本类型作为类型参数――它只能接受引用类型。这意味着可以定义 List<Integer>，但是不可以定义 List<int>。 
　　其次，在 C++ 模板中，编译器使用提供的类型参数来生成不同代码。而 Java 中的泛型，编译器仅仅对这些类型参数进行擦除和替换。类型 ArrayList<Integer> 和 ArrayList<String> 的对象共享相同的类，并且只存在一个 ArrayList 类。

参考： 
https://zh.wikipedia.org/zh-cn/%E6%B3%9B%E5%9E%8B 
http://www.ibm.com/developerworks/cn/java/j-jtp01255.html 
http://www.infoq.com/cn/articles/cf-java-generics