J2SE 5.0 新特性
http://java.sun.com/j2se/1.5.0/docs/relnotes/features.htmlGenerics
This long-awaited enhancement to the type system allows a type or method to operate on objects of various types while providing compile-time type safety. It adds compile-time type safety to the Collections Framework and eliminates the drudgery of casting. Refer to JSR 14.
Sample Code:
// Removes the 4-letter words from cstatic void expurgate(Collection<String> c) { for (Iterator<String> i = c.iterator(); i.hasNext(); ) if (i.next().length() == 4) i.remove();}
Enhanced for Loop
This new language construct eliminates the drudgery and error-proneness of iterators and index variables when iterating over collections and arrays. Refer to JSR 201.
Sample Code:
void cancelAll(Collection<TimerTask> c) { for (TimerTask t : c) t.cancel();}
Autoboxing/Unboxing
This facility eliminates the drudgery of manual conversion between primitive types (such as int) and wrapper types (such as Integer). Refer to JSR 201.
Sample Code:
// List adapter for primitive int arraypublic static List<Integer> asList(final int[] a) { return new AbstractList<Integer>() { public Integer get(int i) { return a; } // Throws NullPointerException if val == null public Integer set(int i, Integer val) { Integer oldVal = a; a = val; return oldVal; } public int size() { return a.length; } };}
Typesafe Enums
This flexible object-oriented enumerated type facility allows you to create enumerated types with arbitrary methods and fields. It provides all the benefits of the Typesafe Enum pattern ("Effective Java," Item 21) without the verbosity and the error-proneness. Refer to JSR 201. <a name="varargs" />
Sample Code:
public enum Operation {PLUS { double eval(double x, double y) { return x + y; } },MINUS{ double eval(double x, double y) { return x - y; } },TIMES{ double eval(double x, double y) { return x * y; } },DIVIDE { double eval(double x, double y) { return x / y; } };// Do arithmetic op represented by this constantabstract double eval(double x, double y);}public static void main(String args[]) { double x = Double.parseDouble(args); double y = Double.parseDouble(args); for (Operation op : Operation.values()) System.out.printf("%f %s %f = %f%n", x, op, y, op.eval(x, y)); }
Varargs
This facility eliminates the need for manually boxing up argument lists into an array when invoking methods that accept variable-length argument lists. Refer to JSR 201. <a name="static_import" />
Sample Code:
public static String format(String pattern, Object... arguments);
Static Import
This facility lets you avoid qualifying static members with class names without the shortcomings of the "Constant Interface antipattern." Refer to JSR 201. <a name="annotations" />
import static java.lang.Math.*;double r = cos(PI * theta);
Metadata (Annotations)
This language feature lets you avoid writing boilerplate code under many circumstances by enabling tools to generate it from annotations in the source code. This leads to a "declarative" programming style where the programmer says what should be done and tools emit the code to do it. Also it eliminates the need for maintaining "side files" that must be kept up to date with changes in source files. Instead the information can be maintained in the source file. Refer to JSR 175.
/** * Describes the Request-For-Enhancement(RFE) that led * to the presence of the annotated API element. */public @interface RequestForEnhancement { int id(); String synopsis(); String engineer() default ""; String date(); default ""; }
页:
[1]