Featured White Papers

• Measuring Risk to Improve Java Software Quality
• Do You Really Get Classloaders?
• Pragmatic Continuous Delivery with Jenkins, Nexus, and LiveRebel
• Your Next Java Web App: Less XML, No Long Restarts, Fewer Hassles
• Coding with JRebel, Java Forever Changed
• 2012 Developer Productivity Report: Java Tools, Tech, Devs, and Data

Sponsored Links

• Graph databases are 1000x faster than relational.

  Learn More!

• Career opportunities at Harman- Careers That'll Rock Your Socks Off.

  Learn More!

• Developer-friendly Java PDF libraries by Qoppa Software

  Live Demos

• Stop blaming your app! Diagnose Java performance issues.

  Free tool >

• UrbanCode: Go From Continuous Integration to
  Continuous Delivery

  Learn More!

Sponsored Links

Optimize with a SATA RAID Storage Solution
Range of capacities as low as $1250 per TB. Ideal if you currently rely on servers/disks/JBODs

Taming Tiger, Part 2

Understanding generics

By Tarak Modi, JavaWorld.com, 06/07/04

Page 3 of 3

   Vector<?>

Note: That code differs from Vector<Object> for the same reasons discussed above.

Roll your own parameterized type

So far we've used the built-in parameterized types in Java. Now let's look at the other side of the coin—creating parameterized types. It's fairly easy to create your own parameterized types. As an example, let's create a new class called Mammals that can store any Mammal:

class Mammals<T extends Mammal> 
{
   private Vector<T> items = new Vector<T>();
   void add(T item)
   {
      items.add(item);
      }
   T get(int index)
   {
      return items.get(index);
   }    
}

Now you can use this new class in your code, as shown in the following fragment:

// A list of dogs
Mammals<Dog> dogs2 = new Mammals<Dog>();
dogs2.add(new Dog());
dogs2.add(new Dog());
// A list of cats
Mammals<Cat> cats2 = new Mammals<Cat>();
cats2.add(new Cat());
cats2.add(new Cat());
cats2.add(new Cat());
// Assign the dogs to a generic list of mammals
Mammals<? extends Mammal> mammals = dogs2;

To support iterating through the Mammals list, I modify the class as follows:

class Mammals<E extends Mammal> extends Vector<E> 
{
}

No, I did not forget the code in the class. I extended the Vector class and inherited all the required functionality (Isn't that what object-oriented programming is all about?). Now we can iterate through the list, as shown below:

Mammals<? extends Mammal> mammals = dogs2;  
for (Mammal m: mammals)
{
   m.eat();
}
mammals = cats2;  
for (Mammal m: mammals)
{
   m.eat();
}

Generic methods

J2SE 1.5 supports generic methods. To see how such methods can be useful, let's say you wanted to create a method that took an array of Mammals and put them in a Mammals list. Here's one way of accomplishing that:

// Mammals class from earlier example
class Mammals<E extends Mammal> extends Vector<E> 
{
}
// A generic method
static <T extends Mammal> void arrayToList(T[] array, Mammals<T> list)
{
   for(T item: array)
      list.add(item);
}

Generic methods prove especially useful when new functionality to an existing parameterized class is needed and it is not possible to extend the class, or when a group of such methods are provided as common utility methods.

Conclusion

I talked at length about generics in this article. Generics are a strong addition to Java and provide a level compile-time type safety not possible in previous versions of the language. They are also used extensively within J2SE 1.5. In addition, not surprisingly, Reflection in J2SE 1.5 has also been extended to support reflecting on generic types. However, those details reach beyond the scope of this introductory article. Perhaps, if there is enough interest, I will write an article exclusively on using Reflection on generics (and a potential weakness with Java's generics implementation called erasure).

In the third and final part of this series, I will go into details about the newly introduced metadata feature in J2SE 1.5 called annotations. Annotations allow programmers to decorate Java code with their own attributes that can be used for code documentation, code generation, and, during runtime, for providing special services such as enhanced business-level security or special business logic.

About the author