Shulou(Shulou.com)06/02 Report--

This article mainly shows you "what are the new language features in JDK1.5". The content is easy to understand and clear. I hope it can help you solve your doubts. Let me lead you to study and learn this article "what are the new language features in JDK1.5".

New language features in JDK1.5, including:

Generics in JDK1.5 (Generics)-provides compile-time type safety for collections (collections) without having to cast (cast) an object every moment from Collections

Enhanced "for" loop (Enhanced For lOOp) in JDK1.5-reducing potential errors in iterator (error-proneness)

Auto-place / Autoboxing/unboxing in JDK1.5-there is no need to manually convert between basic types (such as double) and wrapper types (such as Double).

Type-safe enumeration in JDK1.5 (Typesafeenums)-- provides the benefits of type-safe enumeration patterns.

Static import (Static import) in JDK1.5-there is no need to prefix the class name with static member variables of other classes. This will make the code more concise.

Metadata in JDK1.5 (Metadata)-allows programmers to avoid writing templated code (boiler plate code) and provides opportunities for declarative programming (declarative programming).

Let's discuss each new feature in detail and look at some examples.

◆ generics (Generics)

Generics are one of the coolest features in JDK1.5. By introducing generics, we will gain compile-time type safety and less possibility of throwing ClassCastExceptions at run time. In JDK1.5, you can declare the type of object that a collection will receive / return. In JDK1.4, creating a list of employee names (List) requires a collection object, like the following statement:

List listOfEmployeeName = new ArrayList ()

In JDK1.5, you will use the following statement

List listOfEmployeeName = new ArrayList ()

The coolest thing is that if you try to insert a value of a non-string type, you will find and fix such problems at compile time. Without generics, you will find such a bug that when your client calls it, it will tell you that your program crashes when it throws a ClassCastException exception.

In addition, you do not need to cast when you get an element from the collection. Therefore, it was originally:

String employeeName = (String) listOfEmployee.get (I))

The following statement will be simpler than the above:

String employeeName = listOfEmployee.get (I)

It is unreasonable to cast an object without knowing its type, and more importantly, it will fail at run time. What happens if the user inadvertently passes in a collection that contains a string buffers type instead of a string type. In Listing A, customers are asked to pass in a collection of strings types that the compiler cannot enforce. Listing B shows how the same method is implemented using generics.

Listing A

StaticbOOleancheckName (Collection employeeNameList, String name) {for (Iteratori = employeeNamList.iterator (); i.hasNext ();) {String s = (String) i.next (); if (s.equals (name)) {return true; / / print employee name here. }} return false;}

Listing B

StaticbooleancheckName (Collection employeeNameList, String name) {for (Iteratori = employeeNamList.iterator (); i.hasNext ();) {if (i.next (). Equals (name)) {return true; / / print employee name here. }} return false;}

Now, it is clear from the method signature that the input set must contain only strings. If a customer tries to pass in a collection that contains string buffers, the program will not compile. Also note that this method does not contain any casts. It only takes a short line, and once you get used to generics, it becomes clearer.

The For loop syntax under the current version of jdk is as follows:

Void printAll (Collection c) {for (Iteratori = c.iterator (); i.hasNext ();) {Employee emp = (Employee) i.next (); System.out.println (emp.getName ());}}

◆ implements the same method with enhanced For statements:

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

In this type of For loop, you should think of ":" as "in", so in this case it can be seen as "for Object o in c". You can find that this For loop is more readable.

◆ is automatically placed / removed in JDK1.5 (Autoboxing/unboxing)

Java has basic data types, and around these basic data types are wrapper classes. Often, programmers need to convert one type to another. Look at Listing C. The code snippet in the.

Listing C

Public class Employee {private static final Integer CHILD = new Integer (0); public static void main (String args []) {/ / code for adding n to an Integer int naphtha 10; Integer age= new Integer (30); Integer ageAfterTenYear= new Integer (age.intValue + 10);}}

Notice how messy the inner loop code used to calculate ageAfterTenYear looks. Now, in Listing D. See what the same program looks like when it is rewritten with autoboxing.

Listing D

Public class Employee {public static void main (String args []) {int naphtha 10; Integer age= new Integer (30); Integer ageageAfterTenYear= age + 10;}}

One thing to note: previously, if you unbox the Null value, it will become 0. In the secondary code, the compiler automatically converts Integer to int, then adds 10, and then converts it back to Integer.

Type safe enumeration of ◆ in JDK1.5 (Typesafeenums)

Type safety enumerations provide the following features:

They provide compile-time type safety.

They are all objects, so you don't need to put them in the collection.

They are implemented as a class, so you can add some methods.

They provide appropriate namespaces for enumerated types.

The values they print are informative-if you print an integer enumeration (intenum) and you just see a number, it may not be informative.

Example 1:

Enum Season {winter, spring, summer, fall}

Example 2:

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 of ◆ in JDK1.5 (Static import)

Static imports make the code easier to read. Typically, you use a constant (constAnts) defined in another class, like this:

Importorg.yyy.pkg.Increment; class Employee {public Double calculateSalary (Double salary {return salary + Increment.INCREMENT * salary;}})

Using static imports at that time, we didn't need to prefix the class name for the constant name to use these constants, like this:

Import static org.yyy.pkg.Increment; class Employee {public Double calculateSalary (Double salary {return salary + INCREMENT * salary;}})

Note that we can call the constant INCREMENT instead of using the class name Increment.

◆ metadata (Metadata)

The metadata feature aims to make it easier for developers to develop with the help of vendor-provided tools. Take a look at Listing E. The code in the.

Listing E

Importorg.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 () {}}

With metadata support, you can rewrite the code in Listing E as follows:

Importorg.yyy.hr; public class Employee {@ Remote public String getName () {...} @ Remote public public String getLocation () {...}}

As you can see, all the templated code is gone.

The above is all the content of the article "what are the new language features in JDK1.5". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.