无为

Java 5.0 发布了，许多人都将开始使用这个 JDK 版本的一些新增特性。从增强的 for 循环到诸如泛型 (generic) 之类更复杂的特性，都将很快出现在您所编写的代码中。我们刚刚完成了一个基于 Java 5.0 的大型任务，而本文就是要介绍我们使用这些新特性的体验。本文不是一篇入门性的文章，而是对这些特性以及它们所产生的影响的深入介绍，同时还给出了一些在项目中更有效地使用这些特性的技巧。

　　在 JDK 1.5 的 beta 阶段，我们为 BEA 的 Java IDE 开发了一个 Java 5 编译器。因为我们实现了许多新特性，所以人们开始以新的方式利用它们 ; 有些用法很聪明，而有些用法明显应该被列入禁用清单。编译器本身使用了新的语言特性，所以我们也获得了使用这些特性维护代码的直接体验。本文将介绍其中的许多特性和使用它们的体验。

　　我们假定您已经熟悉了这些新特性，所以不再全面介绍每个特性，而是谈论一些有趣的、但很可能不太明显的内容和用法。这些技巧出自我们的实际体验，并大致按照语言特性进行了分类。

　　我们将从最简单的特性开始，逐步过渡到高级特性。泛型所包含的内容特别丰富，因此占了本文一半的篇幅。

　　增强的 for 循环

　　为了迭代集合和数组，增强的 for 循环提供了一个简单、兼容的语法。有两点值得一提 :

　　 Init 表达式

　　在循环中，初始化表达式只计算一次。这意味着您通常可以移除一个变量声明。在这个例子中，我们必须创建一个整型数组来保存 computeNumbers() 的结果，以防止每一次循环都重新计算该方法。您可以看到，下面的代码要比上面的代码整洁一些，并且没有泄露变量 numbers:

未增强的 For ：
int sum = 0;
Integer[] numbers = computeNumbers();
for (int i=0; i < numbers.length ; i++)
    sum += numbers[i];
增强后的 For ：
int sum = 0;

for ( int number: computeNumbers() )
    sum += number;

　　局限性

　　有时需要在迭代期间访问迭代器或下标，看起来增强的 for 循环应该允许该操作，但事实上不是这样，请看下面的例子 :

for (int i=0; i < numbers.length ; i++) {
    if (i != 0) System.out.print(",");
    System.out.print(numbers[i]);
}

　　我们希望将数组中的值打印为一个用逗号分隔的清单。我们需要知道目前是否是第一项，以便确定是否应该打印逗号。使用增强的 for 循环是无法获知这种信息的。我们需要自己保留一个下标或一个布尔值来指示是否经过了第一项。 　　这是另一个例子 :

for (Iterator<integer> it = n.iterator() ; it.hasNext() ; )
    if (it.next() < 0)
        it.remove();

　　在此例中，我们想从整数集合中删除负数项。为此，需要对迭代器调用一个方法，但是当使用增强的 for 循环时，迭代器对我们来说是看不到的。因此，我们只能使用 Java 5 之前版本的迭代方法。 　　顺便说一下，这里需要注意的是，由于 Iterator 是泛型，所以其声明是 Iterator 。许多人都忘记了这一点而使用了 Iterator 的原始格式。

　　注释

　　注释处理是一个很大的话题。因为本文只关注核心的语言特性，所以我们不打算涵盖它所有的可能形式和陷阱。　　我们将讨论内置的注释 (SuppressWarnings ， Deprecated 和 Override) 以及一般注释处理的局限性。

　　 Suppress Warnings

　　该注释关闭了类或方法级别的编译器警告。有时候您比编译器更清楚地知道，代码必须使用一个被否决的方法或执行一些无法静态确定是否类型安全的动作，而使用 :

@SuppressWarnings("deprecation")
public static void selfDestruct() {
    Thread.currentThread().stop();
}

　　这可能是内置注释最有用的地方。遗憾的是， 1.5.0 _04 的 javac 不支持它。但是 1.6 支持它，并且 Sun 正在努力将其向后移植到 1.5 中。

　　 Eclipse 3.1 中支持该注释，其他 IDE 也可能支持它。这允许您把代码彻底地从警告中解脱出来。如果在编译时出现警告，可以确定是您刚刚把它添加进来 —— 以帮助查看那些可能不安全的代码。随着泛型的添加，它使用起来将更趁手。

　　 Deprecated

　　遗憾的是， Deprecated 没那么有用。它本来旨在替换 @deprecated javadoc 标签，但是由于它不包含任何字段，所以也就没有方法来建议 deprecated 类或方法的用户应该使用什么做为替代品。大多数用法都同时需要 javadoc 标签和这个注释。

Override

　　 Override 表示，它所注释的方法应该重写超类中具有相同签名的方法 :

@Override
public int hashCode() {
    ...
}

　　看上面的例子，如果没有在 hashCode 中将 “C” 大写，在编译时不会出现错误，但是在运行时将无法像期望的那样调用该方法。通过添加 Override 标签，编译器会提示它是否真正地执行了重写。

　　在超类发生改变的情况中，这也很有帮助。如果向该方法中添加一个新参数，而且方法本身也被重命名了，那么子类将突然不能编译，因为它不再重写超类的任何东西。

　　其它注释

　　注释在其他场景中非常有用。当不是直接修改行为而是增强行为时，特别是在添加样板代码的情况下，注释在诸如 EJB 和 Web services 这样的框架中运行得非常好。

　　注释不能用做预处理器。 Sun 的设计特别预防了完全因为注释而修改类的字节码。这样可以正确地理解该语言的成果，而且 IDE 之类的工具也可以执行深入的代码分析和重构之类的功能。

　　注释不是银弹。第一次遇到的时候，人们试图尝试各种技巧。请看下面这个从别人那里获得的建议 :

public class Foo {
 
    @Property
    private int bar;
 
}

　　其思想是为私有字段 bar 自动创建 getter 和 setter 方法。遗憾的是，这个想法有两个失败之处 :1) 它不能运行， 2) 它使代码难以阅读和处理。 　　它是无法实现的，因为前面已经提到了， Sun 特别阻止了对出现注释的类进行修改。

　　即使是可能的，它也不是一个好主意，因为它使代码可读性差。第一次看到这段代码的人会不知道该注释创建了方法。此外，如果将来您需要在这些方法内部执行一些操作，注释也是没用的。 　　总之，不要试图用注释去做那些常规代码可以完成的事情。

　　枚举

　　 enum 非常像 public static final int 声明，后者作为枚举值已经使用了很多年。对 int 所做的最大也是最明显的改进是类型安全 —— 您不能错误地用枚举的一种类型代替另一种类型，这一点和 int 不同，所有的 int 对编译器来说都是一样的。除去极少数例外的情况，通常都应该用 enum 实例替换全部的枚举风格的 int 结构。

　　枚举提供了一些附加的特性。 EnumMap 和 EnumSet 这两个实用类是专门为枚举优化的标准集合实现。如果知道集合只包含枚举类型，那么应该使用这些专门的集合来代替 HashMap 或 HashSet 。

　　大部分情况下，可以使用 enum 对代码中的所有 public static final int 做插入替换。它们是可比的，并且可以静态导入，所以对它们的引用看起来是等同的，即使是对于内部类 ( 或内部枚举类型 ) 。注意，比较枚举类型的时候，声明它们的指令表明了它们的顺序值。

　　 “ 隐藏的 ” 静态方法

　　两个静态方法出现在所有枚举类型声明中。因为它们是枚举子类上的静态方法，而不是 Enum 本身的方法，所以它们在 java.lang.Enum 的 javadoc 中没有出现。

　　第一个是 values() ，返回一个枚举类型所有可能值的数组。

　　第二个是 valueOf() ，为提供的字符串返回一个枚举类型，该枚举类型必须精确地匹配源代码声明。

　　方法

　　关于枚举类型，我们最喜欢的一个方面是它可以有方法。过去您可能需要编写一些代码，对 public static final int 进行转换，把它从数据库类型转换为 JDBC URL 。而现在则可以让枚举类型本身带一个整理代码的方法。下面就是一个例子，包括 DatabaseType 枚举类型的抽象方法以及每个枚举实例中提供的实现 :

  public enum  DatabaseType {
  ORACLE {
  public String getJdbcUrl() {...}
  },
  MYSQL {
  public String getJdbcUrl() {...}
  };
  public abstract String getJdbcUrl();
  }

　　现在枚举类型可以直接提供它的实用方法。例如 :

DatabaseType dbType = ...;
String jdbcURL = dbType.getJdbcUrl();

　　要获取 URL ，必须预先知道该实用方法在哪里。

可变参数 (Vararg)

　　正确地使用可变参数确实可以清理一些垃圾代码。典型的例子是一个带有可变的 String 参数个数的 log 方法 :

    Log.log(String code)
    Log.log(String code,  String arg)
    Log.log(String code,  String arg1, String arg2)
    Log.log(String code,  String[] args)

　　当讨论可变参数时，比较有趣的是，如果用新的可变参数替换前四个例子，将是兼容的 :

　　 Log.log(String code, String... args)

　　所有的可变参数都是源兼容的 —— 那就是说，如果重新编译 log() 方法的所有调用程序，可以直接替换全部的四个方法。然而，如果需要向后的二进制兼容性，那么就需要舍去前三个方法。只有最后那个带一个字符串数组参数的方法等效于可变参数版本，因此可以被可变参数版本替换。

　　类型强制转换

　　如果希望调用程序了解应该使用哪种类型的参数，那么应该避免用可变参数进行类型强制转换。看下面这个例子，第一项希望是 String ，第二项希望是 Exception:

    Log.log(Object...  objects) {
    String message = (String)objects[0];
    if (objects.length > 1) {
    Exception e = (Exception)objects[1];
    // Do something with the exception
    }
    }

　　方法签名应该如下所示，相应的可变参数分别使用 String 和 Exception 声明 :

　　 Log.log(String message, Exception e, Object... objects) {...}

　　不要使用可变参数破坏类型系统。需要强类型化时才可以使用它。对于这个规则， PrintStream.printf() 是一个有趣的例外 : 它提供类型信息作为自己的第一个参数，以便稍后可以接受那些类型。

　　协变返回

　　协变返回的基本用法是用于在已知一个实现的返回类型比 API 更具体的时候避免进行类型强制转换。在下面这个例子中，有一个返回 Animal 对象的 Zoo 接口。我们的实现返回一个 AnimalImpl 对象，但是在 JDK 1.5 之前，要返回一个 Animal 对象就必须声明。 :

    public interface Zoo  {
    public Animal getAnimal();
    }
  public class ZooImpl  implements Zoo {
  public Animal getAnimal(){
  return new AnimalImpl();
  }
  }

　　协变返回的使用替换了三个反模式 :

　　 · 直接字段访问。为了规避 API 限制，一些实现把子类直接暴露为字段 :

　　 ZooImpl._animal

　　 · 另一种形式是，在知道实现的实际上是特定的子类的情况下，在调用程序中执行向下转换 :

　　 ((AnimalImpl)ZooImpl.getAnimal()).implMethod();

　　 · 我看到的最后一种形式是一个具体的方法，该方法用来避免由一个完全不同的签名所引发的问题 :

　　 ZooImpl._getAnimal();

　　这三种模式都有它们的问题和局限性。要么是不够整洁，要么就是暴露了不必要的实现细节。

　　协变

　　协变返回模式就比较整洁、安全并且易于维护，它也不需要类型强制转换或特定的方法或字段 :

public AnimalImpl getAnimal(){
return new AnimalImpl();
}
　　使用结果：
ZooImpl.getAnimal().implMethod();

使用泛型

　　我们将从两个角度来了解泛型 : 使用泛型和构造泛型。我们不讨论 List 、 Set 和 Map 的显而易见的用法。知道泛型集合是强大的并且应该经常使用就足够了。

　　我们将讨论泛型方法的使用以及编译器推断类型的方法。通常这些都不会出问题，但是当出问题时，错误信息会非常令人费解，所以需要了解如何修复这些问题。

　　泛型方法

　　除了泛型类型， Java 5 还引入了泛型方法。在这个来自 java.util.Collections 的例子中，构造了一个单元素列表。新的 List 的元素类型是根据传入方法的对象的类型来推断的 :

static <T> List<T> Collections.singletonList(T o)
示例用法：
public List<Integer> getListOfOne() {
    return Collections.singletonList(1);
}

　　示例用法 :

　　在示例用法中，我们传入了一个 int 。所以方法的返回类型就是 List 。编译器把 T 推断为 Integer 。这和泛型类型是不同的，因为您通常不需要显式地指定类型参数。

　　这也显示了自动装箱和泛型的相互作用。类型参数必须是引用类型 : 这就是为什么我们得到的是 List 而不是 List 。

　　不带参数的泛型方法

　　 emptyList() 方法与泛型一起引入，作为 java.util.Collections 中 EMPTY_LIST 字段的类型安全置换 :

static <T> List<T> Collections.emptyList()
示例用法：
public List<Integer> getNoIntegers() {
    return Collections.emptyList();
}

　　与先前的例子不同，这个方法没有参数，那么编译器如何推断 T 的类型呢 ? 基本上，它将尝试使用一次参数。如果没有起作用，它再次尝试使用返回或赋值类型。在本例中，返回的是 List ，所以 T 被推断为 Integer 。

　　如果在返回语句或赋值语句之外的位置调用泛型方法会怎么样呢 ? 那么编译器将无法执行类型推断的第二次传送。在下面这个例子中， emptyList() 是从条件运算符内部调用的 :

public List<Integer> getNoIntegers() {
    return x ? Collections.emptyList() : null;
}

　　因为编译器看不到返回上下文，也不能推断 T ，所以它放弃并采用 Object 。您将看到一个错误消息，比如 :“ 无法将 List<Object> 转换为 List<Integer> 。 ” 为了修复这个错误，应显式地向方法调用传递类型参数。这样，编译器就不会试图推断类型参数，就可以获得正确的结果：

return x ? Collections.<Integer>emptyList() : null;

　　这种情况经常发生的另一个地方是在方法调用中。如果一个方法带一个 List<String> 参数，并且需要为那个参数调用这个传递的 emptyList() ，那么也需要使用这个语法。
集合之外

　　这里有三个泛型类型的例子，它们不是集合，而是以一种新颖的方式使用泛型。这三个例子都来自标准的 Java 库：

• Class<T>
Class 在类的类型上被参数化了。这就使无需类型强制转换而构造一个 newInstance 成为可能。
• Comparable<T>
Comparable 被实际的比较类型参数化。这就在 compareTo() 调用时提供了更强的类型化。例如， String 实现 Comparable<String> 。对除 String 之外的任何东西调用 compareTo() ，都会在编译时失败。
• Enum<E extends Enum<E>>
Enum 被枚举类型参数化。一个名为 Color 的枚举类型将扩展 Enum<Color> 。 getDeclaringClass() 方法返回枚举类型的类对象，在这个例子中就是一个 Color 对象。它与 getClass() 不同，后者可能返回一个无名类。

      通配符

　　泛型最复杂的部分是对通配符的理解。我们将讨论三种类型的通配符以及它们的用途。

　　首先让我们了解一下数组是如何工作的。可以从一个 Integer[] 为一个 Number[] 赋值。如果尝试把一个 Float 写到 Number[] 中，那么可以编译，但在运行时会失败，出现一个 ArrayStoreException ：

Integer[] ia = new Integer[5];
Number[] na = ia;
na[0] = 0.5; // compiles, but fails at runtime

如果试图把该例直接转换成泛型，那么会在编译时失败，因为赋值是不被允许的：

List<Integer> iList = new ArrayList<Integer>();
List<Number> nList = iList; // not allowed
nList.add(0.5);

　　如果使用泛型，只要代码在编译时没有出现警告，就不会遇到运行时 ClassCastException 。

上限通配符

　　我们想要的是一个确切元素类型未知的列表，这一点与数组是不同的。

List<Number> 是一个列表，其元素类型是具体类型 Number 。
List<? extends Number> 是一个确切元素类型未知的列表。它是 Number 或其子类型。

上限

　　如果我们更新初始的例子，并赋值给 List<? extends Number> ，那么现在赋值就会成功了：

List<Integer> iList = new ArrayList<Integer>();
List<? extends Number> nList = iList;
Number n = nList.get(0);
nList.add(0.5); // Not allowed

　　我们可以从列表中得到 Number ，因为无论列表的确切元素类型是什么（ Float 、 Integer 或 Number ），我们都可以把它赋值给 Number 。

　　我们仍然不能把浮点类型插入列表中。这会在编译时失败，因为我们不能证明这是安全的。如果我们想要向列表中添加浮点类型，它将破坏 iList 的初始类型安全 —— 它只存储 Integer 。

　　通配符给了我们比数组更多的表达能力。

为什么使用通配符

　　在下面这个例子中，通配符用于向 API 的用户隐藏类型信息。在内部， Set 被存储为 CustomerImpl 。而 API 的用户只知道他们正在获取一个 Set ，从中可以读取 Customer 。
此处通配符是必需的，因为无法从 Set<CustomerImpl> 向 Set<Customer> 赋值：

public class CustomerFactory {
    private Set<CustomerImpl> _customers;
    public Set<? extends Customer> getCustomers() {
        return _customers;
    }
}

通配符和协变返回

　　通配符的另一种常见用法是和协变返回一起使用。与赋值相同的规则可以应用到协变返回上。如果希望在重写的方法中返回一个更具体的泛型类型，声明的方法必须使用通配符：
public interface NumberGenerator {
    public List<? extends Number> generate();
}
public class FibonacciGenerator extends NumberGenerator {
    public List<Integer> generate() {
        ...
    }
}

　　如果要使用数组，接口可以返回 Number[] ，而实现可以返回 Integer[] 。

下限

　　我们所谈的主要是关于上限通配符的。还有一个下限通配符。 List<? super Number> 是一个确切 “ 元素类型 ” 未知的列表，但是可能是 Mnumber ，或者 Number 的超类型。所以它可能是一个 List<Number> 或一个 List<Object> 。

　　下限通配符远没有上限通配符那样常见，但是当需要它们的时候，它们就是必需的。

下限与上限

List<? extends Number> readList = new ArrayList<Integer>();
Number n = readList.get(0);

List<? super Number> writeList = new ArrayList<Object>();
writeList.add(new Integer(5));

　　第一个是可以从中读数的列表。
　　第二个是可以向其写数的列表。

无界通配符

　　最后， List<?> 列表的内容可以是任何类型，而且它与 List<? extends Object> 几乎相同。可以随时读取 Object ，但是不能向列表中写入内容。
公共 API 中的通配符

　　总之，正如前面所说，通配符在向调用程序隐藏实现细节方面是非常重要的，但即使下限通配符看起来是提供只读访问，由于 remove(int position) 之类的非泛型方法，它们也并非如此。如果您想要一个真正不变的集合，可以使用 java.util.Collection 上的方法，比如 unmodifiableList() 。

　　编写 API 的时候要记得通配符。通常，在传递泛型类型时，应该尝试使用通配符。它使更多的调用程序可以访问 API 。

　　通过接收 List<? extends Number> 而不是 List<Number> ，下面的方法可以由许多不同类型的列表调用：

void removeNegatives(List<? extends Number> list);

构造泛型类型

　　现在我们将讨论构造自己的泛型类型。我们将展示一些例子，其中通过使用泛型可以提高类型安全性，我们还将讨论一些实现泛型类型时的常见问题。
集合风格 (Collection-like) 的函数

　　第一个泛型类的例子是一个集合风格的例子。 Pair 有两个类型参数，而且字段是类型的实例：

public final class Pair<A,B> {
    public final A first;
    public final B second;

    public Pair(A first, B second) {
        this.first = first;
        this.second = second;
    }
}

　　这使从方法返回两个项而无需为每个两种类型的组合编写专用的类成为可能。另一种方法是返回 Object[] ，而这样是类型不安全或者不整洁的。

在下面的用法中，我们从方法返回一个 File 和一个 Boolean 。方法的客户端可以直接使用字段而无需类型强制转换：

public Pair<File,Boolean> getFileAndWriteStatus(String path){
    // create file and status
    return new Pair<File,Boolean>(file, status);
}

Pair<File,Boolean> result = getFileAndWriteStatus("...");
File f = result.first;
boolean writeable = result.second;

集合之外

　　在下面这个例子中，泛型被用于附加的编译时安全性。通过把 DBFactory 类参数化为所创建的 Peer 类型，您实际上是在强制 Factory 子类返回一个 Peer 的特定子类型：

public abstract class DBFactory<T extends DBPeer> {
    protected abstract T createEmptyPeer();
    public List<T> get(String constraint) {
        List<T> peers = new ArrayList<T>();
        // database magic
        return peers;
    }
}
通过实现 DBFactory<Customer> ， CustomerFactory 必须从 createEmptyPeer() 返回一个 Customer ：
public class CustomerFactory extends DBFactory<Customer>{

    public Customer createEmptyPeer() {
        return new Customer();
    }
}

泛型方法

　　不管想要对参数之间还是参数与返回类型之间的泛型类型施加约束，都可以使用泛型方法：

　　例如，如果编写的反转函数是在位置上反转，那么可能不需要泛型方法。然而，如果希望反转返回一个新的 List ，那么可能会希望新 List 的元素类型与传入的 List 的类型相同。在这种情况下，就需要一个泛型方法：

<T> List<T> reverse(List<T> list)

具体化

　　当实现一个泛型类时，您可能想要构造一个数组 T[] 。因为泛型是通过擦除 (erasure) 实现的，所以这是不允许的。

　　您可以尝试把 Object[] 强制转换为 T[] 。但这是不安全的。

具体化解决方案

　　按照泛型教程的惯例，解决方案使用的是 “ 类型令牌 ” ，通过向构造函数添加一个 Class<T> 参数，可以强制客户端为类的类型参数提供正确的类对象：

public class ArrayExample<T> {
    private Class<T> clazz;

    public ArrayExample(Class<T> clazz) {
        this.clazz = clazz;
    }

    public T[] getArray(int size) {
        return (T[])Array.newInstance(clazz, size);
    }
}

　　为了构造 ArrayExample<String> ，客户端必须把 String.class 传递给构造函数，因为 String.class 的类型是 Class<String> 。
拥有类对象使构造一个具有正确元素类型的数组成为可能。

结束语

　　总而言之，新的语言特性有助于从根本上改变 Java 。通过了解在什么场景下使用以及如何使用这些新特性，您将会编写出更好的代码。

凡是有该标志的文章，都是该blog博主Caoer（草儿）原创，凡是索引、收藏
、转载请注明来处和原文作者。非常感谢。