by May 4, 2006 0 comments

Java programming language has matured tremendously over the
years. It has been able to safeguard against common programming pitfalls such as
array bounds checking, exception handling, memory leaks, dangling references
etc. But, there are still some lacunas in the language, such as typecasting and

excessive use of deployment descriptors (DD), which are processed independently
from the source code. In this article, we’ll look at two popular features
namely Generics and Annotations introduced in Java SE 5 (aka Tiger) to catch
bugs early and drive agile development. Catching bugs early helps in preventing
their propagation in the later stages of the development cycle.

Applies to:
Java SE/EE developers
Ensure compile-time type safety with Tiger
Google keywords:
Generics, annotations

A date with common programming bugs Java collection offers
excellent data structure support, and  is used to hold heterogeneous
objects, where the elements may have any reference type. Some common programming
bugs lead to ugly ClassCastException. For instance, when you add an integer to a
vector, while extracting the collection, an object is

returned that must be explicitly cast to an integer in order to

ensure type safety.

Vector v = new Vector();
v.add(new Integer(1));
Integer num = (Integer) v.get(0);

This kind of programming style makes it difficult to read
and maintain the code. Down casting is often the cause of errors as shown below.

class Facade{
//application logic
class MVC_View{
//client view

. . . .

Vector v = new Vector();
// Add an object of type Facade
v.add(new Facade());

// extract the object back
MVC_View b = (MVC_View) v.get(0);

Although the above code snippet compiles fine but at
runtime, it throws ClassCastException.

Generics to the rescue
Generics provide compile-time type safety and eliminate the need for casts.
With Generics, errors are flagged where they occur, and not later at run time.
Parametric types (eg vector, hashtable) provide an elegant way to implement
generic-utility classes that alleviates the need to cast and allow errors to be
caught at compile time. As shown in the following code snippet, with Generics,
you no longer have to keep track of what types of objects your collection

Vector v = new

int num = v.get(0);

The code snippet above uses another feature called
autoboxing introduced in Tiger. If you were to assign an extracted

element to a different type, the error would be caught at compile-time instead
of run-time.

This early static checking increases the type safety.
Here’s another example that demonstrates how Generics can catch some potential
bugs at the compile time. This code segment will result in compilation error.

Vector v = new
// Add an object of type Facade
v.add(new Facade());
// extract the object back
MVC_View b = (MVC_View) v.get(0);

Metadata meets Java
Metadata is data about data. It is useful in compile-time checking and code
analysis and does not directly affect the

semantics of a program. Development and deployment tools can inspect these
annotations and process them in some fashion and may produce additional source
files, such as XML documents, or other artifacts. Java SE5 lets the developer
use metadata in source code to include special directives. Lets now see how we
can put it to use.

Decorate your code with annotations
The metadata feature introduced in Java SE 5 is Annotations. With
Annotations, developers can dress their code to provide

documentation, code generation, and deliver container services to POJOs. Here
we’ll explore some built-in annotations in Tiger. The first built-in
annotation type is Override. It indicates that the annotated method is
overriding a method in a superclass, and, it can only be applied to methods as
shown below.

public class TestOverride {

  public String toString() {
    return super.toString() + ” Testing Override
  public int hashCode() {
    return toString().hashCode();


If a method marked with Override annotation does not
override its super-class’s method, the compiler will generate an error.

Next, we’ll look at another marker annotation called
Deprecated. Like other deprecated methods, a method marked with this annotation
should not be used and the compiler flags a warning if such method is called.


public class
TestDeprecatedAnnotation {

   public static
void main(String arg[])  {

new TestDeprecatedAnnotation();


TestDeprecatedAnnotation() {

t=new TestDeprecated();



Delivering container services to POJOs
The real power of annotations can only be realized if one looks into the EJB 3.0
specification. With EJB 3.0, business components are developed as POJOs (Plain
Old Java Objects), and developers can use metadata annotations to specify to the
container how these beans are to be managed. With the new EJB 3.0 specification,
there’s no need of boilerplate code, and DD (Deployment

Descriptors) are optional. Thanks to annotations, EJB 3.0
decreases the number of  programming artifacts that the developers need to

and eliminates/minimizes callback methods required to be implemented.
Annotations can be used to define the bean’s business interface, O/R mapping
information, and inject dependencies at runtime. The following code snippet
shows how annotations help in simplifying the EJB development


@Stateless public class HellodBean {
public String sayHello(String s){
System.out.println(“Hello: “+s; }

It can’t get simpler than this. You no longer need to
implement the javax.ejb.SessionBean interface or define separate remote (or
local) and home interface.

Even if you explicitly define one, it can be a POJI (Plain
Old Java Interface) called business interface, and, need not extend to EJBObject
or EJBLocalObject. If you do not implement an interface, a bean interface will
be generated for you. The type of generated interface, either local or remote,
is dependent on the annotation you used in the bean class. All the public
methods of the bean class will be included as part of the automatically
generated business interface.

Further, now there is no ejb-jar.xml DD required. XML files
can express complex relationships, but they are also quite verbose and less
robust. Annotations, on the other hand, are simple and concise. XML based DD
files are optional in EJB 3.0 and can be used to override annotation behavior.

Tiger is believed to be the biggest leap forward in Java

programming with significant extensions to the language syntax. Advanced
features such as auto-boxing and un-boxing of primitives, static imports,
variable method arguments, and enumerations are now supported.

Reflection in Java SE 5 has also been extended to support

reflecting on generic types.

In addition to using generic types, you can implement your
own types. Annotations are driving the next wave in agile

development. You can define your own custom application

specific annotations. Annotations alleviate boilerplate code and XML documents,
resulting in much cleaner and readable code. 

Kunal Jaggi

No Comments so far

Jump into a conversation

No Comments Yet!

You can be the one to start a conversation.