文章目录
1.学习目标
1.以能阅读 java 集合源码为目标学习泛型
2.了解泛型
3.了解通配符
2.什么是泛型
先来看下面的代码，如果要给方法传参，传递的参数必须是符合参数类型的。
public class Test {
public static void func (int a) {
}
public static void main(String[] args) {
func(10);
}
}
因为上述代码中的 func 方法的参数是 int 类型，此时调用方法时传递的参数就必须是 int 类型的。
如果是其他类型的这里就会报错。
通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化；简单来说就是在给方法传参时，可以将一些不同类型的参数一起传递过去。
3.引入泛型
解决下面的问题：
实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值
此时如果将这个数据定义为具体的某一个类型，那么它就只能传递具体的某一个参数类型。
比方说，如果是一个 int 的数组，它就只能传递 int 类型的参数；如果是一个 char 类型的参数，那么它就只能传递 char 类型的参数…
解决办法就是，将这个数组定义为 Object 数组 即可，这是因为 Object 是所有类的父类，也就是所有都继承这个类，如下代码片段所示。
class MyArray {
public Object[] objects = new Object[10];
// 给数组添加元素
public void setVal (int pos, Object val) {
objects[pos] = val;
}
// 返回数组中某个下标的值
public Object getVal (int pos) {
return objects[pos];
}
}
public class Test {
public static void main(String[] args) {
MyArray myArray = new MyArray();
// 调用方法给数组的 0 下标添加一个int类型的 10 元素
myArray.setVal(0, 10);
// 给数组 1 下标添加一个 String 类型的 “hello” 元素
myArray.setVal(1, "hello");
}
}
按照上述代码中调用 setVal 方法就可以给数组添加元素。
在调用 getVal 方法返回某个下标的的值时代码报错了，鉴于上述情况可以得出结论：
1、任何类型的数据都可以存放。
2、1号下标本身就是字符串，但是取数据的时候编译却报错了。此时必须进行强制类型转换
可以看到强转后就不报错了，按照上述的情况，必须要看看下标元素是什么类型后再取出，
这就比较不合适了。
虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望他只能够持有一种数据类型。
而不是同时持有这么多类型。因此，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。
此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。
接下来修改代码使用 泛型 来解决这个问题。
class MyArrays<T> {
public T[] objects = (T[])new Object[10];
// 给数组添加元素
public void setVal (int pos, T val) {
objects[pos] = val;
}
// 返回数组中某个下标的值
public T getVal (int pos) {
return objects[pos];
}
}
public class Work {
public static void main(String[] args) {
// 此时指定的是 Integer 类型，只能传递整数
MyArrays<Integer> myArrays = new MyArrays<Integer>();
myArrays.setVal(0, 10);
myArrays.setVal(1, 20);
}
}
< T > : 相当于是一个占位符，表示当前类是一个泛型类。
括号里的字母不一定是 T，也可以别的，但是我们习惯括号里的字母可以将我们想要表达的意思表示出来，T 和 E 一般用来表示类型。
main 函数里的 < Intrger>表示当前只能传递 Integer 类型的参数，也就是只能传递整数。
如果此时要传递 Integer 类型以外的参数。
可以看到代码此时会报错。
如果要取出指定下标元素的值定义一个变量接收方法返回的值即可。
int ret = myArrays.getVal(1);
根据输出的结果可以判断出的确得到了下标为 1 的元素的值。
如果想要传递其他类型的参数，更改 <> 中的类型即可。
public static void main(String[] args) {
MyArrays<String> myArrays1 = new MyArrays<String>();
myArrays1.setVal(2, "hello");
myArrays1.setVal(3, "world");
String retString = myArrays1.getVal(2);
System.out.println(retString);
}
可以看到得到的结果也是正确的。
这就是泛型！！！
泛型存在的两个最大的意义：
1、存放元素的时候，会进行类型的检查。
2、取出元素的时候，会自动进行类型转换，不在需要类型的强转了。
泛型只要是编译时期的一种机制，这种机制叫做 擦除机制，而运行的时候是没有泛型概念的。
有关泛型擦除机制的文章介绍：擦除机制的文章介绍
语法
class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> {
}
class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
// 可以只使用部分类型参数
}
一个泛型类的参数列表可以指定多个类型，也就是 <> 里可以有多个字母，
如下图所示：
4.泛型类的使用
语法
泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象
示例
MyArray<Integer> list = new MyArray<Integer>();
注意：泛型只能接受类，所有的基本数据类型必须使用包装类！，也就是<> 里只能是 类类型，不能是基本类型。
6.泛型的上界
在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。
语法
class 泛型类名称<类型形参 extends 类型边界> {
...
}
示例
public class MyArray<E extends Number> {
...
}
只接受 Number 的子类型作为 E 的类型实参。
MyArray<Integer> l1; // 正常，因为 Integer 是 Number 的子类型
MyArray<String> l2; // 编译错误，因为 String 不是 Number 的子类型
实现一个泛型类，求一个数组中的最大值
class MaxVal<T extends Comparable<T>> {
public T findMax (T[] array) {
T max = array[0];
for (int i = 1; i < array.length; i++) {
if(max.compareTo(array[i]) < 0 ) {
max = array[i];
}
}
return max;
}
}
public class MaxValue {
public static void main(String[] args) {
MaxVal<Integer> maxVal = new MaxVal<>();
Integer[] array = {
1,2,3,4,5};
Integer ret = maxVal.findMax(array);
System.out.println(ret);
}
}
可以输出结果正确。
7.泛型的方法
定义语法
方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) {
... }
示例
public class Util {
//静态的泛型方法 需要在static后用<>声明泛型类型参数
public static <E> void swap(E[] array, int i, int j) {
E t = array[i];
array[i] = array[j];
array[j] = t;
}
}
8.通配符
? 用于在泛型的使用，即为通配符。
通配符解决什么问题
通配符是用来解决泛型无法协变的问题的，协变指的就是如果 Student 是 Person 的子类，那么 List 也应该是 List 的子类，但是泛型是不支持这样的父子类关系的。
泛型 T 是确定的类型，一旦你传了我就定下来了，而通配符则更为灵活或者说是不确定，更多的是用于扩充参数的范围。
class Message<T> {
private T message ;
public T getMessage() {
return message;
}
public void setMessage(T message) {
this.message = message;
}
}
public class Test3 {
public static void main(String[] args) {
Message<String> message = new Message() ;
message.setMessage("中土世界欢迎您");
fun(message);
}
public static void fun(Message<String> temp){
System.out.println(temp.getMessage());
}
}
以上是程序的输出结果。
以上程序会带来新的问题，如果现在泛型的类型设置的不是String，而是Integer。
可以看到程序会报错，因为 fun 方法被要求是 String 类型的。
解决办法就是引入 通配符 的概念，直接在代码中写入 ? 即可。
class Message<T> {
private T message ;
public T getMessage() {
return message;
}
public void setMessage(T message) {
this.message = message;
}
}
public class Test3 {
public static void main(String[] args) {
Message<Integer> message = new Message() ;
message.setMessage(10);
fun(message);
}
public static void fun(Message<?> temp){
System.out.println(temp.getMessage());
}
}
可以看到改写好的代码，就没有报错了。
此时的问号表示的含义是程序也不知道此时的类型是什么类型。
此时就得到了正确的结果。
在 “?” 的基础上又产生了两个子通配符:
? extends 类：设置泛型上限
? super 类：设置泛型下限
通配符上界
语法
<? extends 上界>
<? extends Number>//可以传入的实参类型是Number或者Number的子类
示例
class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Banana extends Fruit {
}
class Plate<T> {
// 设置泛型上限
private T plate ;
public T getPlate() {
return plate;
}
public void setPlate(T plate) {
this.plate = plate;
}
}
public class TestDemo {
public static void main(String[] args) {
// 可以看到p1 与 p2 调用 fun 方法后都是正确的
Plate<Apple> plate1 = new Plate<>();
plate1.setPlate(new Apple());
fun(plate1);
Plate<Banana> plate2 = new Plate<>();
plate2.setPlate(new Banana());
fun(plate2);
}
// 此时继承的是 Fruit 类，表名 fun 方法可以调用 Fruit、Apple or Banana
public static void fun(Plate<? extends Fruit> temp){
}
}
根据上面代码可以看到，plate1 设置为只能放 Apple，而 plate2 设置为了只能放 Banana。
实际上 fun 继承了 Fruit 类，在调用方法的时候就决定了可以是 Fruit、Apple、Banana其中一个。
因为 Apple 与 Banana 是 Fruit 的子类。
此时通过 fun 方法是不能往里面放元素的。
站在 fun 方法的角度考虑，此时他有可能接收的 Apple 也有可能接收的是 Banana，因此也就不可以往里面放元素。
取元素的时候是没问题的，但是放元素的时候是有问题的。因为取出的元素一定是 Fruit 或者它的子类，但是放进去的是什么就不能确定了。就好像可以说苹果是水果，但是不能说水果是苹果一样。
public static void fun(Plate<? extends Fruit> temp){
Fruit fruit = temp.getPlate();
}
需要注意的是在这里的代码只能用 Fruit 来引用，还是因为具体是什么类型是不确定的。
可以看到是错的，因此通配符的上界，不能进行写入数据，只能进行读取数据。
通配符下界
语法
<? super 下界>
<? super Integer>//代表 可以传入的实参的类型是Integer或者Integer的父类类型
示例
class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Banana extends Fruit {
}
class Plate<T> {
private T plate ;
public T getPlate() {
return plate;
}
public void setPlate(T plate) {
this.plate = plate;
}
}
public class TestDemo {
public static void fun(Plate<? super Fruit> temp){
temp.setPlate(new Apple());
temp.setPlate(new Banana());
temp.setPlate(new Fruit());
}
public static void main(String[] args) {
Plate<Fruit> plate1 = new Plate<>();
plate1.setPlate(new Fruit());
fun(plate1);
Plate<Food> plate2 = new Plate<>();
plate2.setPlate(new Food());
fun(plate2);
}
}
下界和上界正好是相反的，可以放元素但是不可以取元素。因为不能确定这里存放的是什么。
可以看到取出的时候报错了。
下界这里方法调用的时候只能传递 Fruit 或者 它的父类作为参数。
可以看到传递 Fruit 的子类是出错了。
9.包装类
在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。
基本数据类型和对应的包装类
需要注意的是除了圈出的两个，其他的包装类都是首字母大写。
装箱和拆箱
int i = 10;
// 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中
Integer ii = Integer.valueOf(i);
Integer ij = new Integer(i);
// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中
int j = ii.intValue();
自动装箱和自动拆箱
// 自动拆箱和装箱
int i = 10;
Integer ii = i; // 自动装箱
Integer ij = (Integer)i; // 自动装箱
int j = ii; // 自动拆箱
int k = (int)ii; // 自动拆箱