Java核心技术第八章——泛型程序设计（1）

1.泛型程序设计

泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。例如：不希望为了聚集String和Integer对象分别设计不同的类。（个人觉得此处说的聚集译为：创建一个对象，属性可以为String和Integer类型。但是却有着相同的行为或属性）

代码如下：

public class StringTest {
    private String age;
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
}

public class IntegerTest {
    private Integer age;
    public Integer getAge() {
        return Age;
    }
    public void setAge(Integer age) {
        this.age= age;
    }
}

可以看到上面两个类都有age属性和方法。只是他们的属性类型有所不同。那么我们则可以使用到泛型：例

public class GenericTest<T> {
    private T age;
    public T getAge() {
        return age;
    }
    public void setAge(T age) {
        this.age= age;
    }
}

然后只需要如下调用

    public static void main(String[] args){
        GenericTest<String> genericString= new GenericTest<>();
        GenericTest<Integer> genericInteger = new GenericTest<>();
    }

这样我们就很好的解决了代码重用的问题，不是吗？看不懂？不急，我只是说了泛型的好处，让我们慢慢往下了解。

2.定义简单的泛型类

没接触过泛型的同学看到上面例子中的T可能会觉得一脸懵逼，其实T只是一个类的类型变量（虽然你可以定义A、B、C...，但是我们还是要规范点的是吧），然后T需要使用尖括号括起来，当你定义多个类型变量时。可以看下面的Generic类，

public class Generic<T,U> {
    private T size;
    private U length;
    ...
}

当你传入Generic<Integer,String> 时，你可以把这个类想象成如下使用

public class Generic {
    private Integer size;
    private String length;
    ...
}

所以，泛型类其实可以看做普通的工厂类。

3.泛型方法

上面介绍了一个简单的泛型类，让我们来看看泛型方法是怎么写吧。

public class ArrayAlg {
    public static <T> T getMiddle(T... a){
        return a[a.length/2];
    }
}

可以看到，ArrayAlg是一个普通类，并不是一个泛型类。说明：泛型方法可以定义在普通类和泛型类中。

当我们调用getMiddle方法时，在方法名前的尖括号放入具体类型：

String s = ArrayAlg.<String>getMiddle("John","Q","Min");

看起来是不是很别扭？其实可以省略<String>类型参数，编译器会使用String[ ]数组与泛型T[ ]进行匹配推断出一定是String，这个应该就是他们私下bilibili的规则了。变成：

String s = ArrayAlg.getMiddle("John","Q","Min");

有的小伙伴可能会想到，酱紫的话，我能不能瞎比的传参数进去？例：

Double middle2 = ArrayAlg.getMiddle(3.14,0);

其实当你这样写的时候编译器就已经提示错误了，因为第二个参数编译器会默认认为是Integer类型。解决方法有两种：

1.把Double改成Number类型，因为Number类型为Double和Integer的父类。

2.自己改代码去吧，谁让你瞎搞。

4.类型变量的限定

有时候，类或方法需要对类型变量加以约束，假如，某个泛型方法需要使用到Comparable接口的compareTo方法，那我们则需要限制传进来的参数必须实现Comparable接口，例：

public static <T extends Comparable> T minmax(T[] a){
　　compareTo...
}

传进来的参数a则必须实现Comparable接口。假如传进来参数需要实现Comparable和Serializable两个接口，则

public static <T extends Comparable&Serializable> Pair<T> minmax(T[] a){
  compareTo...
}

叮咚！那么传进来的参数需要继承某个类怎么写？其实是一样的。传进来的参数需要继承某个类、实现某个接口都是使用extends关键字来控制。原因：选择关键字extends的原因是更接近子类的概念，并且Java的设计者也不打算在语言中再添加一个新的关键字

5.泛型代码和虚拟机

5.1类型擦除

Java 的泛型在编译器有效，在运行期被删除，也就是说所有泛型参数类型在编译后都会被清除掉

例如：

public class GenericClass<T> {
    private T first;
    public T getFirst() {
        return first;
    }
    ...
}

擦除类型后

public class GenericClass {
    private Object first;
    public Object getFirst() {
        return first;
    }
    ...
}

可以看到，类型擦除后的GengericClass和没引用泛型没有什么两样。而且，当你使用GenericClass<String>后，也是变成原始的GenericClass类型。

但是当我们使用限定类型变量后，类型擦除后将会使用限定类型。例：

public class GenericClass<T extends Comparable> {
    private T first;
    ...
}

可以看到限定了传进来的参数需要实现Comparable接口，那么类型擦除后如下：

public class GenericClass{
    private Comparable first;
    ...
}

问题：当你限定了参数需要实现Comparable和Serializable接口，就是GenericClass<T extends Comparable&Serializable>时，类型擦除后会变成怎样呢？

public class GenericClass{
    private Comparable first;
    ...
}

虚拟机会把首位实现的接口（此处为Comparable），转为擦除后对象类型。当然，如果你这样写GenericClass<T extends Serializable&Comparable> ，那么擦除后的类型为Serializable。

5.2翻译泛型表达式

当程序调用泛型方法时，如果擦除返回类型， 编译器将插入强制类型转换。例如List集合源码：

public interface List<E> extends Collection<E> {
    ...
    E get(int index);
    ...
}

当不使用类型变量时，取出来的值是Object，而定义了String类型变量时，编译器将插入强制类型转换：

List list1 = new ArrayList();
list1.add("1");
list1.get(0); //Object

List<String> list2 = new ArrayList<>();
list2.add("1");
list2.get(0); //String

但是在虚拟机中时，list2.get(0)在调用时翻译成了两条虚拟机命令：

1.对原始方法List集合的get方法调用

2.将返回的Object进行强制类型转换成String

5.3翻译泛型方法

当GenericSubClass类继承了Generic类时，泛型方法会有什么变化？

public class Generic<T> {
    private T size;
    public T getSize() {
        return size;
    }
    ...
}

public class GenericSubclass extends Generic<Integer> {
    @Override
    public Integer getSize() {
        return super.getSize();
    }
}

此时的@Override真的是重写父类方法吗？到了运行期间，Generic被类型擦除后getSize方法返回类型变成Object：

public Object getSize() { return size; }

而GenericSubclass的getSize方法的返回类型却是Integer：

public Integer getSize() { return super.getSize(); }

这并不是重写父类的方法，因为方法并不一样，所以导致GenericSubclass在虚拟机中却有了两个getSize方法：

public Integer getSize() {  ...  }
public Object getSize() {  ...  }

导致的原因就是类型擦除与多态发生了冲突。要解决此问题，虚拟机自动在GenericSubclass中生成了一个桥方法：

public Integer getSize() { return (Integer)super.getSize(); }

最后，虚拟机就会调用自己生成的桥方法来解决此冲突。

若有不足之处，请各位大牛在下面留言指出，Thanks♪(･ω･)ﾉ