修琳琳-JAVA英文翻译

外文翻译 院 系 北方软件学院 专 业 计算机科学与技术（软件工程） 班 级 5233101

学 号 200502331010

姓 名 修琳琳 指导教师 张荣博 负责教师 张荣博

沈阳航空工业学院 2007年6月沈阳航空工业学院毕业设计（外文翻译）

1 Using Java 5 language features in earlier JDK Java 5 added a number of powerful language features: generics, enumerations, annotations, autoboxing, and the enhanced for loop. However, many shops are still tied to JDK 1.4 or earlier and may be for some time to come. But it's still be possible for those developers to take advantage of these powerful language features while continuing to deploy on earlier JVMs. Brian Goetz returns from his hiatus in this installment of Java theory and practice to demonstrate how. With Java 6.0 being newly released, you might think the Java 5 language features are "old news." But even now, when I ask developers which version of the Java platform they are using in development, typically only half are using Java 5 -- and the other half are jealous. They are eager to use the language features added in Java 5 such as generics and annotations, but a number of factors still prevent many from doing so. One category of developers unable to take advantage of Java 5 features are those who develop components, libraries, or application frameworks. Because their customers may still be using JDK 1.4 or earlier and classes compiled with Java 5 cannot be loaded by JDK 1.4 or previous JVMs, using Java 5 language features would limit their customer base to companies that have already transitioned to Java 5. Another group of developers often held back from using Java 5 are those working with Java EE. Many shops will not use Java 5 with Java EE 1.4 or earlier for fear that it will not be supported by their application server vendor. But it may be a while before those shops transition to Java EE 5. In addition to the lag time between the Java EE 5 and Java SE 5 specifications, commercial Java EE 5 containers are not necessarily available as soon as the ink is dry on the specification, businesses do not necessarily upgrade their 沈阳航空工业学院毕业设计（外文翻译） 2 applications servers as soon as the next version is available, and even after upgrading their application server, it may take some time to certify their applications on the new platform. Java 5 language feature implementation The language features added in Java 5 -- generics, enumerations, annotations, autoboxing, and the enhanced for loop -- required no change to the JVM instruction set, and are almost entirely implemented in the static compiler (javac) and class libraries. When the compiler encounters the use of generics, it attempts to verify that type safety is preserved (emitting an "unchecked cast" warning if it cannot) and then emits bytecode that is identical to what would be produced from equivalent nongeneric code, casts and all. Similarly, autoboxing and the enhanced for loop are simply "syntactic sugar" for equivalent, but more verbose, idioms, and enumerations are compiled into ordinary classes. In theory, you could take the class files produced by javac and load them in earlier JVMs, which was, in fact, the intention when JSR 14 (the Java Community Process working group responsible for generics) was convened. However, other issues (such as retention of annotations) forced the class file version to be changed between Java 1.4 and Java 5, which prevents code compiled for Java 5 to be loaded by earlier JVMs. Further, some of the language features added in Java 5 have dependencies on the Java 5 libraries. If you compile a class with javac -target 1.5 and try to load it on an earlier JVM, you'll get an UnsupportedClassVersionError because the -target 1.5 option generates classes with a class file version of 49, and JDK 1.4 only supports class file versions through 48. The for-each loop The enhanced for loop, sometimes called the for-each loop, is translated by the compiler as if the programmer had supplied the equivalent old-style 沈阳航空工业学院毕业设计（外文翻译） 3 for loop. The for-each loop can iterate over the elements of an array or of a collection. Listing 1 shows the syntax of iterating over a collection with the for-each loop: Listing 1. The for-each loop Collection fooCollection = ...

for (Foo f : fooCollection) { doSomething(f); } The compiler translates this code into the equivalent iterator-based loop, as shown in Listing 2: Listing 2. Iterator-based equivalent for Listing 1 for (Iterator iter=f.iterator(); f.hasNext();) { Foo f = (Foo)iter.next(); doSomething(f); } How does the compiler know that the supplied argument has an iterator() method? The architects of the javac compiler could have built in understanding of the collections framework, but this approach would have been unnecessarily restrictive. Instead, a new interface was created, java.lang.Iterable (see Listing 3), and the collection classes were retrofitted to implement Iterable. This way, container classes that do not build on the core collections framework can still take advantage of the new for-each loop. But doing so creates a dependency on the Java 5 class library because Iterable is not present in the JDK 1.4 library. Listing 3. The Iterable interface