Java 5

This page describe the major new features added in Java 5.

Annotations (Metadata)

avoids need for external configuration files, allowing configuration data to be embedded in source files

avoids duplicated boilerplate code by enabling tools to generate it from annotations in source code

leads to a declarative programming style

an example of a specific annotation added in Java 5 is @Override which marks a method that overrides a superclass method

for more information, see here

Autoboxing/Unboxing

avoids need to convert between primitives and their corresponding type wrapper objects

basic example

int i = 19;
Integer iObj = i;
int j = iObj;
// i and j are equal

collections example

List<Integer> list = new ArrayList<Integer>(); // see "Generics"
int i = 19;
list.add(i);
int j = list.get(0);
// i and j are equal

overuse can result in performance issues

for more information, see here

Enhanced For Loop

array example

  Car[] cars = new Car[](5);
  // populate array of Car objects
  for (Car car : cars) {
    // Use the variable car inside the loop.
  }

list example

  List<Car> cars = new ArrayList<Car>() // see "Generics"
  // populate List of Car objects
  for (Car car : cars) {
    // Use the variable car inside the loop.
  }

for more information, see here

Enums

can create enumerated types with arbitrary fields and methods

example

  enum Season { WINTER, SPRING, SUMMER, FALL }
  Season season = SPRING;
  for (Season season : Season.values()) {
    // use season variable
  }

to get the integer value of an enumerated value, invoke the ordinal method on it

for more information, see here (includes an example of adding fields and methods to enums)

Generics

most often used for type-safe collections

example

  List<String> myList = new ArrayList<String>();
  // only String objects can be added to myList.

collections of subclass objects can be passed to methods that accept collections of superclass objects (for example, an object of type List<Dog> can be passed to a method that accepts List<? extends Animal> or even List<? extends Object>)

for more information, see here

Static Import

avoids the need to qualify static members of classes or interfaces with the class or interface name

example from JUnit 4

  import static org.junit.Assert.*;
  // can now use static assert methods from the Assert class
  // without prefixing them with "Assert."

note that the ".*" part says to import all the static members from the Assert class (can't omit that!)

for more information, see here

Varargs

eliminates the need to put arguments into an array for the purpose of passing a variable number of arguments to a method

example

  public void washCars(Car... cars) {
    for (int i = 0; i < cars.length; i++) {
      Car car = cars[i];
      // wash the car
    }
  }

  // call like this
  washCars(car1, car2, car3);

the type of cars is Car[]

for more information, see here