【JAVA系列】Java8、Java7、Java5新特性

Java Programming Language Enhancements

Enhancements in Java SE 8

• Lambda Expressions enable you to encapsulate a single unit of behavior and pass it to other code. You can use a lambda expressions if you want a certain action performed on each element of a collection, when a process is completed, or when a process encounters an error. Lambda expressions are supported by the following features:

  • Method References are compact, easy-to-read lambda expressions for methods that already have a name.

  • Default Methods enable you to add new functionality to the interfaces of your libraries and ensure binary compatibility with code written for older versions of those interfaces. They are interface methods that have an implementation and the default keyword at the beginning of the method signature. In addition, you can define static methods in interfaces.

  • New and Enhanced APIs That Take Advantage of Lambda Expressions and Streams in Java SE 8 describe new and enhanced classes that take advantage of lambda expressions and streams.

• Improved Type Inference - The Java compiler takes advantage of target typing to infer the type parameters of a generic method invocation. The target type of an expression is the data type that the Java compiler expects depending on where the expression appears. For example, you can use an assignment statement’s target type for type inference in Java SE 7. However, in Java SE 8, you can use the target type for type inference in more contexts. The most prominent example is using a method invocation’s target types to infer the data types of its arguments.

  Consider the following example:

  List<String> stringList = new ArrayList<>();
  stringList.add("A");
  stringList.addAll(Arrays.asList());
  

  Disregarding generics for the moment, the method addAll expects a Collection instance as its argument, and the method Arrays.asList returns a List instance. This works because List is a subtype of Collection.

  Now considering generics, the target type of addAll is Collection<? extends String>, and Arrays.asList returns a List instance. In this example, the Java SE 8 compiler can infer that the value of the type variable T is String. The compiler infers this from the target type Collection<? extends String>.

  Compilers from Java SE 7 and earlier do not accept this code because they do not use target typing to infer types for method call arguments. For example, the Java SE 7 compiler generates an error message similar to the following:

  error: no suitable method found for addAll(List<Object>) ...
  method List.addAll(Collection<? extends String>) is not applicable (actual argument List<Object> cannot be converted to Collection<? extends String> by method invocation conversion)
  

  Consequently, in situations like this where the Java compiler cannot infer types, you must explicitly specify values for type variables with type witnesses. For example, the following works in Java SE 7:

  List<String> stringList = new ArrayList<>();
  stringList.add("A");
  stringList.addAll(Arrays.<String>asList());
  

  See the following sections in the Java Tutorials for more information:

  • Target Typing in Lambda Expressions

  • Type Inference

• Annotations on Java Types - It is now possible to apply an annotation anywhere a type is used. Used in conjunction with a pluggable type system, this allows for stronger type checking of your code. For more information, see Type Annotations and Pluggable Type Systems in the new Annotations lesson in the Java Tutorial.

• Repeating Annotations - It is now possible to apply the same annotation type more than once to the same declaration or type use. For more information, see Repeating Annotations in the new Annotations lesson in the Java Tutorial.

• Method Parameter Reflection - You can obtain the names of the formal parameters of any method or constructor with the method java.lang.reflect.Executable.getParameters. (The classes Method and Constructor extend the class Executable and therefore inherit the method Executable.getParameters.) However, .class files do not store formal parameter names by default. To store formal parameter names in a particular .class file, and thus enable the Reflection API to retrieve formal parameter names, compile the source file with the -parameters option of the javac compiler. See Obtaining Names of Method Parameters in the Java Tutorials.

Enhancements in Java SE 7

• Binary Literals - In Java SE 7, the integral types (byte, short, int, and long) can also be expressed using the binary number system. To specify a binary literal, add the prefix 0b or 0B to the number.
• Underscores in Numeric Literals - Any number of underscore characters (_) can appear anywhere between digits in a numerical literal. This feature enables you, for example, to separate groups of digits in numeric literals, which can improve the readability of your code.
• Strings in switch Statements - You can use the String class in the expression of a switch statement.
• Type Inference for Generic Instance Creation - You can replace the type arguments required to invoke the constructor of a generic class with an empty set of type parameters (<>) as long as the compiler can infer the type arguments from the context. This pair of angle brackets is informally called the diamond.
• Improved Compiler Warnings and Errors When Using Non-Reifiable Formal Parameters with Varargs Methods - The Java SE 7 complier generates a warning at the declaration site of a varargs method or constructor with a non-reifiable varargs formal parameter. Java SE 7 introduces the compiler option -Xlint:varargs and the annotations @SafeVarargs and @SuppressWarnings({“unchecked”, “varargs”}) to suppress these warnings.
• The try-with-resources Statement - The try-with-resources statement is a try statement that declares one or more resources. A resource is an object that must be closed after the program is finished with it. The try-with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements the new java.lang.AutoCloseable interface or the java.io.Closeable interface can be used as a resource. The classes java.io.InputStream, OutputStream, Reader, Writer, java.sql.Connection, Statement, and ResultSet have been retrofitted to implement the AutoCloseable interface and can all be used as resources in a try-with-resources statement.
• Catching Multiple Exception Types and Rethrowing Exceptions with Improved Type Checking - A single catch block can handle more than one type of exception. In addition, the compiler performs more precise analysis of rethrown exceptions than earlier releases of Java SE. This enables you to specify more specific exception types in the throws clause of a method declaration.

Enhancements in Java SE 6

No language changes were introduced in Java SE 6.

Enhancements in Java SE 5.0

• Generics - 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. See the Generics lesson in the Java Tutorials. (JSR 14)
• Enhanced for Loop - This new language construct eliminates the drudgery and error-proneness of iterators and index variables when iterating over collections and arrays. (JSR 201)
• Autoboxing/Unboxing - This facility eliminates the drudgery of manual conversion between primitive types (such as int) and wrapper types (such as Integer). (JSR 201)
• 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. (JSR 201)
• Varargs - This facility eliminates the need for manually boxing up argument lists into an array when invoking methods that accept variable-length argument lists.
• Static Import - This facility lets you avoid qualifying static members with class names without the shortcomings of the “Constant Interface antipattern.” (JSR 201)
• Annotations (Metadata) - 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. (JSR 175)
  NOTE: The @Deprecated annotation provides a way to deprecate program elements. See How and When To Deprecate APIs.

Generics papers

• JSR14: Adding Generic Types to the Java Programming Language
  • Generics lesson in the Java Tutorials
  • Earlier public review draft specification from Java Community Process
• Making the Future Safe for the Past: Adding Genericity to the Java Programming Language (PDF)
  Bracha, Odersky, Stoutamire, and Wadler. OOPSLA 98, Vancouver, October 1998. ( other formats)
• GJ: Extending the Java Programming Language with Type Parameters (PDF)
  Bracha, Odersky, Stoutamire, and Wadler. A tutorial on GJ. August 1998. ( other formats)
• Adding Generics to the Java Programming Language (PDF)
  Bracha. Slides from JavaOne 2003 presentation.
• Adding Wildcards to the Java Programming Language (PDF)
  Torgersen, Hansen, Ernst, Ahe, Bracha and Gafter. An ACM paper, 2004.

Enhancements in J2SE 1.4

• Assertion Facility - Assertions are boolean expressions that the programmer believes to be true concerning the state of a computer program. For example, after sorting a list, the programmer might assert that the list is in ascending order. Evaluating assertions at runtime to confirm their validity is one of the most powerful tools for improving code quality, as it quickly uncovers the programmer’s misconceptions concerning a program’s behavior.

参考

https://docs.oracle.com/javase/8/docs/technotes/guides/language/enhancements.html

https://docs.oracle.com/en/java/javase/index.html