Java中的泛型 --- Java 编程思想

前言

​ 我一直都认为泛型是程序语言设计中一个非常基础，重要的概念，Java 中的泛型到底是怎么样的，为什么会有泛型，泛型怎么发展出来的。通透理解泛型是学好基础里面中非常重要的。于是，我对《Java编程思想》这本书中泛型章节进行了研读。可惜遗憾的是，自己没有太多的经验，有些东西看了几次也是有点懵。只能以后有机会，再进行学习了。但是自己也理解了挺多的。下面就是自己对于泛型的理解与感悟。如有不对，望指出。

概念

由来： Java 一开始设计之初是没有泛型这个特性的，直到jdk 1.5中引入了这个特性。Java 的泛型是由擦除来实现的。要知道擦除是什么？往下看。

概念：一般的类和方法，只能使用具体的类型；要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。泛型实现了参数化类型的概念，使代码应用于多个类型。泛型在编程语言中出现时，其最初的目的是希望类和方法具有广泛的表达能力。

简单泛型

​ 有很多原因促成泛型的出现，其中最重要的一个原因就是为了创造容器类。我们暂时不指定类型，而是稍后再决定具体使用什么类型。要达到这个目的，需要使用类型参数，用尖括号括住，放在类名的后面。然后使用这个类的时候，再用实际的类型替换此类型参数。在下面例子中，T就是类型参数。代码如下：

public class Holder<T> {
    private T a;

    public Holder(T a) {
        this.a = a;
    }

    public void set(T a) {
        this.a = a;
    }

    public T get(){
        return a;
    }

    public static void main(String[] args) {
        Holder<String> h = new Holder<>();
        h3.set("hello");
        String a = h3.get();
    }
}
class Automobile{}

​ 但是往往很多的源码中一些通用的类都是有多个泛型参数，譬如 java.util.function.BiFunction 中就有三个类型参数 T,U,R 。

接口泛型

​ 泛型在接口上的运用是非常多的，例如迭代器(Iterable)中的 Iterator 。

public interface Itreator<T>{
    // 判断是否还有元素
    boolean hasNext();
    // 洗一个元素
    E next();
    ....
}

​ 这个是我们都很常用的吧，其实接口使用泛型和类使用泛型没什么区别。

泛型方法

​ 泛型方法，在返回参数类型前面添加泛型参数列表，由<>括着

eg:

    // 泛型方法 两个泛型参数，T,R 返回类型为 R
  public <T, R> R test(T t, R r){
        return r;
    }

​ 泛型方法使得该方法独立于类而产生变化。在需要编写泛型代码的时候，基本的的指导原则是：无论何时，只要你能做到，就尽量使用泛型方法。意思是如果使用泛型方法可以代替整个类的泛型化，那就用泛型方法，因为它可以使事情更加清楚明白。另外对于static的方法而言，无法访问泛型类的类型参数，所以如果static方法需要使用泛化能力，就必须使其成为泛型方法。

泛型的擦除

​ 在看 《Java编程思想》 中泛型章节中 ’擦除的神秘之处‘ 这一小节的时候，看的我特别的晕晕乎乎的，然后再往下面看时就越来越混了。 特别是看到’边界‘，’通配符‘ 这块了就有点懵了。首先看下什么是擦除。在泛型代码内部，无法获得有关泛型参数类型的信息。 Java 的泛型是由擦拭来实现的，这意味着当你使用泛型的时，任何具体的类型都被擦除了，你唯一知道的就是你在使用一个对象。由于 Java 一开始没有引入 泛型这个特性，在为了兼容 JDK 老版本的情况下。擦除是 Java 泛型实现的一种折中。 因此你在运行时 List<String> 和 List<Integer> 是一样的，注意是在运行时，但是在编译时，List<String> 表示这个 String 类型的 List 容器， List<Integer> 表示这个时 Integer 类型的List容器。 举个例子，例子来源于 Java编程思想

#include <iostream>
using namespace std;

temple<class T> class Manipulator{
    T obj;
    public ：
        Manipulator(T x){obj = x;}
        void manipylate() {obj.f();}

};
class HasF{
public:
    void f(){cout<<"HasF::f()"<< endl;}
};

int main(){
    HasF hf;
    Manipulator<HasF> manipulator(hf);
    manipulator.manipylate();
}

输出 HasF:f()

​ Manipulator 类存储了一个类型T的对象，在 manipylate 方法里，他在 obj上调用了方法 f() ; 它是怎么知道 f() 是类型参数T 中有的方法呢？ 当你实例化这个模板的时，c++编译器将进行检查，如果他在 Manipulator<HasF> 被实例化的这刻，它看到HasF如果拥有这个方法 f(), 就编译通过，否则不通过。 这个代码就算不会 c++ 的人应该也看的懂吧。我们看下 Java 的版本：

public class HasF{
    public void f(){
        System.out.println("HasF::f()");
    }
}

class Manipulator<T>{
    private T obj;
    public Manipulator(T obj){
        this.obj = obj;
    }

    public void manipulator(){
        //错误： 这个是不可以调用 f() 这个方法的。
        // obj.f();
    }

    public static void main(String[] args){
        HasF hf = new HasF();
        Manipulator<HasF> manipulator = new Manipulator<>(hf);
        manipulator.manipulator();
    }
}

看到没有，Java 中有了擦除， Java 编译器不知道 obj 中有没有 f() 这个方法的事情。

泛型的边界

T extends Class

​ Java 中的泛型，在编译时，T代表一种类型，如果没有指定任何的边界，那么他就相当于 Object 。 我们可以通过 extends 关键字，给泛型指定边界。 上面代码我们为了能够调用f()， 我们可以协助泛型类，给定泛型类的边界，告诉编译器必须接受遵循这个边界的类型。这里用 extends 关键字。 将上面代码改成

public class HasF{
    public void f(){
        System.out.println("HasF::f()");
    }
}

class Manipulator<T extends HasF>{
    private T obj;
    public Manipulator(T obj){
        this.obj = obj;
    }

    public void manipulator(){
        obj.f();
    }

    public static void main(String[] args){
        HasF hf = new HasF();
        Manipulator<HasF> manipulator = new Manipulator<>(hf);
        manipulator.manipulator();
    }
}

输出：HasF::f()

这样子在编译的时候就相当告诉编译器 Manipulator 类中 obj 的参数类型 为 HasF 或着它的子类。

? extends T

? 是泛型表达式中的通配符。 ? extends T 表示： T 数据类型或着 T 的子类数据类型。 举个例子

class Vegetables{}
// 白菜
class Cabbage extends Vegetables{}
// 小白菜
class Pakchoi extends Cabbage{}
//大蒜
class Garlic extends Vegetables{}

public class Main{
    public static void main(String[] args) {
        // 这个是会报错的。
        // ArrayList<Vegetables> vegetables = new ArrayList<Cabbage>();
    }
}

​ 上面的中 main 方法里面是报错的因为，ArrayList<Vegetables>表示这个ArrayList容器中只能存放蔬菜，new ArrayList<Cabbage>() 表示 这个使一个只能放白菜的容器。这两个容器是不可以相等的，类型不一样。但是我们可以通过 ? extends T 来解决这个问题，代码如下：

public class Main{
    public static void main(String[] args) {
        ArrayList<? extends Vegetables> vegetables = new ArrayList<Cabbage>();
        // 报错 不能添加白菜进去
        // vegetables.add(new Cabbage());
    }
}

​ 我们可以用 vegetables 表示 new ArrayList<Cabbage>()， 这是向上转型。但是，为什么 vegetables.add(new Cabbage()) ; 会报错，因为 ArrayList<? extends Vegetables> 表示这个 ArrayList 容器中能够存放任何蔬菜。 但是 ArrayList 具体是什么容器，完全不知道，add 的时候，你添加什么东西进去到这个容器中都是不安全的。 这个时候，我们可以用 ? super T 来进行操作，具体往下看。

? super T

? super T 表示： T 数据类型 或着 T的超类数据类型， super 表示超类通配符。 上面代码可以用以下表示

public class Main{
    public static void main(String[] args) {
        ArrayList<? super Cabbage> cabbages = new ArrayList<Vegetables>();

        cabbages.add(new Cabbage());
        cabbages.add(new Pakchoi());

        //        cabbages.add(new Vegetables());
        System.out.println(cabbages);
    }
}

上面 ArrayList<? super Cabbage> 表示ArrayList这个容器中怎么都可以存放 Cabbage 以及Cabbage子类的数据类型。 cabbages 指向的是 蔬菜的容器类。 add 进去的是白菜以及白菜的子类型数据。这个当然是支持的。

? extends T VS ? super T

? extends T ，? super T 一般用于方法参数列表。

public class Main{
    public static void main(String[] args) {

        List<Cabbage> cabbages = new ArrayList<>();
        cabbages.add(new Cabbage());
        cabbages.add(new Cabbage());
        cabbages.add(new Cabbage());
        extendsTest(cabbages);
        List<? super Cabbage> list = superTest(new ArrayList<Vegetables>());
        System.out.println(list);
    }

    public static void extendsTest(List<? extends Vegetables> list){
        for (Vegetables t : list){
            System.out.println(t);
        }
    }

    public static List<? super Cabbage> superTest(List<? super Cabbage> list){
        list.add(new Cabbage());
        list.add(new Pakchoi());
        return list;
    }
}

? extends T 表示消费者 list 然后把里面的数据消费掉。

? super T 表示生产者 传入一个list 然后往里面添加数据，进行其他操作。

总结

​ 对于 ? extends Class ，? extends T，? super T,不是很理解的，可以自己把例子写一下，然后想一想。Java 泛型的特性在很多开源的框架上是用的非常多的。这快需要深入的理解一下，我想随着敲代码的年限上，应该到了后面会有不一样得理解吧。现在通过书上能够知道，理解得就只有这么多了。