java之泛型(2)
接上一篇使用通配符(?)
通配符
在上一篇中没有详细讲通配符的使用，萝卜刚开始学这儿的时候觉得不好理解，后来一下子想开了。萝卜觉得泛型最新重要的作用是解决了类型安全的问题，有些时候我们需要某种类型，同时不需要其他的类型，这个问题在泛型出现之前是很难解决的。
举个很简单的例子：容器类中都定义了泛型
ArrayList<String> strs = new ArrayList<String>
strs.add(13) //错误有时候我们不确定我们具体要传哪种类型，就可以使用<?>来匹配任意类型
例： 前面我们写过一个求平均数的方法，现在我们的需求是比较两个平均值是否相同。
这次我们定义一个类，接受一系列的数，可以求平均值，比较平均值是否相同。
public class Nums<T extends Number>{ //泛型限制只能传入数字类型
private T[] nums;
double aver;
public Nums(T... nums) {
this.nums = nums;
}
public double getAverage(){
double sum = 0;
for (T num : nums){
sum += num.doubleValue();
}
aver = sum/nums.length;
return aver;
}
public Boolean isSameAver(Nums<T> n2){
//这种方案适用范围很窄 只能比较两个类型参数一样的对象
//但是我们想比较不同类型的例如： Nums<Double> 和 Nums<Short>
//这个时候我们可以使用<?>来匹配
//public boolean isSameAver(Nums<?> n2)
if(this.getAverage()==n2.getAverage()){
return true;
}
return false;
}
}
有界通配符
前面我们已经用过有界的泛型：
<T extends 类名>指定泛型上界，
类型只能为指定类或其子类；<T super 类名>指定泛型的下界，类
型只能是指定类或其父类。
有界通配符的用法跟上面类似只要把T改成?就可以了，有时候我们需要某些类型但是不确定是具体哪种，尤其是存在多层次继承结构，有界通配符就会显得特别方便，最重要的是保证类型安全。
最典型例子就是显示N维坐标：
class TwoD {//二维坐标
int x;
int y;
public TwoD(int x, int y) {
this.x = x;
this.y = y;
}
}
class ThreeD extends TwoD{//三维坐标
int z;
public ThreeD(int x, int y, int z) {
super(x, y);
this.z = z;
}
}
class FourD extends ThreeD{//四维坐标
int t;
public FourD(int x, int y, int z, int t) {
super(x, y, z);
this.t = t;
}
}
class Points<T extends TwoD>{//只能接受坐标类型
T[] points;
public Points(T...points) {
this.points = points;
}
}
class ShowPoint{
public static void showXY(Points<? extends TwoD> p){//TwoD或继承TwoD的类都有x，y
for (int i=0; i<p.points.length; i++){
System.out.println("(" + "x=" + p.points[i].x + " y=" + p.points[i].y +")");
}
}
public static void showXYZ(Points<? extends ThreeD> p){//只有ThreeD或继承ThreeD的类才有z
for (int i=0; i<p.points.length; i++){
System.out.println("(" + "x=" + p.points[i].x + " y=" + p.points[i].y + " z=" + p.points[i].z + ")");
}
}
public static void ShowXYZT(Points<? extends FourD> p) {//只有FourD或继承FourD的类才有四个坐标
for (int i=0; i<p.points.length; i++){
System.out.println("(" + "x=" + p.points[i].x + " y=" + p.points[i].y + " z=" + p.points[i].z + " t="+ p.points[i].t + ")");
}
}
}
public class Demo {
public static void main(String[] args) {
Points<TwoD> twoDPoints = new Points<TwoD>(new TwoD(1, 2), new TwoD(2, 3));//二维坐标群
Points<ThreeD> threeDPoints = new Points<ThreeD>(new ThreeD(4, 5, 6), new ThreeD(5, 6, 7));//三维坐标群
Points<FourD> fourDPoints = new Points<FourD>(new FourD(6, 7, 8, 9),new FourD(7, 8, 9, 10));//四维坐标群
ShowPoint.showXY(twoDPoints); //ok
ShowPoint.showXY(threeDPoints);//ok
ShowPoint.showXY(fourDPoints);//ok
ShowPoint.showXYZ(threeDPoints);//ok
ShowPoint.showXYZ(fourDPoints);//ok
ShowPoint.ShowXYZT(fourDPoints);//ok
// ShowPoint.showXYZ(twoDPoints);//错误
// ShowPoint.showXYZT(ThreeDPoints);//错误；
}
}
结果： (x=1 y=2)
(x=2 y=3)
(x=4 y=5)
(x=5 y=6)
(x=6 y=7)
(x=7 y=8)
(x=4 y=5 z=6)
(x=5 y=6 z=7)
(x=6 y=7 z=8)
(x=7 y=8 z=9)
(x=6 y=7 z=8 t=9)
(x=7 y=8 z=9 t=10)
从上面的例子可以看出有界通配符用起来还是很方便的，可以按我们的意愿指定类型。
JDK1.7之后有了类型推断：
比如前面我们要创建Points对象时要Points<TwoD> twoDs = new Points<Twod>(new TwoD(1,2))有了类型推断之后，我们可以
Points<TwoD> twoDs = new Points<>(new TwoD(1,2))
关于泛型还有几点要注意
泛型不能被实例化，因为他只是一个占位符嘛。
class Demo<T>{
T t = new T;//错误...
}静态方法不能使用类上定义的泛型，因为静态方法优先于对象存在，静态方法只能使用定义在自己身上的泛型。
class Demo<T>{ public static void method(T t){}//错误}使用泛型数组的时候不能实例化，而且不能创建具体类型的泛型数组
public class Demo <T>{ T[] ts;//ok ts = new T[10];//错 误，编译器无法知道自己创建什么具体的数据类型的数组
Demo<String>[] strs = new Demo<String>[10];//错误
Demo<?>[] strs = new Demo<?>[10];//ok
}