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

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

2|0概念

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

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

3|0简单泛型

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

4|0接口泛型

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

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

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

5|0泛型方法

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

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

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

6|0泛型的擦除

在看《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() 这个方法的事情。

7|0泛型的边界

7|1T 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 或着它的子类。

7|2? 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 来进行操作，具体往下看。

7|3? 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 进去的是白菜以及白菜的子类型数据。这个当然是支持的。

7|4? 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 然后往里面添加数据，进行其他操作。

8|0总结

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

__EOF__

作　　者：家里那只橘猫
出　　处：https://www.cnblogs.com/Krloypower/p/10454507.html