第九课时：泛型

　　　　一、定义泛型接口、类

　　　　JDK 1.5 改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

　　　　下面是 JDK 1.5 改写后 List 接口、Iterator 接口、Map 的代码片段：

　　　　// 定义接口时制定了一个类型形参，该形参名为 E

　　　　public interface List<E>

　　　　{

　　　　　　　　// 在该接口里，E 可作为类型使用

　　　　　　　　// 下面方法可以使用 E 作为参数类型

　　　　　　　　void add(E x);

　　　　　　　　Iterator<E> iterator();

　　　　}

　　　　// 定义接口时制定了一个类型形参，该形参名为 E

　　　　public interface Iterator<E>

　　　　{

　　　　　　　　// 在该接口里 E 完全可以作为类型使用

　　　　　　　　E next();

　　　　　　　　bollean hasNext();

　　　　}

　　　　// 定义接口时制定了两个类型形参，该形参名为 K、V

　　　　public interface Map<K, V>

　　　　{

　　　　　　　　// 在该接口里 K, V 完全可以作为类型使用

　　　　　　　　Set<K> keySet();

　　　　　　　　V put(K key, V value);

　　　　}

　　　　我们可以为任何类增加泛型的声明（并不是只有集合类才可以使用泛型声明，虽然泛型是集合类的重要使用场所）。例：

　　　　public class Apple<T>

　　　　{

　　　　　　　　// 使用 T 类型形参定义属性

　　　　　　　　private T info;

　　　　　　　　public Apple(){}

　　　　　　　　// 下面方法中使用 T 类型参数来定义方法

　　　　　　　　public Apple(T info)

　　　　　　　　{

　　　　　　　　　　　　this.info = info;

　　　　　　　　}

　　　　　　　　public void setInfo(T info)

　　　　　　　　{

　　　　　　　　　　　　this.info = info;

　　　　　　　　}

　　　　　　　　public T getInfo()

　　　　　　　　{

　　　　　　　　　　　　return this.info;

　　　　　　　　}

　　　　}

            实例化带有泛型的 Apple 类：

           

             二、从泛型类派生子类

             当创建了带泛型声明的接口、父类之后，可以为该接口创建实现类，或者从该父类来派生子类，但是，当使用这些接口、父类时不能再包含类型形参。下面的代码是错误的：

             // 定义类 A 继承 Apple 类，Apple 类不能跟类型参数

             public class A extends Apple<T>{}

             如果想从 Apple 类派生一个子类，可以改为如下方法：

             // 使用 Apple 类时，为 T 形参传入 String 类型

             public class A extends Apple<String>

             当然也可以不为接口、类传入的类型参数传入实际类型，所以下面的代码也是正确的：

             public class A extends Apple

             如果从 Apple<String> 类派生子类，则在 Apple 类中所使用 T 类型形参的地方都将被替换成 String类型，即它的子类将会集成到 String getInfo() 和 void setInfo(String info) 两个方法，如果子类需要重新写父类的方法，必须注意到这一点。例如：

             public class A1 extends Apple<String>

             {

                      // 正确重写了父类的方法，返回值与父类 Apple<String> 的返回值完全相同

                      public String getInfo()

                      {

                               return "子类" + super.getInfo();

                      }

                      /*

                      // 下面方法是错误的，重写父类方法时返回值类型不一致

                      public Object getInfo()

                      {

                               return "子类";

                      }

                      */

             }

             三、并不存在泛型类

             我们可以把 ArrayList<String> 类当做 ArrayList 的子类，而事实上系统并没有为 ArrayList<String> 生成新的 class 文件，而且也不会把 ArrayList<String> 当成新类来处理。

             例如：下面程序的打印结果是true

             List<String> l1 = new ArrayList<String>();

             List<Integer> l2 = new ArrayList<Integer>();

             System.out.println(l1.getClass() == l2.getClass());

             静态方法、静态初始化或者静态变量的声明和初始化中不允许使用类型参数。

             下面程序演示了这种错误：

             public class R<T>

             {

                      // 下面程序代码错误，不能在静态属性声明中使用类型参数

                      static T info;

                      T age;

                      public void foo(T msg){}

                      // 下面代码错误，不能在静态方法声明中使用类型形参

                      public static void bar(T msg){}

             }

             由于系统中并不会真正生成泛型类，所以 instanceof 运算符后不能使用泛型类，例如下面的代码是错误的：

             Collection cs = new ArrayList<String>();

             // 下面代码编译时引发错误：instanceof 运算符后不能使用泛型类

             if(cs instanceof List<String>){...}

 

             四、类型通配符

             如果 SubClass 是 SuperClass 的子类型（子类或者子接口），而 G 是具有泛型声明的类或者接口，那么 G<SubClass> 是 G<SuperClass> 的子类型并不成立。例如：List<String> 并不是 List<Object> 的子类。

             与数组进行对比：

             // 下面程序编译正常、运行正常

             Number[] nums = new Integer[7];
             nums[0] = 9;
             System.out.println(nums[0]);

             // 面程序编译正常、运行时发生 java.lang.ArrayStoreException 异常
             Integer[] ints = new Integer[5];
             Number[] nums2 = ints;
             nums2[0] = 0.4;
             System.out.println(nums2[0]);

             // 下面程序发生编译异常，Type mismatch: cannot convert from List<Integer> to List<Number>
             List<Integer> iList = new ArrayList<Integer>();
             List<Number> nList = iList;

 

             数组和泛型有所不同，如果 SubClass 是 SuperClass 的子类型（子类或者子接口），那么 SubClass[] 依然是 SuperClass[] 的子类；但是 G<SubClass> 不是 G<SuperClass> 的子类。

             如何适用类型通配符：

             为了表示各种泛型 List 的父类，我们需要使用类型通配符，类型通配符是一个问号 （？），将一个问号作为类型实参传给 List 集合，写作：List<?> （意思是未知类型元素的 List）。这个问号 （？） 被称作通配符，它的元素类型可以匹配任何类型。例如：

             public void test(List<?> c)

             {

                      ...

             }

             现在我们可以使用任何类型的 List 来调用它，程序依然可以访问集合 c 中的元素，其类型是 Object。

             这种写法适用于任何支持泛型声明的接口和类，例如：Set<?>、Collection<?>、Map<?, ?>等。

             但是这种带通配符的 List 仅表示它是各种泛型 List 的父类，并不能把元素加入到其中，例如下面的代码将引发编译错误：

             List<?> c = new ArrayList<String>();

             // 下面程序引发编译错误

             c.add(new Object());

             因为我们不知道上面程序中 c 集合中的元素类型，所以不能向其中添加对象。唯一的例外是 null，它是所有引用类型的实例。例如：下面程序是正确的：

             c.add(null);

 

             五、设置类型通配符的上限

             当直接使用 List<?> 这种形式时，即表明这个 List 集合是任何泛型 List 的父类。但还有一种特殊的情况，我们不想这个 List<?> 是任何泛型 List 的父类，只想表示它是某一类泛型 List 的父类。

             被限制的泛型通配符如下表示：

             List<? extends SuperClass>

             六、设定类型形参的上限

             Java 泛型不仅允许在使用通配符形参时设定类型上限，也可以在定义类型形参时设定上限，用于表示传给该类型形参的实际类型必须是上限类型，或是该上限类型的子类。例如：

             
             import java.util.*;

             public class Apple<T extends Number>
             {
                       T col;
 
                        public static void main(String[] args)
                        {
                                   Apple<Integer> ai = new Apple<Integer>();
                                   Apple<Double> ad = new Apple<Double>();
                                   //下面代码将引起编译异常
                                   //因为String类型传给T形参，但String不是Number的子类型。
                                   Apple<String> as = new Apple<String>();
                        }
            }

 

            有时候程序需要为类型形参设定多个上限（至多有一个父类上限，可以有多个接口上限）表明该类型形参必须是其父类的子类（包括是父类本身也行），并且实现多个上限接口。例如：

             // 表明 T 类型必须是 Number 类或其子类，并必须实现 java.io.Serializable 接口

             public class Apple<T extends Number & java.io.Serializable>

             {

                          ...

             }

 

             七、泛型方法

             1、定义泛型方法

             泛型方法的用法格式是：

             修饰符 <T, S> 返回值类型 方法名(形参列表)
             {

                         // 方法体……

             }

             示例：

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

             {

                         for(Object o : a)

                         {

                                    c.add(o);

                         }

             }

             上面的方法中形参 c 的数据类型是 Collection<Object>，因为 Collection<Object> 不是 Collection<String> 类的父类，所以这个方法的功能非常有限，它只能将 Object 数组的元素复制到 Object (Object 的子类不行) Collection 集合，及下面的代码会引发编译异常：

             String[] str = {"a", "b"};

             List<String> strList = new ArrayList<String>();

             // Collection<String> 对象不能当成 Collection<Object> 调用，下面的代码出现编译异常

             fromArrayGToCollection(str, strList);

             上面方法的参数类型不可以使用 Collection<String>，那是用通配符 Collection<?> 也是不可行的，因为不能把对象放进一个未知类型的集合当中去。

             使用泛型方法解决这个问题：

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

             {

                      for (T o : a)

                      {

                                  c.add(o);

                      }

             }

             public static void main(String[] args)
             {
                      Object[] oa = new Object[100];
                      Collection<Object> co = new ArrayList<Object>();
                      //下面代码中T代表Object类型
                      fromArrayToCollection(oa, co);
                      String[] sa = new String[100];
                      Collection<String> cs = new ArrayList<String>();
                      //下面代码中T代表String类型
                      fromArrayToCollection(sa, cs);
                      //下面代码中T代表Object类型
                      fromArrayToCollection(sa, co);
                      Integer[] ia = new Integer[100];
                      Float[] fa = new Float[100];
                      Number[] na = new Number[100];
                      Collection<Number> cn = new ArrayList<Number>();
                      //下面代码中T代表Number类型
                      fromArrayToCollection(ia, cn);
                      //下面代码中T代表Number类型
                      fromArrayToCollection(fa, cn);
                      //下面代码中T代表Number类型
                      fromArrayToCollection(na, cn);
                      //下面代码中T代表String类型
                      fromArrayToCollection(na, co);
                      //下面代码中T代表String类型，但na是一个Number数组，
                      //因为Number既不是String类型，也不是它的子类，所以出现编译错误
                      fromArrayToCollection(na, cs);
           }

           上面程序定义了一个泛型方法，该泛型方法中定义了一个 T 类型形参，这个 T 类型形参就可以在该房内当成普通类型来使用。与在接口、类中定义的类型形参不同的是，方法声明中定义的类型形参只能在方法里使用，而接口、类声明中定义的类型形参则可以住在整个接口、类中使用。

           与类、接口中使用泛型参数不同的是，方法中的泛型参数无需显式传入实际类型参数，如上面程序中，当程序调用 fromArrayToCollection 时，无须在调用该方法前传入 String、Object 等类型，编译器可以根据实参推断出类型形参的值。

          但是不要是编译器迷惑，例如下面的程序：

          public class Test

          {

                    // 声明一个泛型方法，该泛型方法中带一个 T 类型参数

                    static <T> void test(Collection<T> a, Collection<T> c)

                    {

                                // 方法体

                    }

                    public static void main(String[] args)

                    {

                               List<Object> ao = new ArrayList<Object>();

                               List<String>  as = new ArrayList<String>();

 

                               // 下面代码将产生编译错误

                               test(as, ao);

                    }

          }

          上面程序中，编译器无法正确识别 T 所代表的实际类型。可以将该方法修改为下面的形式：

          public class Test

          {

                    // 声明一个泛型方法，该泛型方法中带一个 T 类型参数

                    static <T> void test(Collection<? extends T> a, Collection<T> c)

                    {

                                // 方法体

                    }

                    public static void main(String[] args)

                    {

                               List<Object> ao = new ArrayList<Object>();

                               List<String>  as = new ArrayList<String>();

 

                               // 下面代码编译正常

                               test(as, ao);

                    }

          }

          上面代码中将方法的第一个形参类型修改为 Collection<? extends T>，这种采用类型通配符的表示方法，只要 test 方法的前一个 Collection 集合元素类型是后一个 Collection 集合元素类型的子类即可。

          2、泛型方法和类型通配符的区别

          JDK 中对于 Collection 接口中两个方法的定义：

          public interface Collection<E>

          {

                    boolean containsAll(Collection<?> c);

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

          }

          上面两个方法都采用了类型通配符的形式，如果采用泛型方法形式来代替它们，如下所示:

          public interface Collection<E>

          {

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

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

          }

          上面方法使用了 <T extends E> 泛型形式，这是定义类型形参时设定上限。

          3、设定通配符的下限

          Java 允许设置通配符下限：<? super Type>，这个通配符表示它必须是 Type 本身，或者是 Type 的父类。示例：

          public class MyUtils

          {

                     // 下面 dest 集合元素类型必须与 src 集合元素类型相同，或是其父类

                     public static <T> copy(Collection<? super T> dest, Collection<T> src)

                     {

                                 T last = null;

                                 for(T ele : src)

                                 {

                                             last = ele;

                                             dest.add(ele);

                                 }

                                 return last;

                     }

                     public static void main(String[] args)

                     {

                                 List<Number> ln = new ArrayList<Number>();

                                 List<Integer> ln = new ArrayList<Integer>();

                                 li.add(5);

                                 // 此处可准确的知道最后一个被复制的元素是 Integer 类型（与 src 集合元素的类型相同）

                                 Integer last = copy(ln, li);

                                 System.out.println(ln);

                     }

          }