新特性总结-JDK1.5

说明

• 2004，一个里程碑
• API的修改
• 语法的修改

泛型（Generics）

　　泛型是JDK1.5中一个最“酷”的特征。通过引入泛型，我们将获得编译时类型的安全和运行时更小地抛出 ClassCastExceptions的可能。在JDK1.5中，你可以声明一个集合将接收/返回的对象的类型。在JDK1.4中，创建雇员名字的清单 （List）需要一个集合对象，像下面的语句：

List listOfEmployeeName = new ArrayList(); 

　　在JDK1.5中，你将使用下面　　

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

　　“酷”的是，如果你试图插入非string类型的值，你将在编译时发现并且修正这类问题。没有泛型，你会发现这样一个bug，当你的客户调用后会告诉你，你所编写的程序抛出ClassCastException异常而崩溃。
　　另外，当你从集合中得到一个元素时你无需进行强制转换。故原先为：

String employeeName = ((String) listOfEmployee.get(i)); 

　　而下面的语句将比上面的更加简单：

String employeeName = listOfEmployee.get(i); 

　　不清楚对象的类型而强制转换对象是不合理的，并且更重要的是，它将在运行时失败。假使用户无意间传入一个包含string buffers类型而非string类型的集合，那结果会怎样呢。在Listing A中，客户被要求传入一个编译器无法强制的strings类型集合。Listing B中显示了同样的方法使用泛型是如何实现的。

// Listing Aprivate boolean staticbooleancheckName(Collection employeeNameList, String name) {    for (Iterator i = employeeNamList.iterator(); i.hasNext();) {        String s = (String) i.next();        if (s.equals(name)) {            return true;            // print employee name here ......        }    }    return false;}// Listing Bprivate boolean staticbooleancheckName(Collection<String> employeeNameList, String name) {    for (Iterator i = employeeNamList.iterator(); i.hasNext();) {        if (i.next().equals(name)) {            return true;            // print employee name here ......        }    }    return false;}

　　现在，通过方法签名可以清楚知道输入集合必须只能包含strings。如果客户试图传入一个包含string buffers的集合，程序将不会编译。同时注意，该方法不包含任何强制转换。它只需要短短一行，一旦你习惯泛型后，它也更加清晰。

FOREACH

　　在JDK当前版本下的For循环语法如下：

for (Iterator i = c.iterator(); i.hasNext();) {    Employee emp = (Employee) i.next();    System.out.println(emp.getName());}

　　现在，用增强的For语句实现相同方法：

for (Object o : c) {    System.out.println((TimerTask)o).getName()); }

　　在这类For循环中，你应该将”:”看成”in”，所以，在该例中可以看成”for Object o in c”。你可以发现这种For循环更具可读性。

自动拆箱装箱

Java有基本数据类型，在这些基本数据类型周围又有包装类。通常，编程人员需要将一种类型转换成另一种。

　　int sum = 10; 　　Integer sum = new Integer(30); 　　Integer num = new Integer(sum.intValue +10); 

　　请注意，用于计算ageAfterTenYear的内循环代码看上去是多么杂乱。现在，看看重写后的样子。

　　int sum = 10; 　　Integer sum = new Integer(30); 　　Integer num = sum +10; 

　　有一件事值得注意的：在先前，如果你取出（unbox）Null值，它将变为0。在次代码中，编译器将自动地转换Integer为int然后加上10，接着将其转换回Integer。

类型安全的枚举（Typesafeenums）

　　类型安全的枚举提供下列特性：

他们提供编译时类型安全。 　　
他们都是对象，因此你不需要将他们放入集合中。 　　
他们作为一种类的实现，因此你可以添加一些方法。
他们为枚举类型提供了合适的命名空间。 　　
他们打印的值具有情报性（informative）― 如果你打印一个整数枚举（intenum），你只是看见一个数字，它可能并不具有情报性。

　　例一：

enum Season { spring, summer, fall , winter}

　　例二：

    public enum Coin {        penny(1), nickel(5), dime(10), quarter(25);        Coin(int value) {            this.value = value;        }        private final int value;        public int value() {            return value;        }    }

静态导入（Static import）

　　静态导入使代码更易读。通常，你要使用定义在另一个类中的常量（constants），像这样：

import org.grp.Increment; class Employee {    public Double calculateSalary(Double salary){        return salary + Increment.INCREMENT  * salary;    } } 

　　当时使用静态导入，我们无需为常量名前缀类名就能使用这些常量，像这样：

import org.grp.Increment; class Employee {    public Double calculateSalary(Double salary){        return salary + INCREMENT  * salary;    } } 　

　　注意，我们可以调用INCREMENT这一常量而不要使用类名Increment.。

元数据（Metadata） - 注解

　　元数据特征志于使开发者们借助厂商提供的工具可以进行更简易的开发。看一看Listing E.中的代码。

// Listing E import org.yyy.hr;public interface EmployeeI extends Java.rmi.Remote {    public String getName()     throwsJava.rmi.RemoteException;    public String getLocation ()     throwsJava.rmi.RemoteException;}public class EmployeeImpl implements EmployeeI {    public String getName() {    }    public String getLocation() {    }}

　　通过元数据的支持，你可以改写Listing E中的代码为：

// Listing E import org.yyy.hr;public class Employee {    @Remote    public String getName() {        // TODO something    }    @Remote    public public String getLocation() {        // TODO something    }}

线程池

Java5中，对Java线程的类库做了大量的扩展，其中线程池就是Java5的新特征之一，除了线程池之外，还有很多多线程相关的内容，为多线程的编程带来了极大便利。为了编写高效稳定可靠的多线程程序，线程部分的新增内容显得尤为重要。

有关Java5线程新特征的内容全部在java.util.concurrent下面，里面包含数目众多的接口和类，熟悉这部分API特征是一项艰难的学习过程。目前有关这方面的资料和书籍都少之又少，大所属介绍线程方面书籍还停留在java5之前的知识层面上。

当然新特征对做多线程程序没有必须的关系，在java5之前通用可以写出很优秀的多线程程序。只是代价不一样而已。

线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。

在Java5之前，要实现一个线程池是相当有难度的，现在Java5为我们做好了一切，我们只需要按照提供的API来使用，即可享受线程池带来的极大便利。

Java5的线程池分好多种：固定尺寸的线程池、可变尺寸连接池

在使用线程池之前，必须知道如何去创建一个线程池，在Java5中，需要了解的是java.util.concurrent.Executors类的API，这个类提供大量创建连接池的静态方法，是必须掌握的。

一、固定大小的线程池

import java.util.concurrent.Executors; import java.util.concurrent.ExecutorService; /** * Java线程：线程池- * * @author Administrator 2009-11-4 23:30:44 */ public class Test {         public static void main(String[] args) {                 //创建一个可重用固定线程数的线程池                 ExecutorService pool = Executors.newFixedThreadPool(2);                 //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口                 Thread t1 = new MyThread();                 Thread t2 = new MyThread();                 Thread t3 = new MyThread();                 Thread t4 = new MyThread();                 Thread t5 = new MyThread();                 //将线程放入池中进行执行                 pool.execute(t1);                 pool.execute(t2);                 pool.execute(t3);                 pool.execute(t4);                 pool.execute(t5);                 //关闭线程池                 pool.shutdown();         } } class MyThread extends Thread{         @Override         public void run() {                 System.out.println(Thread.currentThread().getName()+"正在执行。。。");         } }

输出结果为：

pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。

Process finished with exit code 0

二、单任务线程池

在上例的基础上改一行创建pool对象的代码为：

//创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。 ExecutorService pool = Executors.newSingleThreadExecutor(); 

输出结果为：

pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。

Process finished with exit code 0

对于以上两种连接池，大小都是固定的，当要加入的池的线程（或者任务）超过池最大尺寸时候，则入此线程池需要排队等待。
一旦池中有线程完毕，则排队等待的某个线程会入池执行。

三、可变尺寸的线程池

与上面的类似，只是改动下pool的创建方式：

//创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。 ExecutorService pool = Executors.newCachedThreadPool(); 

输出结果为：

pool-1-thread-5正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-4正在执行。。。
pool-1-thread-3正在执行。。。
pool-1-thread-2正在执行。。。

Process finished with exit code 0

四、延迟连接池

import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; /** * Java线程：线程池- * * @author Administrator 2009-11-4 23:30:44 */ public class Test {         public static void main(String[] args) {                 //创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。                 ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);                 //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口                 Thread t1 = new MyThread();                 Thread t2 = new MyThread();                 Thread t3 = new MyThread();                 Thread t4 = new MyThread();                 Thread t5 = new MyThread();                 //将线程放入池中进行执行                 pool.execute(t1);                 pool.execute(t2);                 pool.execute(t3);                 //使用延迟执行风格的方法                 pool.schedule(t4, 10, TimeUnit.MILLISECONDS);                 pool.schedule(t5, 10, TimeUnit.MILLISECONDS);                 //关闭线程池                 pool.shutdown();         } } class MyThread extends Thread {         @Override         public void run() {                 System.out.println(Thread.currentThread().getName() + "正在执行。。。");         } }

输出结果为：

pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。

Process finished with exit code 0

五、单任务延迟连接池

在四代码基础上，做改动

//创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。 ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();

输出结果为：

pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。

Process finished with exit code 0

六、自定义线程池

import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; /** * Java线程：线程池-自定义线程池 * * @author Administrator 2009-11-4 23:30:44 */ public class Test {         public static void main(String[] args) {                 //创建等待队列                 BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);                 //创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。                 ThreadPoolExecutor pool = new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue);                 //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口                 Thread t1 = new MyThread();                 Thread t2 = new MyThread();                 Thread t3 = new MyThread();                 Thread t4 = new MyThread();                 Thread t5 = new MyThread();                 Thread t6 = new MyThread();                 Thread t7 = new MyThread();                 //将线程放入池中进行执行                 pool.execute(t1);                 pool.execute(t2);                 pool.execute(t3);                 pool.execute(t4);                 pool.execute(t5);                 pool.execute(t6);                 pool.execute(t7);                 //关闭线程池                 pool.shutdown();         } } class MyThread extends Thread {         @Override         public void run() {                 System.out.println(Thread.currentThread().getName() + "正在执行。。。");                 try {                         Thread.sleep(100L);                 } catch (InterruptedException e) {                         e.printStackTrace();                 }         } }

输出结果为：

pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。
pool-1-thread-2正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。

Process finished with exit code 0

创建自定义线程池的构造方法很多，本例中参数的含义如下：

ThreadPoolExecutorpublic ThreadPoolExecutor(int corePoolSize,                          int maximumPoolSize,                          long keepAliveTime,                          TimeUnit unit,                          BlockingQueue<Runnable> workQueue)

用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor。使用 Executors 工厂方法之一比使用此通用构造方法方便得多。

参数：
corePoolSize - 池中所保存的线程数，包括空闲线程。 maximumPoolSize - 池中允许的最大线程数。
keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。 unit - keepAliveTime 参数的时间单位。 workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。

抛出：
IllegalArgumentException - 如果 corePoolSize 或 keepAliveTime 小于零，或者
maximumPoolSize 小于或等于零，或者 corePoolSize 大于 maximumPoolSize。
NullPointerException - 如果 workQueue 为 null

自定义连接池稍微麻烦些，不过通过创建的ThreadPoolExecutor线程池对象，可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等。

Java Generics

在JDK1.5之前的版本中，对于一个Collection类库中的容器类实例，可将任意类型对象加入其中（都被当作Object实例看待）；从容器中取出的对象也只是一个Object实例，需要将其强制转型为期待的类型，这种强制转型的运行时正确性由程序员自行保证。

例如以下代码片断：

List intList = new ArrayList(); //创建一个List，准备存放一些Integer实例 intList.add(new Integer(0)); //不小心加入了一个字符串；但在编译和运行时都不报错，只有仔细的代码走才能揪出intList.add(“1”);  Integer i0 = (Integer)intList.get(0); //编译通过，直到运行时才抛ClassCastException Integer i1 = (Integer)intList.get(1);

而在JDK1.5中，可以创建一个明确只能存放某种特定类型对象的容器类实例，例如如下代码：

//intList为存放Integer实例的List List<Integer> intList = new ArrayList<Integer>(); intList.add(new Integer(0)); //无需(Integer)强制转型//List<Integer>的get()返回的就是//Integer类型对象 Integer i0 = intList.get(0);//编译不通过，因为//List<Integer>的//add()方法只接受//Integer类型的参数 intList.add("1");  

List<Integer> intList = new ArrayList<Integer>();就是最简单且最常用的Generic应用；显然，运用Generic后的代码更具可读性和健壮性。

Generic类

JDK1.5中Collection类库的大部分类都被改进为Generic类。以下是从JDK1.5源码中截取的关于List和Iterator接口定义的代码片断：

public interface List<E> {        void add(E x);        Iterator<E> iterator; } public interface Iterator<E> {        E next();        boolean hasNext(); } 

以List为例，public interface List<E>中的E是List的类型参数，用户在使用List

时可为类型参数指定一个确定类型值（如List<Integer>）。类型值为Java编译器所用，确保用户代码类型安全。例如，编 译器知道List<Integer>的add()方法只接受Integer类型的参数，因此如果你在代码中将一个字符串传入add()将导致 编译错误；编译器知道Iterator<Integer>的next()方法返回一个Integer的实例，你在代码中也就无需对返回结果进 行(Integer)强制转型。代码检验通过（语法正确且不会导致运行时类型安全问题）后，编译器对现有代码有一个转换工作。简单的说，就是去除代码中的 类型值信息，在必要处添加转型代码。例如如下代码：

public String demo() {     List<String> strList = new ArrayList<String>();     strList.add(“Hello!”);     return strList.get(0); } 

编译器在检验通过后，将其转换为：

public String demo() {     List strList = new ArrayList(); //去除类型值<String>     strList.add(“Hello!”);     return (String)strList.get(0);  //添加转型动作代码(String) } 

可见，类型值信息只为Java编译器在编译时所用，确保代码无类型安全问题；验证通过之后，即被去除。对于JVM而言，只有如JDK1.5之前版本一样的 List，并无List<Integer>和List<String>之分。这也就是Java Generics实现中关键技术Erasure的基本思想。以下代码在控制台输出的就是“true”。

List<String> strList = new ArrayList<String>(); List<Integer> intList = new ArrayList<Integer>(); System.out.println(strList.getClass() == intList.getClass()); 

可以将Generic理解为：为提高Java代码类型安全性（在编译时确保，而非等到运行时才暴露），Java代码与Java编译器之间新增的一种约定规 范。Java编译器在编译结果*.class文件中供JVM读取的部分里没有保留Generic的任何信息；JVM看不到Generic的存在。
对于Generic类（设为GenericClass）的类型参数（设为T）：

1) 由于对于JVM而言，只有一个GenericClass类，所以GenericClass类的静态字段和静态方法的定义中不能使用T。T只能出现在 GenericClass的非静态字段或非静态方法中。也即T是与GenericClass的实例相关的信息；

2) T只在编译时被编译器理解，因此也就不能与运行时被JVM理解并执行其代表的操作的操作符（如instanceof 和new）联用。

class GenericClass<T> {     T t1;     public void method1(T t){        t1 = new T(); //编译错误，T不能与new联用        if (t1 instanceof T) {}; //编译错误，T不能与instanceof联用     };     static T t2; //编译错误，静态字段不能使用T     public static void method2(T t){};//编译错误，静态方法不能使用T } 

Generic类可以有多个类型参数，且类型参数命名一般为大写单字符。例如Collection类库中的Map声明为：

public interface Map<K,V> {        // ……; } 

Generic类和原（Raw）类

对每一个Generic类，用户在使用时可以不指定类型参数。例如，对于List<E>，用户

可以以List<String> list;方式使用，也可以以List list;方式使用。List<String>被称为参数化的Generic类（类型参数被赋值），而“List”称为原类。原类 List的使用方式和效果与JDK1.5之前版本List的一样；使用原类也就失去了Generic带来的可读性和健壮性的增强。

允许原类使用方式的存在显然是为了代码的向前兼容：即JDK1.5之前的代码在JDK1.5下仍然编译通过且正常运行。

当你在JDK1.5中使用原类并向原类实例中添加对象时，编译器会产生警告，因为它无法保证待添加对象类型的正确性。编译通过是为了保证代码向前兼容，产生警告是提醒潜在的风险。

public void test () {     List list = new ArrayList();     list.add("tt");//JDK1.5编译器对此行产生警告 } 

4 Generic类和子类

List<String> ls = new ArrayList<String>(); //编译错误：Type mismatch: cannot convert from List<Dummy> to //List<Object>     List<Object> lo = ls;                                            

以上第二行代码导致的编译错误“Type mismatch: cannot convert from List<Dummy> to
List<Object>”是不是有点出人意料？直观上看，就像String是Object的子类，因此‘Object o = “String”’合法一样，存放String的List是存放Object的List的子类，因此第二行应该是合法的。反过来分析，如果第二行是合法 的，那么如下会导致运行时异常的代码也是合法的：

lo.add(new Object); //会导致在ls中添加了非String对象 String s = ls.get(0); //ls.get(0)返回的实际上只是一个Object实例，会导致ClassCastException 

编译器显然不允许此种情形发生，因此不允许List<Object> lo = ls编译通过。
因此，直观上的“存放String的List是存放Object的List的子类”是错误的。更一般的说，设Foo是Bar的子类，G是Generic类型声明，G<Foo>不是G<Bar>的子类。

参数化的Generic类和数组

我们知道，如果T是S的子类，则T[]也是S[]的子类。因此，如下代码编译通过，只在运行时于第三行代码处抛ArrayStoreException。

String[] words = new String[10]; Object[] objects = words; Objects[0] = new Object(); //编译通过，但运行时会抛ArrayStoreException

再分析如下代码：

List<String>[] wordLists = new ArrayList<String>[10]; ArrayList<Integer> integerList = new ArrayList<Integer>(); integerList.add(123); Object[] objects = wordLists; objects[0] = integerList;//运行时不出错，因为运行时ArrayList<String>和ArrayList<Integer>都                                  //为ArrayList String s = wordlists[0].get(0); //编译通过，运行时抛ClassCastException 

就出现了“正确使用了Generic，但在运行时仍然出现ClassCastException”的情形。显然Java编译器不允许此种情形的发生。事实 上，以上代码的第一行List<String>[] wordLists = new ArrayList<String>[10];就是编译不通过的，也就不存在接下来的代码。
更一般地说，不能创建参数化的Generic类的数组。

类型参数通配符?

由“Generic类和子类”节知，Collection<Object>不是存放其它类型对象的Collection（例如Collection<String>）的基类（抽象），那么如何表示任一种参数化的Collection的呢？使用Collection<?>。？即代表任一类型参数值。例如，我们可以很容易写出下面的通用函数printCollection()：

public static void printCollection(Collection<?> c) {        //如此遍历Collection的简洁方式也是JDK1.5新引入的        for (Object o : c) {               System.out.println(o);        } } 

这样，既可以将Collection<String>的实例，也可以将Collection<Integer>的实例作为参数调用printCollection()方法。

然而，要注意一点，你不能往Collection<?>容器实例中加入任何非null元素，例如如下代码的第三行编译不通过：

public static void testAdd(Collection<?> c) {     c.add(null); //编译通过     c.add(“test”); //编译错误 } 

很好理解：c中要存放的对象的具体类型不确定，编译器无法验证待添加对象类型的正确性，因此不能加入对象实例；而null可以看作是任一个类的实例，因而允许加入。

另外，尽管c中要存放的对象的类型不确定，但我们知道任何类都是Object子类，因此从c中取出的对象都统一作为Object实例。

更进一步，如果BaseClass代表某个可被继承的类的类名，那么Collection<? extends BaseClass>代表类型参数值为BaseClass或BaseClass某个子类的任一参数化Collection。对于 Collection<? extends BaseClass>的实例c，因为c中要存放的对象具体类型不确定，不能往其加入非null对象，但从c中取出的对象都统一作为BaseClass实例。事实上，你可以把Collection<?>看作Collection<? extends Object>的简洁形式。

另一种情形：如果SubClass代表任一个类的类名，那么Collection<? super SubClass>代表类型参数值为SubClass或SubClass某个祖先类的任一参数化Collection。对于 Collection<? super SubClass>的实例c，你可以将SubClass实例加入其中，但从中取出的对象都是Object实例。

Generic方法

我们可以定义Generic类，同样可以定义Generic方法，即将方法的一个或多个参数的类型参数化，如代码：

public static <T> void fromArrayToCollection(T[] a, Collection<T> c) {        for (T o : a) {            c.add(o); //合法。注意与Collection<?>的区别       } } 

我们可以以如下方式调用fromArrayToCollection()：

Object[] oa = new Object[100]; Collection<Object> co = new ArrayList<Object>(); fromArrayToCollection(oa, co); //此时，T即为Object String[] sa = new String[100]; Collection<String> cs = new ArrayList<String>(); fromArrayToCollection(sa, cs); //此时，T即为String fromArrayToCollection(sa, co); //此时，T即为Object Integer[] ia = new Integer[100]; Float[] fa = new Float[100]; Number[] na = new Number[100]; Collection<Number> cn = new ArrayList<Number>(); fromArrayToCollection(ia, cn); //此时，T即为Number fromArrayToCollection(fa, cn); //此时，T即为Number fromArrayToCollection(na, cn); //此时，T即为Number fromArrayToCollection(na, co); //此时，T即为Object fromArrayToCollection(na, cs); //编译错误 

通过以上代码可以看出，我们在调用fromArrayToCollection()时，无需明确指定T为何种类型（与Generic类的使用方式不同），而是像调用一般method一样，直接提供参数值，编译器会根据提供的参数值自动为T赋类型值或提示编译错误（参数值不当）。

考虑如下函数sum()

public static long sum(Collection<? extends Number> numbers) {     long sum = 0;     for (Number n : numbers) {        sum += n.longValue();     }     return sum; } 

我们也可以将其以Generic方法实现：

public static <T extends Number> long sum(Collection<T> numbers) {     long sum = 0;     for (Number n : numbers) {        sum += n.longValue();     }    return sum; } 

那么对于一个方法，当要求参数类型可变时，是采用Generic方法，还是采用类型参数通配符方式呢？一般而言，如果参数类型间或参数类型与返回值类型间存在某种依赖关系，则采取Generic方法，否则采取类型参数通配符方式。

这一原则在Collection类库的源代码中得到了很好的体现，例如Collection接口的containsAll()、addAll()和toArray()方法：

interface Collection<E> {     //参数间类型以及参数与返回值间类型无依赖     public boolean containsAll(Collecion<?> c);     <T> T[] toArray(T[] a); //参数a与返回值都是相同类的数组，有依赖 } 

当然，根据需要，二者也可以结合使用，例如Collections中的copy()方法：

class Collections {     public static <T> void copy(List<T> dest, List<? extends T> src) {         // ……    } } 

可变长的参数

参数的个数不确定