冯志霞201771010107《面向对象程序设计（java）》第十周学习总结

实验十 泛型程序设计技术

实验时间 2018-11-1

1、实验目的与要求

(1) 理解泛型概念；

(2) 掌握泛型类的定义与使用；

(3) 掌握泛型方法的声明与使用；

(4) 掌握泛型接口的定义与实现；

(5)了解泛型程序设计，理解其用途。

Java中泛型类的定义也比较简单，例如：public class Test<T>{}。这样就定义了一个泛型类Test，在实例化该类时，必须指明泛型T的具体类型，例如：Test<Object> t = new Test<Object>();，指明泛型T的类型为Object。

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型。

冯志霞201771010107《面向对象程序设计（java）》第十周学习总结

调用泛型方法语法格式如下：

冯志霞201771010107《面向对象程序设计（java）》第十周学习总结

说明一下，定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。

Class<T>的作用就是指明泛型的具体类型，而Class<T>类型的变量c，可以用来创建泛型类的对象。

为什么要用变量c来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。

泛型方法要求的参数是Class<T>类型，而Class.forName()方法的返回值也是Class<T>，因此可以用Class.forName()作为参数。其中，forName()方法中的参数是何种类型，返回的Class<T>就是何种类型。在本例中，forName()方法中传入的是User类的完整路径，因此返回的是Class<User>类型的对象，因此调用泛型方法时，变量c的类型就是Class<User>，因此泛型方法中的泛型T就被指明为User，因此变量obj的类型为User。

当然，泛型方法不是仅仅可以有一个参数Class<T>，可以根据需要添加其他参数。

为什么要使用泛型方法呢？因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。

定义泛型方法

(1) 如果你定义了一个泛型（类、接口），那么Java规定，你不能在所有的静态方法、静态初块等所有静态内容中使用泛型的类型参数。例如：

public class A<T> {
    public static void func(T t) {
    //报错，编译不通过
    }
}

(2) 如何在静态内容（静态方法）中使用泛型，更一般的问题是，如果类（或者接口）没有定义成泛型，但是就想在其中某几个方法中运用泛型（比如接受一个泛型的参数等），该如何解决？

定义泛型方法就像定义泛型类或接口一样，在定义类名（或者接口名）的时候需要指定我的作用域中谁是泛型参数。例如：public class A<T> { ... }表明在类A的作用域中，T是泛型类型参数。
定义泛型方法，其格式是：修饰符 <类型参数列表> 返回类型方法名(形参列表) { 方法体 }。例如：public static <T, S> int func(List<T> list, Map<Integer, S> map) { ... }，其中T和S是泛型类型参数。
泛型方法的定义和普通方法定义不同的地方在于需要在修饰符和返回类型之间加一个泛型类型参数的声明，表明在这个方法作用域中谁才是泛型类型参数；
不管是普通的类/接口的泛型定义，还是方法的泛型定义都逃不出两大要素：
- 明哪些是泛型类型参数；
- 这些类型参数在哪里使用。

(3) 类型参数的作用域

class A<T> { ... }中T的作用域就是整个A；
public <T> func(...) { ... }中T的作用域就是方法func；
类型参数也存在作用域覆盖的问题，可以在一个泛型模板类/接口中继续定义泛型方法，例如：

class A<T> {
    // A已经是一个泛型类，其类型参数是T
    public static <T> void func(T t) {
    // 再在其中定义一个泛型方法，该方法的类型参数也是T
    }
}
//当上述两个类型参数冲突时，在方法中，方法的T会覆盖类的T，即和普通变量的作用域一样，内部覆盖外部，外部的同名变量是不可见的。
//除非是一些特殊需求，一定要将局部类型参数和外部类型参数区分开来，避免发生不必要的错误，因此一般正确的定义方式是这样的：
class A<T> {
    public static <S> void func(S s) {

    }
}

(4) 泛型方法的类型参数可以指定上限，类型上限必须在类型参数声明的地方定义上限，不能在方法参数中定义上限。规定了上限就只能在规定范围内指定类型实参，超出这个范围就会直接编译报错。

<T extends X> void func(List<T> list){ ... }，正确
<T extends X> void func(T t){ ... }，正确
<T> void func(List<T extends X> list){ ... } ，编译错误

2. 泛型调用

(1) 显式指定方法的类型参数，类型参数要写在尖括号中并放在方法名之前。例如：object.<String> func(...)，这样就显式指定了泛型方法的类型参数为String，那么所有出现类型参数T的地方都将替换成String类型。

(2) 隐式地自动推断，不指明泛型参数，编译器根据传入的实参类型自动推断类型参数。例如：<T> void func(T t){ ... }隐式调用object.func("name"),根据"name"的类型String推断出类型参数T的类型是String

(3) 避免歧义，例如：<T> void func(T t1, T t2){ ... }如果这样调用的话object.func("name", 15); 虽然编译不会报错，但是仍然会有很大隐患，T到底应该是String还是Integer存在歧义；

(4) 有些歧义Java是会直接当成编译错误的，即所有和泛型参数有关的歧义，例如：<T> void func(List<T> l1, List<T> l2){...}如果这样调用的话，object.func(new List<String>(), new List<Integer>()); 这里会有歧义，编译器无法知道T到底应该是String还是Integer，这种歧义会直接报错的，编译无法通过。即泛型方法中，如果类型参数刚好就是泛型参数的类型实参，那么这个类型实参不得有歧义，否则直接编译报错。

3. 泛型方法/类型通配符

(1) 你会发现所有能用类型通配符（?）解决的问题都能用泛型方法解决，并且泛型方法可以解决的更好。

类型通配符：void func(List<? extends A> list);
完全可以用泛型方法完美解决：<T extends A> void func(List<T> list);

(2) 两种方法可以达到相同的效果，“?”可以代表范围内任意类型，而T也可以传入范围内的任意类型实参，并且泛型方法更进一步，“?”泛型对象是只读的，而泛型方法里的泛型对象是可修改的，即List<T> list中的list是可修改的。

(3) 两者最明显的区别

“?”泛型对象是只读的，不可修改，因为“?”类型是不确定的，可以代表范围内任意类型；
而泛型方法中的泛型参数对象是可修改的，因为类型参数T是确定的（在调用方法时确定），因为T可以用范围内任意类型指定；

2、实验内容和步骤

实验1： 导入第8章示例程序，测试程序并进行代码注释。

测试程序1：

l 编辑、调试、运行教材311、312页代码，结合程序运行结果理解程序；

l 在泛型类定义及使用代码处添加注释；

l 掌握泛型类的定义及使用

package pair1;

/**
 * @version 1.01 2012-01-26
 * @author Cay Horstmann
 */
public class PairTest1
{
   public static void main(String[] args)
   {
      String[] words = { "Mary", "had", "a", "little", "lamb" };
      Pair<String> mm = ArrayAlg.minmax(words);//将Pair类型实例化
      System.out.println("min = " + mm.getFirst());
      System.out.println("max = " + mm.getSecond());
   }
}

class ArrayAlg
{
   /**
    * Gets the minimum and maximum of an array of strings.
    * @param a an array of strings
    * @return a pair with the min and max value, or null if a is null or empty
    */
   public static Pair<String> minmax(String[] a)
   {
      if (a == null || a.length == 0) return null;//判断a是否合法
      String min = a[0];
      String max = a[0];//初始化
      for (int i = 1; i < a.length; i++)
      {
         if (min.compareTo(a[i]) > 0) min = a[i];
         if (max.compareTo(a[i]) < 0) max = a[i];
      }
      return  new Pair<>(min, max);
   }
}

pairtest

pairtest