目录
一,为什么我们需要泛型
通过分析下面两种情况,来得出我们为什么需要泛型。
1.对两个数值类型求和的情况,如下代码,当两个数值是int类型时,需要实现一个方法对int类型的数值求和。当两个数值是Float类型时,需要实现一个方法对Float类型的数值求和。如果两个数值是Double类型时,还需要再实现一个方法对Double类型的数值求和。
public int addInt(int x, int y) {
return x+y;
}
public float addFloat(float x, float y) {
return x+y;
}
我们发现对两个数值求和时,都是一样的操作(加法运算),但当两个数值的数据类型改变时,就需要重新实现一个新的求和方法。同样的一段代码,只是因为传入的参数不同,这里就必须要重写这个方法,这样会导致代码非常臃肿,也不灵活。
这种情况下我们能不能写出一段代码,代码的逻辑是一样的,根据传入的参数不同,自动进行运算。这就是泛型需要的地方之一。
适用多种数据类型,执行相同的代码,这是泛型的用处之一。
2.声明一个List集合,如下代码,不带任何的类型说明,向List里面添加一些元素,加入String和Integer对象,这时候编译不会报错。然后我们打印出List中的元素,运行的时候抛出一个异常"java.lang.Integer cannot be cast to java.lang.String",Integer对象不能转换成一个String对象。
因为这里声明的List没有规定它的类型,此时List默认的类型是Object,Object是所有类的父类,所以把不同类型的数据添加到List中没有问题。但是从List中取数据的时候,取到的所有数据都是Object,所以在使用这些数据的时候就需要强制类型转换。如下代码中需要打印出String,就需要强制转换成String类型,但是由于List中还添加了Integer类型的数据,这时候强制类型转换就会报异常"ClassCastException"。
所以这里就需要使用到泛型,List集合定义了泛型之后,List集合中只能添加指定类型的数据,不然会编译不通过,在编译的时候就找到错误。而且从List集合中取数据的时候,不需要强制类型转换,可以直接用。
这就是使用泛型的好处,在编码的过程中,可以指定数据类型,不需要进行强制类型转换。以及如果我们插入错误的数据类型,在编译期间就能够发现,不至于在运行的时候才抛类转换异常。
public static void main(String[] args) {
// TODO Auto-generated method stub
List list = new ArrayList();
list.add("mark");
list.add("OK");
list.add(new Integer(100));
for(int i = 0; i < list.size(); i++){
String name = (String) list.get(i);
System.out.println("name: " + name);
}
}
所以泛型的好处就是:
1,适用多种数据类型,执行相同的代码。
2,在编码的过程中,指定数据类型,不需要进行强制类型转换。以及如果我们插入错误的数据类型,在编译期间就能够发现,不至于在运行的时候才抛类转换异常。
二,什么是泛型,泛型的定义
泛型的定义:参数化类型
泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?
顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。
简单点说普通的方法定义,已经明确确定了需要传入的参数类型,调用方法的时候,只能改变传入的参数值,不能改变传入的参数类型,否则编译时会报错。
使用泛型定义方法,需要传入的参数类型和参数值都是没有明确确定的,调用方法的时候,由调用者确定传入的参数类型和参数值。
参数化类型,不同类型的参数可以由同一段代码处理。
泛型的本质是为了参数化类型(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。
三,如何定义和使用泛型
假如我们自己要定义泛型,如何去定义泛型呢?
泛型分为三种:泛型类、泛型接口、泛型方法。
泛型使用时引入一个类型变量,比较常用的有T,E,K,V等等,一般来讲就这么几种,都是约定俗成的。
泛型类
定义泛型类,在类名后面加尖括号T(也可以是其他的字符),然后可以用T去定义变量和方法(方法返回值和参数。泛型类是允许有多个类型变量的。
实现和测试代码去下。
public class NormalGeneric<T> {
private T data;
public NormalGeneric(){
}
public NormalGeneric(T data){
this.data = data;
}
public T getData(){
return data;
}
public void setData(T data){
this.data = data;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
NormalGeneric<String> normalGeneric = new NormalGeneric<>();
normalGeneric.setData("hello Generic");
//normalGeneric.setData(12); //编译不通过报错,因为已经声明了泛型类的类型了
System.out.println(normalGeneric.getData());
}
}
public class NormalGeneric2<T, K> {
private T data;
private K result;
}
泛型接口
除了泛型类,接口也可以定义泛型。泛型接口的定义和泛型类差不多。
定义泛型接口,在接口名后面加尖括号T,然后可以用T去定义抽象方法。
public interface Genertor<T> {
public T next();
}
我们平时用接口的时候,都是用它的实现类。那么对于泛型接口来讲,要怎么去写它的实现类,
这里有两种方式。
第一种实现方式,使用泛型类实现泛型接口。
在实现泛型接口的时候,并不给泛型赋一个实际类型,这个类本身还是一个泛型类,在类名后面加尖括号T,这是一种实现泛型接口的方式。
泛型类实现泛型接口,它在使用上和其他普通的泛型类并没有什么区别。
public class ImplGenertor<T> implements Genertor<T> {
@Override
public T next() {
// TODO Auto-generated method stub
return null;
}
}
第二种实现方式,在实现泛型接口的时候,直接规定泛型接口的类型。在泛型接口里面,T是一个参数化类型,实现泛型接口的时候,规定了参数化类型的类型。
public class ImplGenertor2 implements Genertor<String> {
@Override
public String next() {
// TODO Auto-generated method stub
return null;
}
}
泛型方法
泛型方法和泛型类以及泛型接口都有所不同,泛型方法可以是完全独立的,没有要求泛型方法一定要声明在泛型类或泛型接口中,泛型方法可以声明在普通类和普通接口中。
如下代码中声明的泛型方法。方法的返回值变成参数化类型,在修饰符和返回值之间多了一个用尖括号括起来的类型,这样声明定义的方法就是泛型方法。尖括号括起来的类型变量是声明定义泛型方法必须要的,没有这个就不是泛型方法。
public class GenericMethod {
public <T> T genericMethod(T...a){
return a[a.length / 2];
}
public void test(int x, int y){
System.out.println(x + y);
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
GenericMethod genericMethod = new GenericMethod();
genericMethod.test(54, 864);
System.out.println(genericMethod.<String>genericMethod("hello", "word", "2021"));
System.out.println(genericMethod.genericMethod(11, 22, 33));
}
}
不管是泛型类还是泛型方法,都是允许定义多个泛型的。
那么泛型方法与泛型类或泛型接口有什么区别呢?
泛型类或泛型接口必须是在new创建对象实例的时候,告诉编译器类型变量的具体类型。而泛型方法是在调用的时候,告诉编译器当前这个泛型方法传入的具体参数类型是什么。
泛型方法是在调用方法的时候指明泛型的具体类型,可以在任何地方和任何场景中使用,包括普通类和泛型类,注意泛型类中定义的普通方法和泛型方法是有区别的。
下面代码讲述泛型方法的区别。
/**
* 这是一个普通类
*/
public class GenericMethod2{
/**
* 这个类是个泛型类
* @param <T>
*/
public class Generic<T> {
private T key;
public Generic(){
}
public Generic(T key){
this.key = key;
}
/**
* 虽然在方法中使用了泛型,但是这并不是一个泛型方法。
* 这只是泛型类中一个普通的成员方法,只不过他的返回值是在声明泛型类已经声明过的泛型。
* 所以在这个方法中才可以继续使用 T 这个泛型。
*
* @return
*/
public T getKey(){
return key;
}
/**
* 编译报错
* 这个方法显然是有问题的,在编译器会给我们提示这样的错误信息"E cannot be resolved to a type"
* 因为在类的声明中并未声明泛型E,所以在使用E做形参和返回值类型时,编译器会无法识别。
*/
public E setKey(E key){
this.key = key;
}
/**
* 这才是一个真正的泛型方法。
* 首先在public与返回值之间的<T>必不可少,这表明这是一个泛型方法,并且声明了一个泛型T
* 这个T可以出现在这个泛型方法的任意位置.
* 泛型的数量也可以为任意多个
* @param container
* @return
*/
public <E,K> K showKeyName(Generic<E> container){
return null;
}
/**
* 这也不是一个泛型方法,这就是一个普通的方法,
* 只是使用了NormalGeneric<Number>这个泛型类做形参而已。
* @param Obj
*/
public void show(Generic<Number> Obj){
}
}
/**
* 这个方法是有问题的,编译错误,编译器会为我们提示错误信息:"E cannot be resolved to a type"
* 虽然我们声明了<T>,也表明了这是一个可以处理泛型类型的泛型方法。
* 但是只声明了泛型类型T,并未声明泛型类型E,因此编译器并不知道该如何处理E这个类型。
* @param ab
* @return
*/
public <T> T show(Generic<E> ab){
}
/**
* 这个方法是有问题的,编译错误,编译器会为我们提示错误信息:"T cannot be resolved to a type"
* 对于编译器来说T这个类型并未在类或方法中声明过,因此编译也不知道该如何编译这个类。
* 所以这也不是一个正确的泛型方法声明。
* @param obj
*/
public void show(T obj){
}
}
使用泛型的时候有几点需要注意的地方:
1.不是声明在泛型类里面的方法,就是泛型方法。
2.泛型方法声明在泛型类中,也要遵守泛型方法的定义规则。
下面代码泛型方法的用法和定义:
public class GenericMethod3 {
static class Fruit{
@Override
public String toString() {
return "fruit";
}
}
static class Apple extends Fruit{
@Override
public String toString() {
return "apple";
}
}
static class Person{
@Override
public String toString() {
return "person";
}
}
static class GenerateTest<T>{
public void show_1(T t){
System.out.println(t.toString());
}
/**
* 在泛型类中声明了一个泛型方法,使用泛型E,这个泛型E可以为任意类型。
* 类型可以与T相同,也可以不同。
* 由于泛型方法在声明的时候会声明泛型<E>,因此即使在泛型类中并未声明该泛型,
* 编译器也能够正确识别泛型方法中的泛型。
* @param e
*/
public <E> void show_2(E e){
System.out.println(e.toString());
}
/**
* 在泛型类中声明了一个泛型方法,使用泛型T,
* 注意这个T是一种全新的类型,可以与泛型类中声明的T不是同一种类型。
* 泛型类和泛型方法中定义的泛型,它的作用域是不一样的。前者是在整个类中可以使用,后者只能在该方法中使用
* @param t
*/
public <T> void show_3(T t){
System.out.println(t.toString());
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Apple apple = new Apple();
Person person = new Person();
GenerateTest<Fruit> generateTest = new GenerateTest<>();
//不会报错,因为Apple是Fruit的子类。
generateTest.show_1(apple);
//编译报错,因为创建GenerateTest实例时,已经确定泛型的类型是Fruit
generateTest.show_1(person);
generateTest.show_2(apple);
generateTest.show_2(person);
generateTest.show_3(apple);
generateTest.show_3(person);
}
四、限定类型变量
有时候,我们需要对类型变量加以约束,比如计算两个变量的最小或最大值。
public static <T> T min(T a, T b){
if(a.compareTo(b) > 0) return a; else return b;
}
如下代码,我们实现了一个泛型方法,然后调用compareTo方法比较传入的两个对象,但是编译报错"The method compareTo(T) is undefined for the type T",泛型T找不到找不到方法compareTo。
那么确保传入的两个变量一定有compareTo方法呢?解决这个问题的方案就是将T限定为实现了接口Comparable的类。
public static <T extends Comparable> T min(T a, T b){
if(a.compareTo(b) > 0) return a; else return b;
}
T extends Comparable中 extends(派生、继承)
T表示应该绑定类型的子类型,Comparable表示绑定类型,子类型和绑定类型可以是类也可以是接口。
同时extends左右都允许有多个,如 T,V extends Comparable & Serializable
注意限定类型中,只允许有一个类,而且如果有类,这个类必须是限定列表的第一个。因为在java中类是单继承,接口是多实现。
如果这个时候,我们试图传入一个没有实现接口Comparable的类的实例,将会发生编译错误。
/**
* 类说明:类型变量的限定-用在方法上
*
*/
public class ArrayAlg {
/**
* 编译报错,泛型T找不到找不到方法compareTo()方法,因为泛型T没有限定类型
* @param a
* @param b
* @return
*/
// public static <T> T min(T a, T b){
// if(a.compareTo(b) > 0) return a; else return b;
// }
/**
* 取两个对象的最小值,类型变量限定为必须要实现了Comparable接口
* @param a
* @param b
* @return
*/
public static <T extends Comparable> T min(T a, T b){
if(a.compareTo(b) > 0) return b; else return a;
}
/**
* 取两个对象的最大值,类型变量限定为必须要实现了Comparable接口
* @param a
* @param b
* @return
*/
public static <T extends Comparable> T max(T a, T b){
if(a.compareTo(b) > 0) return a; else return b;
}
static class Test{}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(ArrayAlg.min("hello", "world"));
System.out.println(ArrayAlg.min(22, 12));
//编译报错,因为Test类没有实现Compareble接口
//ArrayAlg.min(new Test(), new Test());
System.out.println(ArrayAlg.max(22, 12));
}
}
这种类型变量的限定既可以用在泛型方法上也可以用在泛型类上。使用方法都是一模一样的。下面是类型变量的限定,用在泛型类上面。
/**
* 类说明:类型变量的限定-用在类上
*
* @param <T>
*/
public class ClassBorder<T extends Comparable> {
private T data;
public T min(T outter){
if(this.data.compareTo(outter) > 0)
return outter;
else
return this.data;
}
public T getData(){
return data;
}
public void setData(T data){
this.data = data;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ClassBorder<String> classBorder = new ClassBorder<>();
classBorder.setData("Java");
System.out.println(classBorder.min("Python"));
}
}
五、泛型中的约束和局限性
/**
* 泛型类的原始类型,不会带上泛型的信息。
*
* @param <T>
*/
public class Restrict<T> {
private T data;
/**
* 编译报错:Cannot instantiate the type T
* 不能实例化类型变量,不能new类型变量。
*/
public Restrict(){
this.data = new T();
}
//静态域或者静态方法里面,不能引用类型变量
//因为泛型类是在new创建对象实例的时候,告诉编译器类型变量的具体类型。
//而虚拟机创建对象的代码执行先后顺序是static的部分,然后才是构造函数等等。
private static T instance;
//静态方法本身是泛型方法就行
private static <T> T getInstance(){
return null;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//不能用基本类型实例化类型参数,在Java中基本类型数据不是一个对象
Restrict<double> restrictDouble1 = new Restrict<>();
Restrict<Double> restrictDouble2 = new Restrict<>();
//泛型不能用instanceof关键字判断类型
if(restrictDouble2 instanceof Restrict<Double>){}
if(restrictDouble2 instanceof Restrict<T>){}
//运行时类型查询只适用于原始类型,不会带上泛型的类型变量
Restrict<String> restrictStr = new Restrict<>();
System.out.println(restrictDouble2.getClass() == restrictStr.getClass());
System.out.println(restrictDouble2.getClass().getName());
System.out.println(restrictStr.getClass().getName());
//编译报错:Cannot create a generic array of Restrict<Double>
//可以定义泛型数组,但是不能创建泛型数组(不能创建参数化类型的数组)
Restrict<Double>[] restrictArray; //可以
Restrict<Double>[] resticts = new Restrict<Double>[10]; //不可以,编译失败
}
不能在静态域或方法中引用类型变量。因为泛型是要在对象创建的时候才知道是什么类型的,而虚拟机创建对象的代码执行先后顺序是static的部分,然后才是构造函数等等。所以在对象初始化之前static的部分已经执行了,如果你在静态部分引用的泛型,那么毫无疑问虚拟机根本不知道是什么东西,因为这个时候类还没有初始化。
/**
* 类说明:泛型和异常
*/
public class ExceptionRestrict {
/**
* 编译报错:
* The generic class ExceptionRestrict.Problem<T> may not subclass java.lang.Throwable
* 泛型类不能 extends Exception/Throwable
*/
private class Problem<T> extends Exception{}
/**
* 编译报错:Cannot use the type parameter T in a catch block
* 不能捕获泛型类的实例
*/
public <T extends Throwable> void doWork1(T t){
try{
}catch(T e){
//todo
}
}
/**
* 这种方式是可以的。不能捕获泛型类的实例,但还可以抛出泛型类的实例。
* 泛型类也可以写在throws后面。
* @param t
* @throws T
*/
public <T extends Throwable> void doWork2(T t) throws T{
try{
}catch(Throwable e){
throw t;
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
六、泛型类型的继承规则
如下代码展示泛型的继承原则:
public class Employee {
private String firstName;
private String secondName;
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getSecondName() {
return secondName;
}
public void setSecondName(String secondName) {
this.secondName = secondName;
}
}
public class Worker extends Employee {
}
public class Pair<T> {
private T one;
private T two;
public T getOne() {
return one;
}
public void setOne(T one) {
this.one = one;
}
public T getTwo() {
return two;
}
public void setTwo(T two) {
this.two = two;
}
private static <T> void set(Pair<Employee> p){
}
/*泛型类可以继承或者扩展其他泛型类,比如List和ArrayList*/
private static class ExtendsPair<T> extends Pair<T>{}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//Pair<Employee>和Pair<Worker>没有任何继承关系
Pair<Employee> employeePair = new Pair<>();
Pair<Worker> workerPair = new Pair<>();
//子类给父类赋值,是可以的
Employee employee = new Worker();
//编译报错:Type mismatch: cannot convert from Pair<Worker> to Pair<Employee>
//这就说明Pair<Employee>和Pair<Worker>没有任何继承关系
Pair<Employee> employeePair2 = new Pair<Worker>();
//这种方式是可以的
Pair<Employee> pari = new ExtendsPair<>();
//可以
set(employeePair);
//编译报错:The method set(Pair<Employee>) in the type Pair<T> is not applicable for the arguments (Pair<Worker>)
//Pair<Employee>和Pair<Worker>没有任何继承关系
set(workerPair);
//可以的
set(pari);
}
}
泛型
1.泛型的类型变量之间,不考虑任务继承关系。类型之间的继承关系,不代表泛型的参数化类型之间有继承关系。
2.泛型类可以继承或者扩展其他泛型类,比如List和ArrayList。
七、通配符类型
我们先定义一些有继承关系的类和一个泛型类
public class Fruit {
private String color;
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
public class Food {
}
public class Apple extends Fruit {
}
public class Orange extends Fruit {
}
public class HongFuShi extends Apple {
}
public class GenericType<T> {
private T data;
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
正是因为前面所述的,GenericType<Fruit>和GenericType<Orange>没有任何继承关系,现在我们有一个方法如下:
public static void print(GenericType<Fruit> p){
System.out.println(p.getData().getColor());
}
在调用这个方法的时候,会出现如下的问题:
public static void use(){
GenericType<Fruit> a = new GenericType<>();
print(a);
GenericType<Orange> b = new GenericType<>();
//编译报错:The method print(GenericType<Fruit>) in the type WildChar is not applicable for the arguments (GenericType<Orange>)
//类型之间的继承关系,不代表泛型的参数化类型之间有继承关系。
//GenericType<Fruit>和GenericType<Orange>没有任何继承关系。
print(b);
}
因为GenericType<Fruit>和GenericType<Orange>没有任何继承关系,所以调用print(GenericType<Fruit> p)方法时,传入GenericType<Orange>实例对象就会编译报错。这样的程序看起来非常不灵活,Orange和Fruit是继承关系,但泛型变量可以是Fruit,不能是Orang。
为解决这个问题,于是提出了一个通配符类型 ?
有两种使用方式:
? extends X 表示类型的上界,类型参数是X的子类
? super X 表示类型的下界,类型参数是X的超类
这两种 方式从名字上来看,特别是super,很有迷惑性,下面我们来仔细辨析这两种方法。
通配符类型和限定类型变量的区别:
1.限定类型变量是在定义泛型类和泛型方法时,限定类型变量的类型。
2.通配符类型一般用在方法的参数上面。扩展支持的泛型类实例的类型变量。
? extends X
表示传递给方法的泛型类实例的类型变量,必须是X的子类(包括X本身)
但是对泛型类GenericType来说,如果其中提供了get和set类型参数变量的方法的话,set方法是不允许被调用的,会出现编译错误。
get方法则没问题,会返回一个Fruit类型的值。
public static void print2(GenericType<? extends Fruit> p){
System.out.println(p.getData().getColor());
}
private static void use2(){
GenericType<Fruit> a = new GenericType<>();
print2(a);
GenericType<Orange> b = new GenericType<>();
//这样是可以的
print2(b);
//编译报错:The method print2(GenericType<? extends Fruit>) in the type WildChar is not applicable for the arguments (GenericType<Food>)
//因为Food是Fruit的父类,而这里的泛型类型变量只能是Fruit的子类或本身。
print2(new GenericType<Food>());
//这样赋值是可以的
GenericType<? extends Fruit> c = b;
Apple apple = new Apple();
Fruit fruit = new Fruit();
//这个样是可以的,因为new创建泛型类对象的时候,确定了类型变量为Fruit
a.setData(fruit);
//编译报错:The method setData(capture#2-of ? extends Fruit) in the type GenericType<capture#2-of ? extends Fruit> is not applicable for the arguments (Apple)
c.setData(apple);
c.setData(fruit);
//这个样是可以的
Fruit f = c.getData();
//编译报错:Type mismatch: cannot convert from capture#5-of ? extends Fruit to Orange
//类型转换异常,这时候编译器只知道c.getData()返回的是一个Fruit类实例。
Orange o = c.getData();
}
那么为什么会这样呢?
道理很简单,? extends X 表示类型的上界,类型参数是X的子类,那么可以肯定的说,get方法返回的一定是个X(不管是X或者X的子类)编译器是可以确定知道的。但是set方法只知道传入的是个X,至于具体是X的那个子类,不知道。
总结:主要用于安全地访问数据,可以访问X及其子类型,并且不能写入非null的数据。
? super X
表示传递给方法的泛型类实例的类型变量,必须是X的超类(包括X本身)
public static void printSuper(GenericType<? super Apple> p){
System.out.println(p.getData());
}
public static void useSuper(){
GenericType<Fruit> fruitGeneticType = new GenericType<>();
GenericType<Apple> appleGeneticType = new GenericType<>();
GenericType<HongFuShi> hongfushiGeneticType = new GenericType<>();
GenericType<Orange> orangeGeneticType = new GenericType<>();
printSuper(fruitGeneticType);
printSuper(appleGeneticType);
//编译报错:The method printSuper(GenericType<? super Apple>) in the type WildChar is not applicable for the arguments (GenericType<HongFuShi>)
printSuper(hongfushiGeneticType);
//编译报错
printSuper(orangeGeneticType);
//表示GenericType的类型参数的下界是Apple
GenericType<? super Apple> x = new GenericType<>();
x.setData(new Apple());
x.setData(new HongFuShi());
//这样是不行的,编译报错。
x.setData(new Fruit());
//唯一可行的赋值
Object data = x.getData();
}
但是对泛型类GenericType来说,如果其中提供了get和set类型参数变量的方法的话,set方法可以被调用的,且能传入的参数只能是X或者X的子类。
get方法只会返回一个Object类型的值。
那么为什么会这样呢?
? super X 表示类型的下界,类型参数是X的超类(包括X本身),那么可以肯定的说,get方法返回的一定是个X的超类,那么到底是哪个超类?不知道,但是可以肯定的说,Object一定是它的超类,所以get方法返回Object。编译器是可以确定知道的。对于set方法来说,编译器不知道它需要的确切类型,但是X和X的子类可以安全的转型为X,而X的超类不能安全的转型为X。
总结:主要用于安全地写入数据,可以写入X及其子类型。
无限定的通配符 ?
表示对类型没有什么限制,可以把?看成所有类型的父类,如Pair< ?>;
比如:
ArrayList<T> al=new ArrayList<T>(); 指定集合元素只能是T类型
ArrayList<?> al=new ArrayList<?>();集合元素可以是任意类型,这种没有意义,一般是方法中,只是为了说明用法。
在使用上:
? getFirst() : 返回值只能赋给 Object;
void setFirst(?) : setFirst 方法不能被调用, 甚至不能用 Object 调用;
八、虚拟机是如何实现泛型的?
泛型思想早在C++语言的模板(Template)中就开始生根发芽,在Java语言处于还没有出现泛型的版本时,只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。由于Java语言里面所有的类型都继承于java.lang.Object,所以Object转型成任何对象都是有可能的。但是也因为有无限的可能性,就只有程序员和运行期的虚拟机才知道这个Object到底是个什么类型的对象。在编译期间,编译器无法检查这个Object的强制转型是否成功,如果仅仅依赖程序员去保障这项操作的正确性,许多ClassCastException的风险就会转嫁到程序运行期之中。
泛型技术在C#和Java之中的使用方式看似相同,但实现上却有着根本性的分歧,C#里面泛型无论在程序源码中、编译后的IL中(Intermediate Language,中间语言,这时候泛型是一个占位符),或是运行期的CLR中,都是切实存在的,List<int>与List<String>就是两个不同的类型,它们在系统运行期生成,有自己的虚方法表和类型数据,这种实现称为类型膨胀,基于这种方法实现的泛型称为真实泛型。
Java语言中的泛型则不一样,它只在程序源码中存在,在编译后的字节码文件中,就已经替换为原来的原生类型(Raw Type,也称为裸类型)了,并且在相应的地方插入了强制转型代码,因此,对于运行期的Java语言来说,ArrayList<int>与ArrayList<String>就是同一个类,所以泛型技术实际上是Java语言的一颗语法糖,Java语言中的泛型实现方法称为类型擦除,基于这种方法实现的泛型称为伪泛型。
将一段Java代码编译成Class文件,然后再用字节码反编译工具进行反编译后,将会发现泛型都不见了,程序又变回了Java泛型出现之前的写法,泛型类型都变回了原生类型
public static String method(List<String> stringList){
System.out.println("String List");
return "String";
}
public static String method(List<Integer> integerList){
System.out.println("Integer List");
return Integer;
}
上面这段代码是不能被编译的,因为参数List<Integer>和List<String>编译之后都被擦除了,变成了一样的原生类型List<E>,擦除动作导致这两种方法的特征签名变得一模一样。
(方法重载时两个方法方法名和参数都相同,返回值类型不同是,jdk的编译器不会报错,但是一般IDE的编译器会报错)。
由于Java泛型的引入,各种场景(虚拟机解析、反射等)下的方法调用都可能对原有的基础产生影响和新的需求,如在泛型类中如何获取传入的参数化类型等。因此,JCP组织对虚拟机规范做出了相应的修改,引入了诸如Signature、LocalVariableTypeTable等新的属性用于解决伴随泛型而来的参数类型的识别问题,Signature是其中最重要的一项属性,它的作用就是存储一个方法在字节码层面的特征签名[3],这个属性中保存的参数类型并不是原生类型,而是包括了参数化类型的信息。修改后的虚拟机规范要求所有能识别49.0以上版本的Class文件的虚拟机都要能正确地识别Signature参数。
另外,从Signature属性的出现我们还可以得出结论,擦除法所谓的擦除,仅仅是对方法的Code属性中的字节码进行擦除,实际上元数据中还是保留了泛型信息,这也是我们能通过反射手段取得参数化类型的根本依据。