Java之泛型（2）

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
    }