建议：优先考虑泛型。

心已赠人 2024-02-18 16:34 54阅读 0赞

一般来说，将集合声明参数化，以及使用JDK所提供的泛型和泛型方法，这些都不太困难。编写自己的泛型会比较困难一些，但是值得花些时间去学习如何编写。

考虑下面这个简单的堆栈实现：

// Object-based collection - a prime candidate for generics
    
    public class Stack {
    
        private Object[] elements;
    
        private int size = 0;
    
        private static final int DEFAULT_INITIAL_CAPACITY = 16;
    
        public Stack() {
    
            elements = new Object[DEFAULT_INITIAL_CAPACITY];
    
        }
    
        public void push(Object e) {
    
            ensureCapacity();
    
            elements[size++] = e;
    
        }
    
        public Object pop() {
    
            if (size == 0) throw new EmptyStackException();
    
            Object result = element[-- size];
    
            elements[size] = null; // Eliminate obsolete reference
    
            return result;
    
        }
    
        public boolean isEmpty() {
    
            return size == 0;
    
        }
    
        private void ensureCapacity() {
    
            if (elements.length == size ) elements = Arrays.copyOf(elements , 2 * size + 1);
    
        }
    
    }

这个类是泛型化（generification）的主要备选对象，换句话说，可以适当的强化这个类来利用泛型。根据实际情况来看，必须转换从堆栈里弹出的对象，以及可能在运行时失败的那些转换。将类泛型话的第一个步骤是给他的声明添加一个或者多个类型参数。在这个例子中有一个类型参数，他表示堆栈的元素类型，这个参数的名称通常为E。

下一步是用相应的类型参数替代所有的Object类型，然后试着编译最终的程序：

// Initial attempt to generify Stack = won't compile!
    
    
    public class Stack<E> {
    
        private E[] elements;
    
        private int size = 0;
    
        private static final int DEFAULT_INITIAL_CAPACITY = 16;
    
        public Stack() {
    
            elements = new E[DEFAULT_INITIAL_CAPACITY];
    
        }
    
        public void push(E e) {
    
            ensureCapacity();
    
            elements[size++] = e;
    
        }
    
        public E pop() {
    
            if (size == 0) throw new EmptyStackException();
    
            E result = element[-- size];
    
            elements[size] = null; // Eliminate obsolete reference
    
            return result;
    
        }
    
        public boolean isEmpty() {
    
            return size == 0;
    
        }
    
        private void ensureCapacity() {
    
            if (elements.length == size ) elements = Arrays.copyOf(elements , 2 * size + 1);
    
        }
    
    }

通常，你将至少得到一个错误或警告，这个类也不例外。幸运的是，这个类只产生一个错误，如下：

*Stack.java:8:generic array creation elements = new E\[DEFAULT\_INITIAL\_CAPACITY\];*

我们不能创建不可具体化的（non-reifiable）类型的数组，如E。每当编写用数组支持的泛型时，都会出现这个问题。解决这个问题有两种办法。**第一种，直接绕过创建泛型数组的禁令：创建一个Object的数组，并将他转换成泛型数组类型。**现在错误是消除了，但是编译器会产生一条警告。这种用法是合法的，但（整体而言）不是类型安全的：

*Stack.java:8：warning：\[unchecked\] unchecked cast*

*found ：Object\[\]，required：E\[\] elements = (E\[\]) new Object\[DEFAULT\_INITIAL\_CAPACITY\];*

编译器不可能证明你的程序是类型安全的，但是你可以证明。你自己必须确保未受检的转换不会危及到程序的类型安全性。相关的数组（即elements变量）保存在一个私有的域中，永远不会被返回到客户端，或者传给任何其他方法。这个数组中保存的唯一元素，是传给push方法的那些元素，他们的类型为E，因此未受检的转换不会有任何危害。

一旦你证明了未受检的转换是安全的，就要在尽可能小的范围中禁止警告。在这种情况下构造器只包含未受检的数组创建，因此可以在整个构造器中禁止这条警告。通过增加一条注解来完成禁止，Stack能够正确无误的进行编译，你就可以使用他了，无需显示的转换，也无须担心会出现ClassCastException异常：

// The elements array will contain only E instances from push(E),
    
    // This is sufficient to ensure type safety，but the runtime
    
    // type of the array won't be E[]; it will always be Object[]!
    
    @SuppressWarning("unchecked")
    
    public Static() {
    
            elements = (E[])new Object[DEFAULT_INITIAL_CAPACITY];
    
    }

**消除Stack中泛型数组创建错误的第二种方法是，将elements域的类型从E\[\]改为Object\[\]，**这么做会得到一条不同的的错误：

*Stack.java:19: incompatible types：*

*found ：Object，required：E result = elements\[--size\];*

通过把从数组中获取到的元素由Object转换成E，可以将这条错误变成一条警告：

*Stack.java:19: warning: \[unchecked\] unchecked cast*

*found ：Object，required：E result = (E) elements\[--size\];*

由于E是一个不可具体化（non-reifiable）类型，编译器无法在运行时检验转换。你还是可以自己证实未受检的转换是安全的，因此可以禁止该警告。我们只要在包含未受检转换的任务上禁止警告，而不是在整个pop方法上就可以了，如下：

// Appropriate suppression of unchecked warning
    
    
    public E pop() {
    
        if (size == 0) throw new EmptyStackException();
    
        // push required elements to be of type E，so cast is correct
    
        @SuppressWarning("unchecked")
    
        E result = (E) element[-- size];
    
        elements[size] = null; // Eliminate obsolete reference
    
        return result;
    
    }

**具体选择这两种方法中的哪一种来处理泛型数组创建错误，则主要看个人偏好了。所有其他的东西都一样，但是禁止数组类型的未受检转换比禁止标量类型（scalar type）的更加危险，所以建议采用第二种方案。但是在比Stack更实际的泛型类中，或许代码汇总会有多个地方需要从数组中读取，因此选择第二种方案需要多次转换成E，而不是只转换成E\[\]，这也是第一种方案之所以更常用的原因。**

下面的程序示范了泛型Stack类的使用。程序以相反的顺序打印出他的命令行参数，并转换成大写字母。如果要在从堆栈中弹出的元素上调用String的toUpperCase方法，并不需要显示的转换，并且会确保自动生成的转换会成功：

// Little program to exercise our generic Stack
    
    public Static void main(String[] args) {
    
        Stack<String> stack = new Stack<String>();
    
        for (String arg : args) stack.push(arg);
    
        while (!stack.isEmpty())  System.out.println(stack.pop().toUpperCase());
    
    
    }

实际上并不可宗师或者总想在泛型中使用列表。Java并不是生来就支持列表，因此有些泛型如ArrayList，必须在数组上实现。为了提升性能，其他泛型如HashMap也在数组上实现。

绝大多数泛型就像我们的Stack示例一样，因为他们的类型参数没有限制：你可以创建Stack<Object>、Stack<int\[\]>、Stack<List<String>>，或者任何其他对象引用类型的Stack。注意不能创建基本类型的Stack：企图创建Stack<int>或者Stack<double>会产生一个编译时错误。这是Java泛型系统根本的局限性。你可以通过使用基本包装类型（boxed primitive type）来避开这条限制。

有一些泛型限制了可允许的类型参数值。例如，考虑java.util.concurrent.DelayQueue，其声明如下：

class DelaQueue<E extends Delayed> implements BlockingQueue<E>;

类型参数列表(<E extends Delayed>) 要求实际的类型参数E必须是java.util.concurrent.Delayed的一个子类型。他允许DelayQueue实现及其客户端在DelayQueue的元素上利用Delayed方法，无需显示的转换，也没有出现ClassCastException的封信啊。类型参数E被称做有限制的类型参数（bounded type parameter）。注意，子类型关系确定了，每个类型都是他自身的子类型，因此创建DelayQueue<Delayed>是合法的。

总而言之，使用泛型比使用需要在客户端代码中进行转换的类型来的更加安全，也更加容易。在设计新类型的时候，要确保他们不需要这种转换就可以使用。这通常意味着要把类做成反省的。只要时间允许，就把现有的类型都泛型化。这对于这些类型的新用户来说会变得更加轻松，又不会破坏现有的客户端。