Java中泛型总结(全面)

参考资料：

书：Java编程思想

博客：
https://blog.csdn.net/wang__qin/article/details/81415223
https://blog.csdn.net/harvic880925/article/details/49883589

https://blog.csdn.net/qq_27093465/article/details/73229016

https://blog.csdn.net/harvic880925/article/details/49872903

https://blog.csdn.net/harvic880925/article/details/49883589

目录

                                   Java泛型学习总结（全面）

1.    泛型的清单及概括

1)    泛型的知识清单

A.    泛型定义位置：接口、类、方法

B.    泛型通配符?：是一个实参类型，不是形参。

C.    泛型的类型限定：extends、super

D.    泛型方法：传入Class clazz的作用？

2)    什么是泛型？为什么使用泛型？

3)    泛型类型字母规范

4)    定义泛型时：不限定个数，逗号隔开即可

5)    泛型示例及优点分析

A.    ArrayList、HashMap典型示例,v>

B.    泛型的优点

6)    泛型的擦除与补偿：泛型只在编译阶段有效

7)    注意几点：

2.    泛型通配符？

1)    引入：

2)    如何解决上面的问题？

3)    泛型通配符？

3.    泛型类型绑定

1)    简单示例

2)    泛型之类型绑定：extends绑定：限定类型范围，BoundingType

A.    示例：绑定接口

B.    示例：绑定类

C.    用&实现多个限定；同时定义多个泛型，逗号隔开即可

4.    通配符？及其extends和super的限定

1)    T与?的区别：为什么引入"?"

2)    通配符?的向下限定extends

A.    通过extends向下限定泛型类型(包括边界类型)

B.    注意：利用定义的变量，只可取其中的值，不可修改

3)    通配符？的super绑定

A.    

B.    super通配符实例内容：能存不能取

4)    泛型上限与下限的使用场景

5)    注意：

6)    集合示例：

7)    通配符？主要使用方式

5.    泛型接口（简单）

1)    泛型接口的定义

2)    泛型接口的使用

3)    示例

6.    泛型类（简单）

1)    泛型类的定义

2)    泛型类的示例

3)    问题：定义的泛型类，就一定要传入泛型类型实参么？

4)    实现泛型接口

7.    泛型方法

1)    泛型方法的简单示例

2)    泛型方法的语法

3)    示例：

A.    泛型方法判断

B.    泛型必须提前定义

C.    泛型类和泛型方法同时定义泛型T

D.    泛型可变参数

4)    静态泛型方法

5)    泛型数组T[]：不能直接创建泛型数组。

6)    Class的使用

7)    泛型方法总结

8.    Java中为什么不允许直接创建泛型数组

1)    父类类型数组可以接受子类类型数组

2)    Java中为什么不允许直接创建泛型数组？ 

3)    Java中不能直接创建泛型数组，但是可以定义泛型引用

9.    最后问题总结

1)    T与？的区别

2)    泛型方法如何判断？

---

---

                                   Java泛型学习总结（全面）

1.    泛型的清单及概括

1)    泛型的知识清单

A.    泛型定义位置：接口、类、方法

       泛型可以定义在接口、类、方法上，因此分成三种：接口泛型、类泛型、方法泛型。
       在代码中，使用最多的肯定就是方法了，因此，在类或接口上定义泛型，很多情况下也是在方法上使用的，因此方法泛型至关重要。
      泛型类，是在实例化类的时候指明泛型的具体类型；
      泛型方法，是在调用方法的时候指明泛型的具体类型。

B.    泛型通配符?：是一个实参类型，不是形参。

为什么引入泛型通配符? ? 其解决了什么问题？

C.    泛型的类型限定：extends、super

extends和super为何引入？又分别解决了什么问题？
重点：熟练掌握泛型方法的使用。

D.    泛型方法：传入Class clazz的作用？

2)    什么是泛型？为什么使用泛型？

泛型：是JDK1.5 推出来的安全机制，是给编译器使用的技术，用于编译时期，保证了类型的安全。泛型在集合框架中使用最为广泛。(1.Java的每次升级都是为了三个目的：简化书写、提高效率、提高安全性。泛型的提出是为了提高安全性，基本数据类型的自动装箱和拆箱是为了简化书写。)
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
参数化类型：泛型的本质是参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

3)    泛型类型字母规范

任意一个大写字母都可以，意义是完全相同的。但为了提高可读性，大家还是用有意义的字母比较好，一般来讲，在不同的情境下使用的字母意义如下：
 E — Element，常用在java Collection里，如：List,Iterator,Set
 K,V — Key，Value，代表Map的键值对；
 N — Number，数字； T — Type，类型，如String，Integer等等；
如果这些还不够用，那就自己随便取吧，反正26个英文字母呢。
再重复一遍，使用哪个字母是没有特定意义的！只是为了提高可读性！！！！

4)    定义泛型时：不限定个数，逗号隔开即可

用逗号隔开，写上其它的任意大写字母即可。
public class Point{…}
public class Point{…}

5)    泛型示例及优点分析

A.    ArrayList、HashMap典型示例

ArrayList strList = new ArrayList();
public class ArrayList extends AbstractList
        implements List, RandomAccess, Cloneable, java.io.Serializable
不采用泛型的情况下，List默认每个元素都是Object类型，这时候如果添加一个String类型，再获取的时候需要强转成String，类型转换在编译时不会检查，在运行时如果类型转换错误就会报错。因此引入泛型，可以避免了类型转换可能引起的错误。

B.    泛型的优点

get时不需要类型强制转换；若强制类型转换，很容易造成类转换异常：java.lang.ClassCastException；将可能出现的类转换异常提前到了编译时期，提高了安全性；同时，避免了类型的强制转换的麻烦。set时进行类型检查，若类型不一致，编译时就会报错。
可以这么说，泛型的引入就是为了避免出现类转换异常的。
在实际的编程过程中，使用泛型可以简化开发，且能很好的保证代码质量。
在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。

6)    泛型的擦除与补偿：泛型只在编译阶段有效

泛型的擦除：泛型只用于编译时，供编译器判断类型正确与否，而到了程序运行的时候，会将泛型擦除掉，编译时生成的class文件中是不带泛型的，这称为泛型的擦除。擦除的目的是：为了兼容旧版本的类加载器，否则类加载器还需要进行升级。
泛型的补偿：如果采用了泛型擦除后，对象仍然被提升为Object类型，还需要进行强制类型转换，为了省略掉此转换，引入了泛型的补偿，即在运行时，通过获取元素的类型完成类型的转换工作，不需要再进行强制类型转换了。 （利用Object的getClass()方法）。
Java泛型仅仅是在编译阶段有效，在编译之后，程序会采取去泛型话的措施。
在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦除，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。
本质一句话：带有不同泛型同一类型逻辑上看成是多个不同类型，本质上是相同的类型。
如ArrayList、ArrayList编译阶段是不同类型，在运行时是相同的。

7)    注意几点：

A.    不能对确切的泛型类型使用instanceof操作；如下面是非法的

if(ex_num instanceof Generic){ }

B.    不能定义泛型数组。

C.    Integer是Number的子类，但是List不是List的子类。

D.    泛型<>可以传入引用数据类型，包括类、接口、数组，不能传入基本数据类型，但是可以传入基本数据类型数组，如int[]。

2.    泛型通配符？

1)    引入：

在Generic泛型类中，定义方法：
public void showKeyValue(Generic obj){
    Log.d("泛型测试","key value is " + obj.getKey());
}
Generic gInteger = new Generic(10);
Generic gNumber = new Generic(10);
//gNumber = gInteger;//错误的
//showKeyValue(gInteger);//错误的
Integer是Number的子类，但是Generic不能看做是Generic的子类。

2)    如何解决上面的问题？

如何解决上面问题？总不能再定义一个新方法来处理Generic类，这显然与Java多态思想相违背。因此，实现一个方法能同时接收Generic和Generic的引用类型，由此类型通配符应运而生。
public void showKeyValue1(Generic obj){
    Log.d("泛型测试","key value is " + obj.getKey());
}

3)    泛型通配符？

类型通配符一般是使用？代替具体的类型实参，注意了，此处’？’是类型实参，而不是类型形参。再直白点的意思就是，此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。

3.    泛型类型绑定

1)    简单示例

public class Point {
    private T x;
    private T y;
    public Point(T x, T y) {
        this.x = x;
        this.y = y;
    }
    getter setter…
}

A.    注意：任何的泛型变量都是派生自Object，所以在填充泛型变量时，只能使用派生自Object的类，比如String, Integer, Double，等而不能使用原始的变量类型，比如int,double,float等。
B.    问题：在泛型类Point内部，利用泛型定义的变量T x能调用哪些方法呢？
答案：只能调用Object所具有的方法，因为编译器根本不知道T具体是什么类型，只有在运行时，用户给什么类型，他才知道是什么类型。编译器唯一能确定的是，无论什么类型，都是派生自Object的，所以T肯定是Object的子类，所以T是可以调用Object的方法的。
C.    问题：问题又来了，如果我想写一个可以找到最小值的泛型类；由于不知道用户会传什么类型，所以要写一个接口,让用户实现这个接口来自已对比他所传递的类型的大小。因此引入extends关键字。

2)    泛型之类型绑定：extends绑定：限定类型范围，BoundingType

注意：//T只能extends限定不能super限定
有时候，你会希望泛型类型只能是某一部分类型，比如操作数据的时候，你会希望是Number或其子类类型。这个想法其实就是给泛型参数添加一个界限。

此定义表示T应该是BoundingType的子类型（subtype）。T和BoundingType可以是类，也可以是接口。另外注意的是，此处的”extends“表示的子类型，不等同于继承。
泛型中的extends不是类继承里的那个extends！ extends：这里可以翻译为绑定。两个根本没有任何关联。在这里extends后的BoundingType可以是类，也可以是接口，意思是说，T是在BoundingType基础上创建的，具有BoundingType的功能。目测是JAVA的开发人员不想再引入一个关键字，所以用已有的extends来代替而已。

A.    示例：绑定接口

public class Point2 {
    private T x;
    private T y;
    private boolean xBigy;
    public Point2(T x, T y) {
        this.x = x;
        this.y = y;
        this.xBigy = x.compareTo(y) > 0;
    }
…
}

由于T类型是Comparable的子类型，因此T类型具有compareTo方法。
创建Point2实例：传入的T类型必须是实现了Comparable接口。
Point2 point21 = new Point2(new Integer(11),new Integer(2));
System.out.println(point21);
类型绑定有两个作用：
1、对填充的泛型加以限定；
2、使用泛型变量T时，可以使用extends后面的类型内部的方法。

B.    示例：绑定类

父类类型Fruit：
public class Fruit {
    private String name;
    public Fruit(String name) {
        this.name = name;
    }
}
子类类型Apple:
public class Apple extends Fruit {
    public Apple(String name) {
        super(name);
    }
}
泛型绑定类的使用：
public class PrintFuritName {
    private F fruit;
    public PrintFuritName(F fruit) {
        this.fruit = fruit;
    }
    public void printFruitName(){
        System.out.println(fruit.getName());
    }
}

通过构造方法传入F对象，F绑定了是Fruit类型，因此可以通过F实例调用Fruit中的所有方法。
调用：
//java泛型之类型绑定：绑定类
PrintFuritName applePrint = new PrintFuritName(new Apple("APPLE"));
applePrint.printFruitName();

C.    用&实现多个限定；同时定义多个泛型，逗号隔开即可

可以同时多个限定,用&连接；定义多个泛型，用逗号隔开。
public class Lunch {
    private F f;
    private V v;//有机蔬菜
    public Lunch(F f, V v) {
        this.f = f;
        this.v = v;
    }
public class Tomato extends Vegetable implements Organic 
public class Apple extends Fruit implements Organic 
其中Apple和Tomato都必须实现Organic接口。

4.    通配符？及其extends和super的限定

1)    T与?的区别：为什么引入"?"

在定义泛型的时候，需要用T、K、V等字符表示类型；"?"是在创建对象时通配T的。
也就是说，T、K、V等字符只能在类、接口、方法上用来定义声明泛型，不能用于创建变量；而"?"用来填充泛型T的，表示通配任何类型。
简单说：T只是当做形参的作用，而？是实参，是填充T的。
    一种错觉:List