扫二维码与项目经理沟通
我们在微信上24小时期待你的声音
解答本文疑问/技术咨询/运营咨询/技术建议/互联网交流
本文主要介绍在泛型定义中的< >中的占位符如何配合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 = new Solid(new Bounded());
solid.color();
solid.getY();
solid.weight();
}
} ///:~ 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 = new Solid(new derivedBounded());//给定的具体类型不符合边界
Solid solid1 = new Solid(new derivedBounded());//可以传递具体类型Bounded的子类
//Solid solid2 = new Solid(new Bounded1());//编译报错，因为泛型的静态类型检查
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."":()V
11: invokespecial #5 // Method Solid."":(LDimension;)V
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 extends HoldItem { 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 solid2 = new Solid2 (new Bounded()); solid2.color(); solid2.getY(); solid2.weight(); } } ///:~
总结一下：
当一个泛型类继承另一个泛型类时（前者属于“定义泛型类”，后者属于“使用泛型类”），且使用了同一个类型参数时，定义泛型类的类型参数边界定义一定要小于等于使用的那个泛型类的边界要求。
泛型方法中的边界定义
泛型方法中对类型参数的边界定义，同样也得符合使用的泛型类的边界要求。此例中，泛型类同样继承别的泛型类，分析同上不赘述。讲下类的实际意义：一系列接口代表了超能力、一系列类代表了超级英雄，它们拥有一个超能力的成员变量。
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 extends SuperHero {
SuperSleuth(POWER power) { super(power); }
void see() { power.seeThroughWalls(); }
}
class CanineHero extends SuperHero {
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) {//泛型方法
hero.getPower().hearSubtleNoises();
}
static
void superFind(SuperHero hero) {//泛型方法
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;
}
} ///:~
其他
本文例子均来自java编程思想，例子本身不错，但奈何作者对其做的讲解很少，所以本人为其加上了详细的分析。其实这些例子都需要反复琢磨，精读之后才会对泛型的extends关键字有深刻的理解。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持创新互联。
我们在微信上24小时期待你的声音
解答本文疑问/技术咨询/运营咨询/技术建议/互联网交流
微信二维码
移动版官网