Java泛型

• 前言
• 没有泛型的程序
• 带有泛型的程序
• 泛型的定义
• • 定义泛型类
  • 定义泛型方法
• 泛型的继承
• 泛型的多继承
• • 泛型的继承规则
• 泛型通配符
• • 泛型通配符和extends关键字
  • 泛型通配符和super关键字
• T和?通配符的区别
• 泛型擦除
• 泛型和数组
• 总结

前言

Java当中的泛型是JDK1.5版本中引入的一项技术，使用泛型可以使得我们的代码更加安全，而且具备更好的可读性。泛型大家都有所了解，可能觉得非常简单，然而，泛型也有许许多多需要注意的细节，本文的主要目的就是将泛型的使用细节及注意事项一一归纳。

没有泛型的程序

下面是一段没有使用泛型的代码示例：

package com.zwx.coreJava.genericity;

import java.util.ArrayList;
import java.util.List;

public class MyItem { 
    public static void main(String[] args) { 
        List list = new ArrayList<>();
        list.add(1);
        list.add("中国");
        for (int i=0;i<list.size();i++){ 
             int a = (int)list.get(i);
             System.out.println(a);
        }
    }
}

显然，上面这段代码可以正常编译，但是运行的时候就会报错，这就是没有泛型约束造成的后果，我们可以向list中添加任意数据类型，但是取值的时候就很容易出现类型转换异常，所以为了使Java程序更加安全，泛型技术就应运而生了。

带有泛型的程序

现在我么通过泛型将上面的程序进行改造一下：

List<Integer> list = new ArrayList<>();

因为改造之后的程序加入了泛型的约束，那么就限制了我们只能向list中添加Integer类型的数据，而如果添加其他类型，比如String类型(如下所示)，那么就会在编译阶段无法通过：

list.add("中国"); //编译不通过

上面没有添加泛型时，我们每次取出集合中的元素都需要进行类型强转，而加了泛型，在取值的时候我们也不需要再手动去类型强转，直接取出来(用约束的类型接收)就可以了，无需强转，代码又美观又安全：

 int a = list.get(i);//无需强转
 System.out.println(a);

PS：注意：8种基本数据类型不能作为泛型，泛型必须要使用其对应的包装类

泛型的定义

上面通过一个简单的对比示例展示了如何用泛型以及使用泛型的好处，而上面使用的泛型实际上是一种指定了具体类型的泛型。

直接指定具体泛型的方式是最简单的，我们大部分场景下也都是使用具体类型的方式，但是泛型还有其他非具体类型的定义方式，接下来我们继续介绍一下泛型的非具体类型定义方式。

泛型可以定义在类上，也可以定义在方法上。

定义泛型类

下面就是一个泛型类的定义方式：

package com.zwx.coreJava.genericity;

import java.util.Map;

public class GenericClass<K,V,M> { 
    private M name;
    private Map<K,V> map;

    public V test(M m){ 
        return null;
    }
}

定义的泛型可以只有一个，也可以定义多个，一般使用大写字母来作为泛型定义，不同的字母之前也没有什么特殊含义，只不过一般默认的写法都遵循以下默契：

• 1、E表示元素类型
• 2、K和V表示关键字与值的类型(比如map里面的key和value)
• 3、T则表示其他类型类型

PS:示例中我特意用了一个M来表示，就是想说明到底用什么字母来表示泛型，并没有语法要求。

定义泛型类的时候需要注意的是，类上定义的泛型不能使用在静态变量和静态方法上。比如上面的方法改成静态方法则会编译不通过，原因我们后面再解释。

需要注意的是，接口也算是一种特殊的类，所以这些规则也适用于接口。

定义泛型方法

如果我们不想在类上面定义泛型，只想在方法上定义泛型也可以，这就是泛型方法。泛型方法可以定义在泛型类里面，也可以定义在普通类里面。
泛型方法的定义需要把<>放在修饰符(如public static)之后，返回值之前。
如下就是一个泛型的定义示例：

package com.zwx.coreJava.genericity;

public class GenericMethod { 
    public <T> T test(T arg){ 
        System.out.println("generic method");
        return null;
    }
}

那么定义了泛型的方法应该如何调用呢？
我们把上面例子中的参数改为多参数看一下

package com.zwx.coreJava.genericity;

public class GenericMethod { 
    public <T> T test(T...arg){ 
        System.out.println("generic method");
        return null;
    }

    public static void main(String[] args) { 
        GenericMethod genericMethod = new GenericMethod();
        genericMethod.test("1",1);
    }
}

上面这段代码可以正常编译输出，并没有起到限制的作用，所以如果非要限制，可以采用如下调用方式：

genericMethod.<String>test("1",1);

在方法前面加上泛型就可以起到限制作用，这时候代码就会编译不通过了。

泛型的继承

上面的泛型定义实际上并没有太多限制，还是可以传入任意类型，那么假如我想限制一下泛型，比如说只能是某一个类的子类，又该如何定义呢？

如果想限定泛型为某一个类的子类，那么就需要用到extends关键字。注意：泛型的继承只能使用extends，而不能使用implements(即使是接口也只能用extends关键字)。

package com.zwx.coreJava.genericity;

import java.io.Serializable;

public class GenericClass2<T extends Serializable>{ 
    public static void main(String[] args) { 
        GenericClass2 genericClass2 = new GenericClass2<MyItem>();
    }
}

上面这个示例就会编译不通过，因为我们的MyItem类并没有实现Serializable接口，只有实现了Serializable接口的类才能被正常传进去。

泛型的多继承

在泛型里面支持多继承，可以通过“&”或者“,”来实现。

我们先看一个&的例子：

package com.zwx.coreJava.genericity;

import java.io.Serializable;

public class GenericClass2<T extends MyItem & Serializable & Cloneable>{ 
    public static void main(String[] args) { 
        GenericClass2 genericClass2 = new GenericClass2<MyItemSub>();
    }
}

这里要求必须只能有一个类，而且如果有一个类，那么这个类必须放在第一位。如上面的例子，MyItem只能放在第一位。而下面这句话需要编译通过，那么MyItemSub必须是如下定义：

public class MyItemSub extends MyItem implements Serializable,Cloneable { 
}

也就是说必须同时满足所有条件。

接下来再看一个逗号的例子：

package com.zwx.coreJava.genericity;

public class GenericClass2<T extends MyItem,Serializable,Cloneable>{ 
    public static void main(String[] args) { 
        GenericClass2 genericClass2 = new GenericClass2<MyItemSub,MyItemSub,MyItemSub>();
    }
}

但是这种写法似乎只对第一个限制类型有用，后面的限制并没有用上，因为我除了第1个参数，后面2个参数我传任意类型都可以编译通过。

泛型的继承规则

我们新建一个类继承MyItem:

package com.zwx.coreJava.genericity;

public class MyItemSub extends MyItem { 
}

这时候我们再去测试一下这个例子：

package com.zwx.coreJava.genericity;

public class GenericClass3<T extends MyItem>{ 
    public static void main(String[] args) { 
        MyItemSub myItemSub = new MyItemSub();
        MyItem myItem = myItemSub;//编译通过

        GenericClass3<MyItemSub> myItemSubGenericClass = new GenericClass3<>();
        GenericClass3<MyItem> myItemGenericClass = myItemSubGenericClass;//编译失败
        
    }
}

可以看到最后这一句话编译不通过，也就是说：GenericClass3<MyItem>和GenericClass3<MyItemSub>没有任何关系（当然这个仅限于编译阶段），并不会因为泛型里面有继承关系就影响到了外面的继承关系。

泛型通配符

在某些时候，我们可以通过通配符“?”来作为泛型，?表示不限制类型。（下面例子中Manager类是Employee的子类，两个类都是空类，就不贴代码了）

package com.zwx.coreJava.genericity.wildcard;

import java.util.ArrayList;
import java.util.List;

public class MyWildcard { 
    public static void main(String[] args) { 
        List<?> list = new ArrayList<>();
        list.add(null);//编译通过
        list.add(1);//报错
}

可以看到，虽然?表示允许任意类型，但是和List<Object>还是有本质区别的，使用通配符作为泛型的不能直接设置元素，除了null值。
不过虽然不能直接设值，但是我们可以通过间接的方式设置值进去。

package com.zwx.coreJava.genericity.wildcard;

import java.util.ArrayList;
import java.util.List;

public class MyWildcard { 
    public static void main(String[] args) { 
        List<?> list = MyWildcard.init();
        Object obj = list.get(0);//通过
        list.add(new Employee());//不通过
    }

    public static List<?>  init(){ 
        List<Employee> list = new ArrayList<>();
        list.add(new Employee());
        return list;
    }
}

虽然我不能直接设置值进去，但是我可以get获得list的元素。这是因为设置的时候无法确认?到底是什么类型，所以Java会拒绝编译，但是get元素的时候我可以直接赋值给Object，因为任何对象都是Object的子类，所以相当于知道了list内部对象的上界就是Object对象。用Object来接收不会有问题。

泛型通配符和extends关键字

通配符也可以使用extends关键字。

package com.zwx.coreJava.genericity.wildcard;

import java.util.ArrayList;
import java.util.List;

public class MyWildcard { 
    public static void main(String[] args) { 
        List<? extends Employee> list = MyWildcard.init();
        Employee employee = list.get(0);//通过
        list.add(new Manager());//不通过

    public static List<? extends Employee>  init(){ 
        List<Employee> list = new ArrayList<>();
        list.add(new Employee());
        return list;
    }
}

使用extends关键字和直接使用通配符区别不大，唯一的区别就是取值的时候我可以确定对象一定是Employee的子类，所以我可以直接使用Employee对象来接收。

换句话说就是:这种写法我可以知道list内部元素的上界，但是我不知道你的下界，所以我只允许取值(用上界接收)，不允许设值(设值要用下界)

泛型通配符和super关键字

通配符还可以使用super关键字，限定类型为某个类的超类：

package com.zwx.coreJava.genericity.wildcard;

import java.util.ArrayList;
import java.util.List;

public class MyWildcard { 
    public static void main(String[] args) { 
        List<? super Employee> list = MyWildcard.init();
        Employee employee = list.get(0);//不通过
        Object obj = list.get(0);//编译通过
        list.add(new Employee());//通过
    }

    public static List<? super Employee>  init(){ 
        List<Employee> list = new ArrayList<>();
        list.add(new Employee());
        return list;
    }
}

可以看到，这里就允许设值，因为super关键字限定了元素必须为Employee的父类，也就是我知道了元素的下限，所以我可以设值，但是取值因为不知道上界，所以只能用最顶层的Object。

T和?通配符的区别

这两种表示方法有区别吗？这两个有本质的区别。总结一下主要有如下区别：

• 1、T表示的是形参，也就是说如果我们想要用T，那么必须要先定义才能用；而?通配符则表示的是实参，也就是说不需要定义，我就可以直接拿来使用。
• 2、T相当于是占位符，如果我们定义了T，而实际传进去的是String，那么实际的约束类型就是String类型，而不是T；而?通配符可以理解为就是一种真实存在的特殊类型。
• 3、T可以使用多继承，而?通配符不行，只能用单继承
• 4、T不能使用super关键字，而?通配符可以使用super关键字。
• 5、?通配符表示的对象是存在继承关系的，而T表示的不同泛型之间没有任何关系,所以下面这个示例是成立的。

List<?> list = new ArrayList<>();
List<? extends Employee> list1 = new ArrayList<>();
list = list1;

泛型擦除

我们先看一个例子：

package com.zwx.coreJava.genericity.erasure;

import com.zwx.coreJava.genericity.wildcard.Employee;

import java.util.ArrayList;
import java.util.List;

public class TestErasure { 
    public static void main(String[] args) { 
        List<String> list = new ArrayList<>();
        List<Integer> list1 = new ArrayList<>();
        List<?> list2 = new ArrayList<>();

        System.out.println(list.equals(list1));//true
        System.out.println(list.equals(list2));//true
    }
}

两句话的输出结果都是true。

这是因为Java中的泛型只是在编译阶段有效，而实际运行之后会擦除掉，相当于没有泛型，上面的3个list都等价于List list，所以Java中的的泛型并不是真正的泛型。

所以让我们回到上面的例子，为什么类泛型不能使用在静态方法上？因为静态方法不属于某一个实例对象，而泛型在运行阶段就被擦除了，那么静态方法在加载的时候根本就无法知道这个泛型到底是什么类型。而非静态方法是属于实例对象，可以根据对象实例化状态信息得出泛型属于什么类型。

泛型和数组

Java官方明确说明，不能实例化一个明确参数类型的数组。
请看下面一个例子(ArrElement是一个空类)：

package com.zwx.coreJava.genericity.array;

import java.util.ArrayList;
import java.util.List;

public class TestArray { 
    public static void main(String[] args) { 
        ArrElement<String>[] arr = new ArrElement<String>[10];//编译不通过
        ArrElement<String>[] arr1 = new ArrElement[10];//编译通过
        ArrElement<String>[] arr2 = (ArrElement<String>[])new ArrElement<?>[10];
    }
}

可以看到上面第1句话不允许编译通过，而后面两句话允许通过，这就是因为Java中禁止直接通过具体泛型来初始化一个数组，但是孕育通过具体泛型来接收一个数组。

那么Java中为什么要禁止通过实际类型来初始化数组呢？
因为数组在初始化之后就会记住数据的数据类型，但是泛型又能被擦出，这就会出现问题。
比如上面这个例子中第一句话，泛型被擦除后，实际代码为：

ArrElement[] arr = new ArrElement[10];

那么这时候假如我执行以下两句代码：

Object[] objArr = arr;
objArr[0] = new ArrElement<Integer>();

这两句话是完全可以通过数组的安全性检查的，但是这个元素类型和初始化的元素类型不一致，所以会导致类型错误。正是因为数组会记住元素类型和泛型擦除导致了冲突，才禁止带泛型初始化数组，这样数组初始化的时候只会记住ArrElement对象,而不限定类型

总结

本文对Java泛型相关知识点进行了一个归纳整理，主要包括泛型类，泛型方法，多继承，通配符和非通配符的区别，以及多继承和数组泛型相关知识点。

请关注我，和孤狼一起学习进步。