New features in jdk 1 5
1 / 22

New features in JDK 1.5 - PowerPoint PPT Presentation

  • Updated On :

New features in JDK 1.5. Can these new and complex features simplify Java development?. [email protected] Generic Types Auto-boxing/unboxing Enhanced For Loop Enumerations Variable Arguments Static Import Meta-data. Formatted I/O Concurrency Utilities Management Utilities

Related searches for New features in JDK 1.5

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'New features in JDK 1.5' - PamelaLan

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
New features in jdk 1 5 l.jpg

New features in JDK 1.5

Can these new and complex features simplify Java development?

[email protected]

Overview l.jpg

Generic Types


Enhanced For Loop


Variable Arguments

Static Import


Formatted I/O

Concurrency Utilities

Management Utilities

Class Data Sharing

Loads of other improvements


Reasoning l.jpg

"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

Complementary features l.jpg
Complementary Features

  • Generics improve enhanced for loop

  • Generics and auto-boxing/unboxing allow Enumerated types

  • Variable args improve API usability

  • Variable args allow formatted I/O

New features enhance existing api l.jpg
New features enhance existing API

  • Generics enhance compile time type checking

  • Generics improve reflection

  • Generics allow return type overriding

  • Enum improves readability and organization of constants

  • Static import improves utility functions

  • Auto-boxing improves readability

Generic types l.jpg
Generic Types

interface Collection <E> {

boolean add(E o);

boolean addAll(Collection<? extends E> c);

Iterator<E> iterator();

<T> T[] toArray(T[] a);


Generic interface or class l.jpg
Generic Interface (or Class)

interface Collection <E> …

Collection<Integer> integers;

E is the type parameter for the generic type

Collection is the raw type after type erasure

Integer is the actual type parameter used when declaring an instance of the generic type

Cannot use primitive types but auto-boxing covers over the difference

Using the type parameter l.jpg
Using the Type Parameter

boolean add(E o);

Where ever E is used, the compiler will check the type against the actual type parameter. At runtime E will be Object.

Wildcard parameters l.jpg
Wildcard Parameters

boolean addAll(Collection<? extends E> c);

? represents an unknown type

List<?> list = new ArrayList<String>();

Not legal:

List<Object> list = new ArrayList<String>();

Would allow list.add( new Object() );

Bounded type parameters l.jpg
Bounded Type Parameters

boolean addAll(Collection<? extends E> c);

Constrains possible actual types

An actual type must be same as E or extend E

Can also constrain to implement multiple interfaces

Parameterized methods l.jpg
Parameterized Methods

<T> T[] toArray(T[] a);

Infers the actual type from the actual parameter passed to the method.

Type erasure l.jpg
Type Erasure

  • Insures backwards compatibility

  • Avoids bloat ala C++ templates

  • Type information still available through reflection

Small example l.jpg
Small Example

public static void main ( String... args ) {

Collection<String> strs = new ArrayList<String>();

for ( String s : args )

strs.add( s );

Collection<?> readonly = new ArrayList<String> ( strs );

//readonly.add( "some string" ); Not allowed

Collection<String> copy = new ArrayList<String> (strs);

String[] strAry = strs.toArray( new String[] {} );


Auto boxing unboxing l.jpg

List<Integer> ints = new ArrayList<Integer>();

ints.add( 1 ); // auto-boxing to new Integer( 1 )

ints.add( 2 );

ints.add( 3 );

for ( int num : ints ) // Auto-unboxing using obj.intValue()

System.out.println( num );

Enhanced for loop foreach l.jpg
Enhanced for loop (foreach)

  • Improves readability

  • Reduces boilerplate code

  • Works with both arrays and objects that expose an iterator

Enumerated types l.jpg
Enumerated Types

  • Collects related constants into own namespace

  • Codifies the type-safe enum idiom

  • Can have constructors, fields and methods

  • Can subclass

  • Works well with switch statements

  • Adds enum keyword to language. May require source changes before compiling with 1.5 compiler. Existing classes should still work.

Enum example l.jpg
Enum example

enum Suit {clubs, diamonds, hearts, spades}

enum Rank {deuce, three, four, five, six, seven,

eight, nine, ten, jack, queen, king, ace}

List<Card> deck = new ArrayList<Card>();

for (Suit suit : Suit.VALUES)

for (Rank rank : Rank.VALUES)

deck.add(new Card(suit, rank));


Switch with enum l.jpg
Switch with Enum

Color getColor( Suit suit ) {

switch( suit ) {

case clubs:

case spades: return Color.Black;

case diamonds:

case hearts: return Color.Red;

default: throw new AssertionError( suit + “ not valid value” );



Variable arguments l.jpg
Variable Arguments

String format( String format, Object... args );

format(“{2} {1}!”, “World”, “Hello”);

  • Nicer way to call a method that takes an array of some type

  • Class…means Class[] inside of the method

  • Use the enhanced for loop to iterate

Static import l.jpg
Static Import

import static java.lang.math.*;

int themax = max( 123123, 23475 );

  • Reduces typing

  • Alleviates need for implementing a Constant Interface

  • Compiler error if names clash

Meta data l.jpg

  • Available at compile-time or runtime with reflection

  • Similar concept to XDoclet tags or .Net attributes

  • @deprecated and @overrides are standard

References l.jpg

Java Generics Tutorial

J2SE 1.5 in a Nutshell

A Conversation with Joshua Bloch

What's new in J2SE 1.5's_new_in_J2SE_1.5

David Flanagan Web log