多平台统一管理软件接口,如何实现多平台统一管理软件接口
209
2022-12-26
Java泛型extends关键字设置边界的实现
本文主要介绍在泛型定义中的< >中的占位符如何配合extends关键字使用,形如
一般的泛型定义中的
使用了extends的泛型定义中的
接下来本文将以几个示例和具体分析来讲解剩下的知识点。
类型参数多边界的分析
此例中的泛型类,类型参数带有多个边界。讲下类的实际意义:Dimension代表物体的方位、HasColor代表物体的颜色、Weight代表物体的重量。
interface HasColor { java.awt.Color getColor(); }
class Colored
T item;
Colored(T item) { this.item = item; }
T getItem() { return item; }
// The bound allows you to call a method:
java.awt.Color color() { return item.getColor(); }
}
class Dimension { public int x, y, z; }
// This won't work -- class must be first, then interfaces:
// class ColoredDimension
// Multiple bounds:
class ColoredDimension
T item;
ColoredDimension(T item) { this.item = item; }
T getItem() { return item; }
java.awt.Color color() { return item.getColor(); }
int getX() { return item.x; }
int getY() { return item.y; }
int getZ() { return item.z; }
}
interface Weight { int weight(); }
// As with inheritance, you can have only one
// concrete class but multiple interfaces:
class Solid
T item;
Solid(T item) { this.item = item; }
T getItem() { return item; }
java.awt.Color color() { return item.getColor(); }
int getX() { return item.x; }
int getY() { return item.y; }
int getZ() { return item.z; }
int weight() { return item.weight(); }
}
class Bounded extends Dimension implements HasColor, Weight {
public java.awt.Color getColor() { return null; }
public int weight() { return 0; }
}
public class BasicBounds {
public static void main(String[] args) {
Solid
solid.color();
solid.getY();
solid.weight();
}
} ///:~
class Colored
class ColoredDimension
class ColoredDimension
class Solid
class Bounded extends Dimension implements HasColor, Weight这个类将在生成泛型类对象,用来指定具体类型为Bounded。因为class Solid
class derivedBounded extends Bounded {}
class Bounded1 extends Dimension implements HasColor, Weight {
public java.awt.Color getColor() { return null; }
public int weight() { return 0; }
}
public class BasicBounds {
public static void main(String[] args) {
//Solid
Solid
//Solid
solid1.color();
solid1.getY();
solid1.weight();
}
} ///:~
根据上一条,那么new Solid
但是类型参数有多个边界时,java内部即java字节码到底是怎么处理的呢:
public static void main(java.lang.String[]);
Code:
0: new #2 // class Solid
3: dup
4: new #3 // class Bounded
7: dup
8: invokespecial #4 // Method Bounded."
11: invokespecial #5 // Method Solid."
14: astore_1
从Method Solid."
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
import java.awt.Color;
class Solid
T item;
Solid(T item) {
this.item = item;
}
T getItem() {
return this.item;
}
Color color() {
return ((HasColor)this.item).getColor();//类型转换为其他边界,再调用方法
}
int getX() {
return this.item.x;
}
int getY() {
return this.item.y;
}
int getZ() {
return this.item.z;
}
int weight() {
return ((Weight)this.item).weight();//类型转换为其他边界,再调用方法
}
}
当调用的方法不属于第一个边界时,就进行类型转换处理为其他边界就行,反正T肯定是符合extends Dimension & HasColor & Weight的。
继承有边界要求的泛型类
通过观察上例可知,Colored、ColoredDimension、Solid这三个类在持有对象的方面有冗余的地方:都有同一个成员变量、同一个构造器、同一个get函数。而类型参数上,边界也是依次叠加的。同样,对于这些边界所带来的属性和方法,也是冗余的。
所以下例对其进行了修改,通过继承来消除冗余,注意,下面继承的泛型类对类型参数是有边界要求的:
//HoldItem对边界T没有要求
class HoldItem
T item;
HoldItem(T item) { this.item = item; }
T getItem() { return item; }
}
//Colored2对边界T有HasColor的要求
class Colored2
Colored2(T item) { super(item); }
java.awt.Color color() { return item.getColor(); }
}
//ColoredDimension2对边界T有Dimension & HasColor的要求
class ColoredDimension2
extends Colored2
ColoredDimension2(T item) { super(item); }
int getX() { return item.x; }
int getY() { return item.y; }
int getZ() { return item.z; }
}
//Solid2对边界T有Dimension & HasColor & Weight的要求,不过没有类继承它了
class Solid2
extends ColoredDimension2
Solid2(T item) { super(item); }
int weight() { return item.weight(); }
}
public class InheritBounds {
public static void main(String[] args) {
Solid2
new Solid2
solid2.color();
solid2.getY();
solid2.weight();
}
} ///:~
HoldItem这个泛型类通过类型参数T把成员变量、构造器、get函数都定义好了,之后的类通过继承它就可以获得这些属性和方法。
Colored2泛型类继承了HoldItem,获得了后者的属性和方法从而减少了冗余。同时,class Colored2
ColoredDimension2泛型类继承了Colored2。从边界是否符合的情况分析,Colored2对T的边界要求是
Solid2泛型类继承了ColoredDimension2。从边界是否符合的情况分析,
总结一下:
当一个泛型类继承另一个泛型类时(前者属于“定义泛型类”,后者属于“使用泛型类”),且使用了同一个类型参数时,定义泛型类的类型参数边界定义一定要小于等于使用的那个泛型类的边界要求。
泛型方法中的边界定义
泛型方法中对类型参数的边界定义,同样也得符合使用的泛型类的边界要求。此例中,泛型类同样继承别的泛型类,分析同上不赘述。讲下类的实际意义:一系列接口代表了超能力、一系列类代表了超级英雄,它们拥有一个超能力的成员变量。
import java.util.*;
interface SuperPower {}
interface XRayVision extends SuperPower {
void seeThroughWalls();
}
interface SuperHearing extends SuperPower {
void hearSubtleNoises();
}
interface SuperSmell extends SuperPower {
void trackBySmell();
}
class SuperHero
POWER power;
SuperHero(POWER power) { this.power = power; }
POWER getPower() { return power; }
}
class SuperSleuth
SuperSleuth(POWER power) { super(power); }
void see() { power.seeThroughWalls(); }
}
class CanineHero
CanineHero(POWER power) { super(power); }
void hear() { power.hearSubtleNoises(); }
void smell() { power.trackBySmell(); }
}
class SuperHearSmell implements SuperHearing, SuperSmell {
public void hearSubtleNoises() {}
public void trackBySmell() {}
}
class DogBoy extends CanineHero
DogBoy() { super(new SuperHearSmell()); }
}
public class EpicBattle {
// Bounds in generic methods:
static
void useSuperHearing(SuperHero
hero.getPower().hearSubtleNoises();
}
static
void superFind(SuperHero
hero.getPower().hearSubtleNoises();
hero.getPower().trackBySmell();
}
public static void main(String[] args) {
DogBoy dogBoy = new DogBoy();
useSuperHearing(dogBoy);
superFind(dogBoy);
// You can do this:
List extends SuperHearing> audioBoys;
// But you can't do this:
// List extends SuperHearing & SuperSmell> dogBoys;
}
} ///:~
主函数中的useSuperHearing泛型方法中,其对T的边界定义为
主函数中的useSuperHearing泛型方法中,其对T的边界定义为
其他
版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。
发表评论
暂时没有评论,来抢沙发吧~