八、泛型程序设计

爱被打了一巴掌 2022-03-17 09:23 238阅读 0赞

# **一、为什么使用泛型设计** #

** **使用泛型机制编写的程序代码要比那些杂乱地使用 Object 变量，然后再进行强制类型转换的代码具有更好的安全性和可读性。

在 Java 中增加范型类之前， 泛型程序设计是用继承实现的。ArrayList 类只维护一个 Object 引用的数组：

这种方法有两个问题。当获取一个值时必须进行强制类型转换；此外，这里没有错误检査。可以向数组列表中添加任何类的对象。

泛型提供了一个更好的解决方案： 类型参数（type parameters)。ArrayList 类有一个类型 参数用来指示元素的类型。

类型参数的魅力在于：使得程序具有更好的可读性和安全性。

下面是标准类库的设计者们肯定产生争议的一个典型问 题。AirayList 类有一个方法 addAll 用来添加另一个集合的全部元素。 程序员可能想要将 ArrayList<Manager> 中的所有元素添加到 ArrayList<Employee> 中去。然而， 反过来就不行了。如果只能允许前一个调用， 而不能允许后一个调用呢？ Java语言的设计者发明了一个具 有独创性的新概念，通配符类型（wildcard type), 它解决了这个问题。通配符类型非常抽象， 然而，它们能让库的构建者编写出尽可能灵活的方法。

# 二、定义简单泛型类 #

一个泛型类（ generic class) 就是具有一个或多个类型变量的类。

Pair 类引人了一个类型变量 T，用尖括号 ( < >) 括起来，并放在类名的后面。泛型类可 以有多个类型变量。例如， 可以定义 Pair 类，其中第一个域和第二个域使用不同的类型：

public class Pair<T,U>{...}

类定义中的类型变量指定方法的返回类型以及域和局部变量的类型.换句话说，泛型类可看作普通类的工厂。

package pair1;
    
    /**
     * @version 1.00 2004-05-10
     * @author Cay Horstmann
     */
    public class Pair<T> 
    {
       private T first;
       private T second;
    
       public Pair() { first = null; second = null; }
       public Pair(T first, T second) { this.first = first;  this.second = second; }
    
       public T getFirst() { return first; }
       public T getSecond() { return second; }
    
       public void setFirst(T newValue) { first = newValue; }
       public void setSecond(T newValue) { second = newValue; }
    }
    
    public class PairTest1
    {
       public static void main(String[] args)
       {
          String[] words = { "Mary", "had", "a", "little", "lamb" };
          Pair<String> mm = ArrayAlg.minmax(words);
          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;
          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);
       }
    }

# 三、泛型方法 #

实际上，还可以定义一个带有类型参数的简单方法。

public static <T> T get(T...a){}

注意，类型变量放在修饰符（这里是 public static) 的后面，返回类型的前面。 泛型方法可以定义在普通类中，也可以定义在泛型类中。 当调用一个泛型方法时 ’ 在方法名前的尖括号中放人具体的类型：

String middle = ArrayAlg.<String>get("JohnM, "Q")

在这种情况（实际也是大多数情况）下，方法调用中可以省略类型参数。编译 器有足够的信息能够推断出所调用的方法。它用 names 的类型（即 String\[ \]) 与泛型类型 T\[ \] 进行匹配并推断出 T 一定是 String。

几乎在大多数情况下，对于泛型方法的类型引用没有问题。偶尔，编译器也会提示错 误， 此时需要解译错误报告。看一看下面这个示例：

double middle = ArrayAlg.getMiddle(B.14, 1729, 0);

错误消息会以晦涩的方式指出（不同的编译器给出的错误消息可能有所不同）： 解释这句 代码有两种方法，而且这两种方法都是合法的。简单地说， 编译器将会自动打包参数为 1 个 Double 和 2 个 Integer 对象，而后寻找这些类的共同超类型。事实上；找到 2 个这样的超类 型：Number 和 Comparable 接口，其本身也是一个泛型类型。在这种情况下，可以采取的补救措施是将所有的参数写为 double 值。其本身也是一个泛型类型。在这种情况下，可以采取的补救措施是将所有的参数写为 double 值。

如果想知道编译器对一个泛型方法调用最终推断出哪种类型， PetervonderAM 推 荐了这样一个窍门： 有目的地引入一个错误， 并研究所产生的错误消息。例如， 看一下 调用 ArrayAlg.getMiddle(“ Hello”， 0 ， null)。将结果赋给 JButton， 这不可能正确。将会得 到一个措误报告：

found:

java.1ang.0bject&java.io.Seriallzable&java.lang.Comparable<? extends

java.lang.0bject&java.io.Serializable&java.lang.Comparable<?>>

大致的意思是： 可以将结果賦给 Object、Serialiable 或 Comparable

# 四、类型变量的限定 #

class ArrayAIg
    {
    public static <T> T min(T[] a) // almost correct
    {
    if (a==null || a.length ==0) return null ;
    T smallest = a[0];
    for (int i = 1; i < a.length; i ++)
    if (smallest.compareTo(a[i]) > 0) smallest = a[i];
    return smallest;
    }
    }

但是，这里有一个问题。请看一下 min方法的代码内部。 变量 smallest 类型为 T, 这意 味着它可以是任何一个类的对象。怎么才能确信 T 所属的类有 compareTo 方法呢？ 解决这个问题的方案是将 T 限制为实现了 Comparable 接口（只含一个方法 compareTo 的 标准接口）的类。可以通过对类型变量 T 设置限定（bound) 实现这一点：

public static <T extends Comparable> T min(T[] a);

表示 T 应该是绑定类型的子类型 （subtype)。 T 和绑定类型可以是类， 也可以是接口

一个类型变量或通配符可以有多个限定， 例如： T extends Comparable & Serializable 限定类型用“ &” 分隔，而逗号用来分隔类型变量。 在 Java 的继承中， 可以根据需要拥有多个接口超类型， 但限定中至多有一个类。如果用 一个类作为限定，它必须是限定列表中的第一个。

package pair2;
    
    import java.time.*;
    
    /**
     * @version 1.02 2015-06-21
     * @author Cay Horstmann
     */
    public class PairTest2
    {
       public static void main(String[] args)
       {
          LocalDate[] birthdays = 
             { 
                LocalDate.of(1906, 12, 9), // G. Hopper
                LocalDate.of(1815, 12, 10), // A. Lovelace
                LocalDate.of(1903, 12, 3), // J. von Neumann
                LocalDate.of(1910, 6, 22), // K. Zuse
             };
          Pair<LocalDate> mm = ArrayAlg.minmax(birthdays);
          System.out.println("min = " + mm.getFirst());
          System.out.println("max = " + mm.getSecond());
       }
    }
    
    class ArrayAlg
    {
       /**
          Gets the minimum and maximum of an array of objects of type T.
          @param a an array of objects of type T
          @return a pair with the min and max value, or null if a is 
          null or empty
       */
       public static <T extends Comparable> Pair<T> minmax(T[] a) 
       {
          if (a == null || a.length == 0) return null;
          T min = a[0];
          T 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);
       }
    }

# 五、泛型代码与虚拟机 #

虚拟机没有泛型类型对象—所有对象都属于普通类。

[https://blog.csdn.net/mccand1234/article/details/52013918][https_blog.csdn.net_mccand1234_article_details_52013918]Java代码编译和执行过程。

### 5.1 类型擦除 ###

无论何时定义一个泛型类型， 都自动提供了一个相应的原始类型 （ raw type )。原始类型 的名字就是删去类型参数后的泛型类型名。擦除（ erased) 类型变M, 并替换为限定类型（无限定的变量用 Object。)

在程序中可以包含不N类型的 Pair, 例 如， Pair 或 Pair 。 而擦除类 型后就变成原始的 Pair 类型了。

原始类型用第一个限定的类型变量来替换， 如果没有给定限定就用 Object 替换。

读者可能想要知道切换限定： class Interval<T extends Serializable & Comparable> 会发生什么。如果这样做， 原始类型用 Serializable 替换 T, 而编译器在必要时要向 Comparable 插入强制类型转换。为了提高效率，应该将标签（tagging) 接口（即没有方 法的接口）放在边界列表的末尾。

### 5.2 翻译泛型表达式 ###

当程序调用泛型方法时，如果擦除返回类型， 编译器插入强制类型转换。

Pair<Employee> buddies = . .
    Employee buddy = buddies.getFirstO；

擦除 getFirst 的返回类型后将返回 Object 类型。编译器自动插人 Employee 的强制类型转换。 也就是说，编译器把这个方法调用翻译为两条虚拟机指令：

•对原始方法 Pair.getFirst 的调用。

•将返回的 Object 类型强制转换为 Employee 类型。

当存取一个泛型域时也要插人强制类型转换。假设 Pair 类的 first 域和 second 域都是公 有的（也许这不是一种好的编程风格，但在 Java 中是合法的)。表达式： Employee buddy = buddies.first;也会在结果字节码中插人强制类型转换。

### 5.3 翻译泛型方法 ###

方法的擦除带来了两个复杂问题。看一看下面这个示例：

class Datelnterval extends Pair<LocalDate> {
                public void setSecond(LocalDate second) {
                    if (second.compareTo(getFirst()) >= 0)
                       super.setSecond(second);
                }
            }

一个日期区间是一对 LocalDate 对象， 并且需要覆盖这个方法来确保第二个值永远不小 于第一个值。这个类擦除后变成：

class Datelnterval extends Pair {
                public void setSecond(LocalDate second) {
                    if (second.compareTo(getFirst()) >= 0)
                       super.setSecond(second);
                }
            }

令人感到奇怪的是，存在另一个从Pair继承的 setSecond方法，即：

public void setSecond(Object second)

这显然是一个不同的方法，因为它有一个不同类型的参数 Object, 而不是LocalDate。 然而，不应该不一样。考虑下面的语句序列：

Datelnterval interval = new Datelnterval(...); 
    Pair<LocalDate> pair =interval; // OK assignment to superclass 
    pair.setSecond(aDate);

这里， 希望对 setSecond 的调用具有多态性， 并调用最合适的那个方法。由于 pair引用 Datelnterval 对象，所以应该调用 Datelnterval.setSecond。问题在于类型擦除与多态发生了冲 突。要解决这个问题， 就需要编译器在 Datelnterval 类中生成一个桥方法（bridge method):

public void setSecond(Object second) { setSecond((Date) second); J

public class A<T>{
        public T get(T a){
            //a进行一些操作
            return a;
        }
    }
    public class B extends A<String>{
        @override
        public String get(String a){
            //a进行一些操作
            return a;
        }
    }

擦除后：

public class A{
        public Object get(Object a){
            //a进行一些操作
            return a;
        }
    }
    public class B extends A{
        @override
        public String get(String a){
            //a进行一些操作
            return a;
        }
    }

@override意味着B对父类A中的get方法进行了重写，但是依上面的程序来看，只是重载，依然可以执行父类的方法，这和期望是不附的，也不符合java继承、多态的特性。

注:子类重写父类方法，只要此实例的实际类型是子类类型了（不是引用类型），便不能调用父类的方法，这是语言的多态特性。

为了解决这个问题，java在编译期间加入了桥接方法。编译后再翻译为java原文件，应如下所示：

public class A{
        public Object get(Object a){
            //a进行一些操作
            return a;
        }
    }
    public class B extends A{
        @override
        public String get(String a){
            //a进行一些操作
            return a;
        }
        public Object get(Object a){
            return get((String)a)
        }
    }

总之，需要记住有关 Java 泛型转换的事实：

•虚拟机中没有泛型，只有普通的类和方法。

•所有的类型参数都用它们的限定类型替换。

•桥方法被合成来保持多态。

•为保持类型安全性，必要时插人强制类型转换。

### 5.4 调用遗留代码 ###

**【1】调用遗留代码相关**

**1.1）设计java 泛型的目的：** 允许泛型代码和遗留代码间能够相互操作；   
**1.2）看个荔枝：**要想设置一个 JSlider 标签， 使用 void setLabelTable(Dictionary table)，

*  **1.2.1）**在这里， Dictionary是一个原始类型， 因为实现JSlider 类时Java中还不存在泛型。不过填充字典时， 要使用泛型类型。

Dictionary<Integer, Component> labelTable = new Hashtable<>();
    labelTable.put(0, new JLable(new ImageIcon("nine.gif")));

*   
 *  **1.2.2）将 Dictionary《Interger, Component》对象传递给 setLabelTable 时， 编译器会发出一个警告；**

slider.setLable(labelTable); // Warnning

*  因为， 编译器无法确定setLabelTable 可能会对Dictionary对象做什么操作；这个警告对操作并不会产生什么影响， 最多考虑一下 JSlider 有可能用 Dictionary对象做什么就可以了；

**1.3）再看个荔枝：**（由一个遗留的类得到一个原始类型的对象）。可以将它赋给一个参数化的类型变量， 这样做会产生一个警告；

*  **1.3.1）如：**

Dictionary <Integer, Components> labelTable = slider.getLabelTable(); // Warning

*  **1.3.2）**这种情况并不会比 有泛型之前的case 更糟糕，最差的case 是程序抛出一个异常；
 *  **1.3.3）**在查看了警告之后， 可以利用注释 使之消失。注释必须放在生成这个警告的代码所在的方法之前， 如下：

@SuppressWarnings("unchecked")
    Dictionary<Integer, Components> labelTable = slider.getLabelTable(); // no warning

*   
 *  **或者， 可以标注整个方法， 如：**

@SuppressWarnings("unchecked")
    public void configureSlider(){......}

*  这个标注会关闭对方法中所有代码的检查；

# 六、约束与局限性 #

### 6.1 不能用基本类型实例化类型参数 ###

不能用类型参数代替基本类型。因此， 没有 Pair<double>, 只 有 Pair<Double> 。 当然, 其原因是类型擦除。擦除之后， Pair 类含有 Object 类型的域， 而 Object 不能存储 double。会报错

### 6.2 运行时类型查询只适用于原始类型 ###

虚拟机中的对象总有一个特定的非泛型类型。因此，所有的类型查询只产生原始类型。为提醒这一风险， 试图查询一个对象是否属于某个泛型类型时，倘若使用 **instanceof** 会得到一个编译器错误， 如果使用强制类型转换会得到一个警告。同样的道理， getClass方法总是返回原始类型。例如：

Pair<String> stringPair = . .
    Pair<Employee〉employeePair = . .
    if (stringPair.getClas（） == employeePair.getClass（）) // they are equal

其比较的结果是 true, 这是因为两次调用 getClass 都将返回 Pair.class。

### 6.3 不能创建参数化类型的数组 ###

不能实例化参数化类型的数组， 例如：

Pair<String>[] table = new Pair<String>[10]; // Error

这有什么问题呢？ 擦除之后， table 的类型是 Pair\[\]。可以把它转换为 Object\[\]:

Object[] objarray = table;

objarray\[0\] = new Pair<Employee>()；能够通过数组存储检査， 不过仍会导致一个类型错误。出于这个原因， 不允许创建参数 化类型的数组。

需要说明的是， 只是不允许创建这些数组， 而声明类型为 Pair\[\] 的变量仍是合法 的。不过不能用 new Pair\[10\] 初始化这个变量。

如果需要收集参数化类型对象， 只有一种安全而有效的方法：使用 ArrayList:ArrayList<Pair<String>>？？？？

### 6.4 Varargs 警告 ###

public static <T> void addAll(Collections coll, T... ts)
    {
    for (t : ts) coll.add⑴；
    }

为了调用这个方法，Java 虚拟机必须建立一个 Pair 数组， 这就违反了前面的规 则。不过，对于这种情况， 规则有所放松，你只会得到一个警告，而不是错误。 可以采用两种方法来抑制这个警告。一种方法是为包含 addAll 调用的方法增加注解 @ **SuppressWamings**("unchecked"。) 或者在 Java SE 7中， 还 可 以 用@**SafeVarargs** 直 接 标 注 addAll 方法

### 6.5 不能实例化类型变置 ###

不能使用像 new T(...，) newT\[...\] 或 T.class 这样的表达式中的类型变量。比较传统的解决方法是通过反射调用 Clasmewlnstance 方法来构造泛型对象。在 Java SE 8之后， 最好的解决办法是让调用者提供一个构造器表达式。例如：

Pair<String> p = Pair.makePair(String::new);

makePair方法接收一个 Supplier<T>，这是一个函数式接口，表示一个无参数而且返回 类型为 T 的函数：

public static <T> Pair<T> makePair(Supplier<T> constr) 
    { return new Pair<>(constr.get().constr.get())；}

比较传统的解决方法是通过反射调用 Clasmewlnstance 方法来构造泛型对象:

public static <T> Pair<T> makePair(Class<T> cl)
    {
    try { return new Pair(d.newInstance（）. cl.newInstance（）；) }
    catch (Exception ex) { return null; }
    }
    这个方法可以按照下列方式调用：
    Pair<String> p = Pair.makePair(String.class);

注意，Class类本身是泛型。 例如，String.class 是一个 Class<String> 的实例（事实上， 它是唯一的实例)。

### 6.6 不能构造泛型数组 ###

就像不能实例化一个泛型实例一样， 也不能实例化数组。

利用lamda表达式:

String口 ss = ArrayAlg.minmax(String[]:new,"Tom","Dick");
    public static <T extends Comparable〉T[] minmax(IntFunction<T[]> constr, T... a) 
    { T[] mm = constr.apply(2); }

利用反射可以实现：

package Test;
    
    import java.lang.reflect.Array;
    
    /**
     * 
     * @author QuinnNorris
     * 在泛型方法中创建泛型类型的数组
     */
    public class Test {
        public static void main(String[] args) {
            // TODO Auto-generated method stub
    
            String a = "ccc";//创建一个String，作为泛型类型
            String[] ar = creArray(a);
            for(String art :ar)//循环打印
                System.out.println(art);
        }
    
        //泛型静态方法
        public static <T> T[]  creArray (T obj){
            T[] arr = (T[])Array.newInstance(obj.getClass(), 5);
            arr[1] = obj;
            System.out.println(arr[1]);
            return arr;
        }
    }

上述的方法是完全可行的，我们通过用Array类的newInstance方法来构造了可指定类型的数组。使用反射来完成这个工作也应该是在情理之中。因为泛型类型T在中运行时才可能被确定下来，我们能创建泛型数组也必然是在java运行时想办法，在java运行时能起作用的技术莫过于反射。

### 6.7 泛型类的静态上下文中类型变量无效 ###

不能在静态域或方法中引用类型变量。例如， 下列高招将无法施展：

public class Singleton<T> {
            private static T singlelnstance; // Error
    
            public static T getSinglelnstance() // Error
            {
                if (singleinstance == null)
                   //construct new instance
                   return singlelnstance;
            }
        }

因此， 禁止使用带有类型变量 的静态域和方法。如果这个程序能够运行， 就可以声明一个 Singleton<Random> 共享随机数生成器， 声明 一个 Singlet0n<JFileChooSer> 共享文件选择器对话框。但是， 这个程序无法工作。类型擦除 之后， 只剩下 Singleton类，它只包含一个 singlelnstance 域。 因此， 禁止使用带有类型变量 的静态域和方法。

### 6.8 不能抛出或捕获泛型类的实例 ###

既不能抛出也不能捕获泛型类对象。实际上， 甚至泛型类扩展 Throwable 都是不合法的。

catch 子句中不能使用类型变量：

public static <T extends Throwable〉void doWork(Class<T> t)
    {
    try
    {
    do work
    }
    catch (T e) // Error can 't catch type variable
    {
    Logger,global.info(...)
    }
    }

不过， 在异常规范中使用类型变量是允许的。以下方法是合法的：

public static <T extends Throwable〉void doWork(T t) throws T // OK
    try
    {
    do work
    }
    catch (Throwable real Cause)
    {
    t.initCause(real Cause);
    throw t;
    }
    }

### 6.9 可以消除对受查异常的检查 ###

Java 异常处理的一个基本原则是， 必须为所有受查异常提供一个处理器。不过可以利用 泛型消除这个限制。关键在于以下方法：

@SuppressWamings("unchecked")
    public static <T extends Throwable〉void throwAs(Throwable e) throws T
    {
    throw （t) e;
    }

以下代码会把所有异常都转换为编译器所认为的 非受查异常：

try { do work } catch (Throwable t) { B1ock.<RuntimeException>throwAs(t) ; }

这有什么意义呢？ 正常情况下， 你必须捕获线程 run 方法中的所有受查异常， 把它们 “ 包装” 到非受查异常中， 因为 run 方法声明为不抛出任何受查异常。 不过在这里并没有做这种“ 包装”。我们只是抛出异常， 并“ 哄骗” 编译器， 让它认为 这不是一个受查异常。 通过使用泛型类、 擦除和 @SuppressWamings 注解， 就能消除 Java 类型系统的部分基本 限制。

### 6.10 注意擦除后的冲突 ###

*  假定像下面这样将 equals 方法添加到 Pair 类中：

public class Pair \{ public boolean equals(T value) \{ return first,equals(value) && second,equals(value); \}

考虑一个 Pair。从概念上讲， 它有两个 equals 方法:

boolean equals(String) // defined in Pair

boolean equals(Object) // inherited from Object 但是，直觉把我们引入歧途。

方法擦除 boolean equals(T) 就是 boolean equals(Object) 与 Object.equals 方法发生冲突。

当然，补救的办法是重新命名引发错误的方法。

*  泛型规范说明还提到另外一个原则：“ 要想支持擦除的转换， 就需要强行限制一个类或类 型变量不能同时成为两个接口类型的子类，而这两个接口是同一接口的不同参数化。” 例如， 下述代码是非法的：

class Employee implements Comparab1e<Employee> { . . . }
    class Manager extends Employee implements Comparable<Hanager>
    { . . . } // Error

其原因非常微妙， 有可能与合成的桥方法产生冲突。实现了 C0mpamble 的类可以获得一 个桥方法：

public int compareTo(Object other) \{ return compareTo((X) other); \}

对于不同类型的 X 不能有两个这样的方法。

# 七、泛型类型的继承规则 #

考虑一个类和一个子类， 如 Employee 和 Manager。Pair 是 PaiKEmployee> 的一个子类吗？ 答案是“ 不是”

无论 S 与 T 有什么联系 。通常， Pair<T> 与 Pair<S>没有什么联系。

最后， 泛型类可以扩展或实现其他的泛型类。就这一点而言，与普通的类没有什么 区别。例如， ArrayList<T> 类实现 List<T> 接口。这意味着， 一个 ArrayList<Manager> 可 以被转换为一个 List<Manager>。但是， 如前面所见， 一个 ArrayList<Manager> 不是一个 ArrayList<Emplyee> 或 List<Emplyee>.

# 八、通配符类型 #

通配符类型中， 允许类型参数变化。 例如， 通配符类型：

Pair<? extends Employee〉

表示任何泛型 Pair 类型， 它的类型参数是 Employee 的子类， 如 Pair<Manager>， 但不是 Pair<String>。

### 通配符的超类型限定 ###

通配符限定与类型变量限定十分类似，但是，还有一个附加的能力，即可以指定一个超 类型限定 （supertypebound), 如下所亦：

? super Manager

带有超类型限定的通配符可以向泛型对象写人，带有子类型限定的通配符可 以从泛型对象读取。带有extends的相反。

还可以使用无限定的通配符， 例如，Pair<?> 。初看起来，这好像与原始的 Pair 类型一样。 实际上， 有很大的不同。类型 Pair 有以下方法： ? getFi rst() void setFirst(?). getFirst 的返回值只能赋给一个 Object。setFirst 方法不能被调用， 甚至不能用 Object 调 用。Pair 和 Pair 本质的不同在于： 可以用任意 Object 对象调用原始 Pair 类的 setObject 方法。 0 注释： 可以调用 setFirst(null)。

### 通配符捕获 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70][]

package pair3;
    
    /**
     * @version 1.01 2012-01-26
     * @author Cay Horstmann
     */
    public class PairTest3
    {
       public static void main(String[] args)
       {
          Manager ceo = new Manager("Gus Greedy", 800000, 2003, 12, 15);
          Manager cfo = new Manager("Sid Sneaky", 600000, 2003, 12, 15);
          Pair<Manager> buddies = new Pair<>(ceo, cfo);      
          printBuddies(buddies);
    
          ceo.setBonus(1000000);
          cfo.setBonus(500000);
          Manager[] managers = { ceo, cfo };
    
          Pair<Employee> result = new Pair<>();
          minmaxBonus(managers, result);
          System.out.println("first: " + result.getFirst().getName() 
             + ", second: " + result.getSecond().getName());
          maxminBonus(managers, result);
          System.out.println("first: " + result.getFirst().getName() 
             + ", second: " + result.getSecond().getName());
       }
    
       public static void printBuddies(Pair<? extends Employee> p)
       {
          Employee first = p.getFirst();
          Employee second = p.getSecond();
          System.out.println(first.getName() + " and " + second.getName() + " are buddies.");
       }
    
       public static void minmaxBonus(Manager[] a, Pair<? super Manager> result)
       {
          if (a.length == 0) return;
          Manager min = a[0];
          Manager max = a[0];
          for (int i = 1; i < a.length; i++)
          {
             if (min.getBonus() > a[i].getBonus()) min = a[i];
             if (max.getBonus() < a[i].getBonus()) max = a[i];
          }
          result.setFirst(min);
          result.setSecond(max);
       }
    
       public static void maxminBonus(Manager[] a, Pair<? super Manager> result)
       {
          minmaxBonus(a, result);
          PairAlg.swapHelper(result); // OK--swapHelper captures wildcard type
       }
       // Can't write public static <T super manager> ...
    }
    
    class PairAlg
    {
       public static boolean hasNulls(Pair<?> p)
       {
          return p.getFirst() == null || p.getSecond() == null;
       }
    
       public static void swap(Pair<?> p) { swapHelper(p); }
    
       public static <T> void swapHelper(Pair<T> p)
       {
          T t = p.getFirst();
          p.setFirst(p.getSecond());
          p.setSecond(t);
       }
    }

# 九、反射与泛型 #

反射允许你在运行时分析任意的对象。如果对象是泛型类的实例，关于泛型类型参数则 得不到太多信息，因为它们会被擦除。在下面的小节中，可以了解利用反射可以获得泛型类 的什么信息。

### 泛型 Class 类 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 2][]

package genericReflection;
    
    import java.lang.reflect.*;
    import java.util.*;
    
    /**
     * @version 1.10 2007-05-15
     * @author Cay Horstmann
     */
    public class GenericReflectionTest
    {
       public static void main(String[] args)
       {
          // read class name from command line args or user input
          String name;
          if (args.length > 0) name = args[0];
          else
          {
             try (Scanner in = new Scanner(System.in))
             {
                System.out.println("Enter class name (e.g. java.util.Collections): ");
                name = in.next();
             }
          }
    
          try
          {
             // print generic info for class and public methods
             Class<?> cl = Class.forName(name);
             printClass(cl);
             for (Method m : cl.getDeclaredMethods())
                printMethod(m);
          }
          catch (ClassNotFoundException e)
          {
             e.printStackTrace();
          }
       }
    
       public static void printClass(Class<?> cl)
       {
          System.out.print(cl);
          printTypes(cl.getTypeParameters(), "<", ", ", ">", true);
          Type sc = cl.getGenericSuperclass();
          if (sc != null)
          {
             System.out.print(" extends ");
             printType(sc, false);
          }
          printTypes(cl.getGenericInterfaces(), " implements ", ", ", "", false);
          System.out.println();
       }
    
       public static void printMethod(Method m)
       {
          String name = m.getName();
          System.out.print(Modifier.toString(m.getModifiers()));
          System.out.print(" ");
          printTypes(m.getTypeParameters(), "<", ", ", "> ", true);
    
          printType(m.getGenericReturnType(), false);
          System.out.print(" ");
          System.out.print(name);
          System.out.print("(");
          printTypes(m.getGenericParameterTypes(), "", ", ", "", false);
          System.out.println(")");
       }
    
       public static void printTypes(Type[] types, String pre, String sep, String suf, 
             boolean isDefinition)
       {
          if (pre.equals(" extends ") && Arrays.equals(types, new Type[] { Object.class })) return;
          if (types.length > 0) System.out.print(pre);
          for (int i = 0; i < types.length; i++)
          {
             if (i > 0) System.out.print(sep);
             printType(types[i], isDefinition);
          }
          if (types.length > 0) System.out.print(suf);
       }
    
       public static void printType(Type type, boolean isDefinition)
       {
          if (type instanceof Class)
          {
             Class<?> t = (Class<?>) type;
             System.out.print(t.getName());
          }
          else if (type instanceof TypeVariable)
          {
             TypeVariable<?> t = (TypeVariable<?>) type;
             System.out.print(t.getName());
             if (isDefinition)
                printTypes(t.getBounds(), " extends ", " & ", "", false);
          }
          else if (type instanceof WildcardType)
          {
             WildcardType t = (WildcardType) type;
             System.out.print("?");
             printTypes(t.getUpperBounds(), " extends ", " & ", "", false);
             printTypes(t.getLowerBounds(), " super ", " & ", "", false);
          }
          else if (type instanceof ParameterizedType)
          {
             ParameterizedType t = (ParameterizedType) type;
             Type owner = t.getOwnerType();
             if (owner != null)
             {
                printType(owner, false);
                System.out.print(".");
             }
             printType(t.getRawType(), false);
             printTypes(t.getActualTypeArguments(), "<", ", ", ">", false);
          }
          else if (type instanceof GenericArrayType)
          {
             GenericArrayType t = (GenericArrayType) type;
             System.out.print("");
             printType(t.getGenericComponentType(), isDefinition);
             System.out.print("[]");
          }
       }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 3][]

![20190223182034285.png][]

[https_blog.csdn.net_mccand1234_article_details_52013918]: https://blog.csdn.net/mccand1234/article/details/52013918
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70]: /images/20220317/70efb253745942fca042fd0ab9ee2800.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 1]: /images/20220317/0409c9cf19c446a7ae5899ddea54a00a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 2]: /images/20220317/d5c33efd9ff847759485d7d3d2750f5f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 3]: /images/20220317/af8480d1e0a24548902d3fa6a3ccee10.png
[20190223182034285.png]: /images/20220317/e476455b386c471fb25f33fa77d62365.png