Java 1.5 6-Nov-15 Reason for changes “The new language features all have one thing in common: they take some common idiom and provide linguistic.
Download ReportTranscript Java 1.5 6-Nov-15 Reason for changes “The new language features all have one thing in common: they take some common idiom and provide linguistic.
Java 1.5
28-Apr-20
Reason for changes
“The new language features all have one thing in common: they take some common idiom and provide linguistic support for it. In other words, they shift the responsibility for writing the boilerplate code from the programmer to the compiler.” --Joshua Bloch, senior staff engineer, Sun Microsystems
New features--maybe
Generics Compile-time type safety for collections without casting Enhanced for loop Eliminates the drudgery and error-proneness of iterators Autoboxing/unboxing Avoids manual conversion between primitive types (such as int ) and wrapper types (such as Integer ) Typesafe enums Provides all the well-known benefits of the Typesafe Enum pattern Static import Lets you avoid qualifying static members with class names Metadata Tools to generate boilerplate code from annotations in the source code Leads to a "declarative" programming style where the programmer says what should be done and tools emit the code to do it
Generics
A generic is a method that is recompiled with different types as the need arises The bad news: Instead of saying: List words = new ArrayList(); You'll have to say: List
Enhanced
for
loop
Instead of void cancelAll(Collection c) { for (Iterator i = c.iterator(); i.hasNext(); ) { TimerTask tt = (TimerTask) i.next(); tt.cancel(); } } You will be able to use: void cancelAll(Collection c) { for (Object o : c) ((TimerTask)o).cancel(); } Or: void cancelAll(Collection
Autoboxing
Java won’t let you use a primitive value where an object is required--you need a “wrapper” Similarly, you can’t use an object where a primitive is required--you need to “unwrap” it Java 1.5 makes this automatic: Map
Enumerations
An enumeration, or “enum,” is simply a set of constants to represent various values Here’s the old way of doing it public final int SPRING = 0; public final int SUMMER = 1; public final int FALL = 2; public final int WINTER = 3; This is a nuisance, and is error prone as well Here’s the new way of doing it: enum Season { winter, spring, summer, fall }
Advantages of the new
enum They provide compile-time type safety int enums don't provide any type safety at all They provide a proper name space for the enumerated type With int enums you have to prefix the constants to get any semblance of a name space.
They're robust int enums are compiled into clients, and you have to recompile clients if you add, remove, or reorder constants.
Printed values are informative If you print an int enum you just see a number.
Because they're objects, you can put them in collections.
Because they're essentially classes, you can add arbitrary fields and methods
New features of
enum 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 facility
import static org.iso.Physics.*; class Guacamole { public static void main(String[] args) { double molecules = AVOGADROS_NUMBER * moles; ...
} } You no longer have to say Physics.
AVOGADROS_NUMBER
Metadata
Boilerplate is code that is inserted over and over again, into many different programs The @ symbol is used to tell the compiler to fetch the code from somewhere else, and insert it It is unclear to me how else this will be used I doubt that it’s just an #insert facility
Status
Java 1.5 is due out in “late 2003” At this point, it seems highly unlikely that 1.5 will be out by the end of 2003 My description is from an “ancient” article--May 2003 It isn’t easy to find out much more than this Let’s hope for the best!