重新理解Java泛型

2023-09-20 11:58:05 254

这篇文章的目的在于介绍Java泛型，使大家对Java泛型的各个方面有一个最终的，清晰的，准确的理解，同时也为下一篇《重新理解Java反射》打下基础。

简介

泛型是Java中一个非常重要的知识点，在Java集合类框架中泛型被广泛应用。本文我们将从零开始来看一下Java泛型的设计，将会涉及到通配符处理，以及让人苦恼的类型擦除。

泛型基础

泛型类

我们首先定义一个简单的Box类：

publicclassBox{
privateStringobject;
publicvoidset(Stringobject){this.object=object;}
publicStringget(){returnobject;}
}

这是最常见的做法，这样做的一个坏处是Box里面现在只能装入String类型的元素，今后如果我们需要装入Integer等其他类型的元素，还必须要另外重写一个Box，代码得不到复用，使用泛型可以很好的解决这个问题。

publicclassBox{
//Tstandsfor"Type"
privateTt;
publicvoidset(Tt){this.t=t;}
publicTget(){returnt;}
}

这样我们的Box类便可以得到复用，我们可以将T替换成任何我们想要的类型：

BoxintegerBox=newBox();
BoxdoubleBox=newBox();
BoxstringBox=newBox();

泛型方法

看完了泛型类，接下来我们来了解一下泛型方法。声明一个泛型方法很简单，只要在返回类型前面加上一个类似的形式就行了：

publicclassUtil{
publicstaticbooleancompare(Pairp1,Pairp2){
returnp1.getKey().equals(p2.getKey())&&
p1.getValue().equals(p2.getValue());
}
}
publicclassPair{
privateKkey;
privateVvalue;
publicPair(Kkey,Vvalue){
this.key=key;
this.value=value;
}
publicvoidsetKey(Kkey){this.key=key;}
publicvoidsetValue(Vvalue){this.value=value;}
publicKgetKey(){returnkey;}
publicVgetValue(){returnvalue;}
}

我们可以像下面这样去调用泛型方法：

Pairp1=newPair<>(1,"apple");
Pairp2=newPair<>(2,"pear");
booleansame=Util.compare(p1,p2);

或者在Java1.7/1.8利用typeinference，让Java自动推导出相应的类型参数：

Pairp1=newPair<>(1,"apple");
Pairp2=newPair<>(2,"pear");
booleansame=Util.compare(p1,p2);

边界符

现在我们要实现这样一个功能，查找一个泛型数组中大于某个特定元素的个数，我们可以这样实现：

publicstaticintcountGreaterThan(T[]anArray,Telem){
intcount=0;
for(Te:anArray)
if(e>elem)//compilererror
++count;
returncount;
}

但是这样很明显是错误的，因为除了short,int,double,long,float,byte,char等原始类型，其他的类并不一定能使用操作符>，所以编译器报错，那怎么解决这个问题呢？答案是使用边界符。

publicinterfaceComparable{
publicintcompareTo(To);
}

做一个类似于下面这样的声明，这样就等于告诉编译器类型参数T代表的都是实现了Comparable接口的类，这样等于告诉编译器它们都至少实现了compareTo方法。

publicstatic>intcountGreaterThan(T[]anArray,Telem){
intcount=0;
for(Te:anArray)
if(e.compareTo(elem)>0)
++count;
returncount;
}

通配符

在了解通配符之前，我们首先必须要澄清一个概念，还是借用我们上面定义的Box类，假设我们添加一个这样的方法：

publicvoidboxTest(Boxn){/*...*/}

那么现在Boxn允许接受什么类型的参数？我们是否能够传入Box或者Box呢？答案是否定的，虽然Integer和Double是Number的子类，但是在泛型中Box或者Box与Box之间并没有任何的关系。这一点非常重要，接下来我们通过一个完整的例子来加深一下理解。

首先我们先定义几个简单的类，下面我们将用到它：

classFruit{}
classAppleextendsFruit{}
classOrangeextendsFruit{}

下面这个例子中，我们创建了一个泛型类Reader，然后在f1()中当我们尝试Fruitf=fruitReader.readExact(apples);编译器会报错，因为List与List之间并没有任何的关系。

publicclassGenericReading{
staticListapples=Arrays.asList(newApple());
staticListfruit=Arrays.asList(newFruit());
staticclassReader{
TreadExact(Listlist){
returnlist.get(0);
}
}
staticvoidf1(){
ReaderfruitReader=newReader();
//Errors:ListcannotbeappliedtoList.
//Fruitf=fruitReader.readExact(apples);
}
publicstaticvoidmain(String[]args){
f1();
}
}

但是按照我们通常的思维习惯，Apple和Fruit之间肯定是存在联系，然而编译器却无法识别，那怎么在泛型代码中解决这个问题呢？我们可以通过使用通配符来解决这个问题：

staticclassCovariantReader{
TreadCovariant(Listlist){
returnlist.get(0);
}
}
staticvoidf2(){
CovariantReaderfruitReader=newCovariantReader();
Fruitf=fruitReader.readCovariant(fruit);
Fruita=fruitReader.readCovariant(apples);
}
publicstaticvoidmain(String[]args){
f2();
}

这样就相当与告诉编译器，fruitReader的readCovariant方法接受的参数只要是满足Fruit的子类就行(包括Fruit自身)，这样子类和父类之间的关系也就关联上了。

PECS原则

上面我们看到了类似的用法，利用它我们可以从list里面get元素，那么我们可不可以往list里面add元素呢？我们来尝试一下：

publicclassGenericsAndCovariance{
publicstaticvoidmain(String[]args){
//Wildcardsallowcovariance:
Listflist=newArrayList();
//CompileError:can'taddanytypeofobject:
//flist.add(newApple())
//flist.add(newOrange())
//flist.add(newFruit())
//flist.add(newObject())
flist.add(null);//Legalbutuninteresting
//WeKnowthatitreturnsatleastFruit:
Fruitf=flist.get(0);
}
}

答案是否定，Java编译器不允许我们这样做，为什么呢？对于这个问题我们不妨从编译器的角度去考虑。因为Listflist它自身可以有多种含义：

Listflist=newArrayList();
Listflist=newArrayList();
Listflist=newArrayList();

当我们尝试add一个Apple的时候，flist可能指向newArrayList();
当我们尝试add一个Orange的时候，flist可能指向newArrayList();
当我们尝试add一个Fruit的时候，这个Fruit可以是任何类型的Fruit，而flist可能只想某种特定类型的Fruit，编译器无法识别所以会报错。

所以对于实现了的集合类只能将它视为Producer向外提供(get)元素，而不能作为Consumer来对外获取(add)元素。

如果我们要add元素应该怎么做呢？可以使用：

publicclassGenericWriting{
staticListapples=newArrayList();
staticListfruit=newArrayList();
staticvoidwriteExact(Listlist,Titem){
list.add(item);
}
staticvoidf1(){
writeExact(apples,newApple());
writeExact(fruit,newApple());
}
staticvoidwriteWithWildcard(Listlist,Titem){
list.add(item)
}
staticvoidf2(){
writeWithWildcard(apples,newApple());
writeWithWildcard(fruit,newApple());
}
publicstaticvoidmain(String[]args){
f1();f2();
}
}

这样我们可以往容器里面添加元素了，但是使用super的坏处是以后不能get容器里面的元素了，原因很简单，我们继续从编译器的角度考虑这个问题，对于Listlist，它可以有下面几种含义：

Listlist=newArrayList();
Listlist=newArrayList();
Listlist=newArrayList

重新理解Java泛型

热门推荐

随机推荐