Jdk5.0新特性——Generic Types （泛型） /第5章

5.泛型方法

考虑写一个持有数组类型对象和一个集合对象的方法，把数组里的所有对象都放到

集合里。第一个程序为：

   static void fromArrayToColleciton(Object[]a,Collection<?> c){

     for (Object o : a){

        c.add(o);//编译时错误

        }

   }

到现在为止，你可能学会避免开始的错误而去使用Collection<Object>作为集合参数的类型，你可能会意识到使用Colleciton<?>将不会工作。

解决这个问题的方法是使用泛型方法，GENERIC METHODS，就像类型声明、方法声明一样，就是被一个或更多的类型参数参数化。

   static <T> void fromArrayToCollection(T[]a,Collection<T> c){

        for(T o :a){

             c.add(o);//正确

            }

   }

    我们可以用任意类型的集合调用这个方法，他的元素类型是数组元素类型的超类型。

   Object[] oa = new Object[100];

   Collection <Object> co = new ArrayList<Object>();

   fromArrayToCollection(oa,co);//T 被认为是Object类型

   String[] sa = new String[100];

   Colleciton<String> cs = new ArrayList<String>();

   fromArrayToCollection(sa,cs);//T被认为是String类型

   fromArrayToCollection(sa,co);//T 被认为是Object类型

   Integer[] is = new Integer[100];

   Float[] fa = new Float[100];

   Number[] na = new Number[100];

   Collection<Number> cn = new ArrayList<Number>(); 

   fromArrayToCollection(is,cn);//Number

   fromArrayToCollection(fa,cn);//Number

   fromArrayToCollection(na,cn);//Number

   fromArrayToCollection(na,co);//Object

   fromArrayToCollection(na,cs);//编译时错误

我们不必给一个泛型方法传递一个真正的类型参数,编译器会推断类型参数.一个问题出现了,什么时候使用泛型方法,什么时候使通配符类型,为了回答这些问题,我们从Colleciton库中看一下几个方法：

    interface Collection<E>{

           public boolean containsAll(Collection<?> c);

           public boolean addAll(Collection<? extends E> c);

    }

    使用泛型方法的形式为：

    interface Collection<E>{

           public <T> boolean containsAll(Collection<T> c);

           public <T extends E> boolean addAll(Collection<T> c);

    } 

   无论如何，在ContainAll和addAll中，类型参数T仅被使用一次。返回类型不依赖于类型参数，也不依赖方法中的任何参数。这告诉我类型参数正被用于多态，它的影响仅仅是允许不同的实参在不同的调用点被使用。

   泛型方法允许类型参数被用于表达在一个或更多参数之间或者方法中的参数、返回类型的依赖。如果没有如此依赖，泛型方法就不能被使用。可能一前一后来联合使用泛型和通配符，这里有个例子：

    class Collections{

      public static <T> void copy(List<T> dest,List<? extends T> src){

    }

  }

    注意两个参数之间的依赖，任何从原list的对象复制，必须分配一个目标LIST元素的类型T,于是Src的元素类型可能是任何T的子类型。我们不必在意在COPY的表达中，表示依赖使用一个类型参数，但是是使用一个通配符。

    下面我们不使用通配符来重写上面的方法：

     class Collections{

      public static <T，S extends T>

      void copy(List<T> dest,List<S> src){

    }

  } 

    这非常好，但是第一个类型参数既在dst中使用，也在第二个类型参数中使用，S本身就被使用了一次。在类型src中,没有什么类型依赖它。这是一个标志我们可以用通配符来替换它。使用通配符比显示的声明类型参数更加清楚和精确。所以有可能推荐使用通配符。

   通配符也有优势，可以在方法之外来使用，作为字段类型、局部变量和数组。

这里有一个例子。

   返回到我们画图的例子，假设我们要保持一个画图请求的历史，我们可以在Shape类内部用一个静态变量来保持历史。用drawAll()存储它到来的参数到历史字段。

   static List<List<? extends Shape>> history =

   new ArrayList<List<? extends Shape>>();

   public void drawAll(List<? extends Shape> shapes){

    history.addLast(shapes);

    for (Shape s : shapes){

           s.draw(this);

         }

   }      

正在增加中。。。。。。