Transcript Java 1.5
Java 1.5
28-Mar-16
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
Enhanced for loop
Provides all the well-known benefits of the Typesafe Enum pattern
Static import
Avoids manual conversion between primitive types (such as int) and
wrapper types (such as Integer)
Typesafe enums
Eliminates the drudgery and error-proneness of iterators
Autoboxing/unboxing
Compile-time type safety for collections without casting
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<String> words = new ArrayList<String>();
The good news:
Provides compile-time checking to make sure you are using the correct
type
No casting; instead of
String title = ((String) words.get(i)).toUppercase();
you use
String title = words.get(i).toUppercase();
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<TimerTask> c) {
for (TimerTask task : c)
task.cancel();
}
Not everyone likes this syntax!
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<String, Integer> m =
new TreeMap<String, Integer>();
for (String word : args) {
m.put(word, m.get(word) + 1);
}
Enumerations
An enumeration, or “enum,” is simply a set of constants
to represent various values
Here’s the old way of doing it
public
public
public
public
final
final
final
final
int
int
int
int
SPRING = 0;
SUMMER = 1;
FALL = 2;
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
They provide a proper name space for the enumerated type
int enums are compiled into clients, and you have to recompile clients if
you add, remove, or reorder constants.
Printed values are informative
With int enums you have to prefix the constants to get any semblance of a
name space.
They're robust
int enums don't provide any type safety at all
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!
The End