Java Generics v1.5

[Josh Juneau]

Does anyone have a good example using Generics? I've read a couple of articles about the use of generics, but I haven't really found any great examples.

Thanks in advance-

Josh

[Gregg Bolinger]

I bet Herb's Book has some good examples. There is also a nice simple example showing the difference between 1.4 and 5 at the very beginning of this thread.

[Layne Lund]

Look at the other threads in this forum. Generics have been discussed and argued about in great detail over the past two days. The other threads on this topic have examples and links to more.

HTH

Layne

[Herb Schildt]

Josh:

First, my book has in-depth coverage of generics. In fact, the generics chapter is nearly 50 pages long. There is a lot to generics, far more than one or two examples can show.

That said, here is a very simple example that shows how to create a generic class and create an object of that class. Pay close attention to the new syntax elements.

// A very simple generic class. 
// Here, T is a type parameter that
// will be replaced by a real type
// when an object of type Gen is created.
class Gen<T> {
  T ob; // declare an object of type T
  
  // Pass the constructor a reference to 
  // an object of type T.
  Gen(T o) {
    ob = o;
  }
 
  // Return ob, which is of type T.
  T getob() {
    return ob;
  }
}
 
// Demonstrate the generic class.
class GenDemo {
  public static void main(String args[]) {
    // Create a Gen reference for Integers. 
    Gen<Integer> iOb; 
 
    // Create a Gen<Integer> object and assign its
    // reference to iOb.  Notice the use of autoboxing 
    // to encapsulate the value 88 within an Integer object.
    iOb = new Gen<Integer>(88);
 
    // Get the value in iOb. Notice that
    // no cast is needed.  The type is already known.
    int v = iOb.getob();
    System.out.println("value: " + v);
 
    System.out.println();
 
    // Create a Gen object for Strings.
    Gen<String> strOb = new Gen<String>("Generics Test");
 
    // Get the value of strOb. Again, notice
    // that no cast is needed.
    String str = strOb.getob();
    System.out.println("value: " + str);
  }
}

The output produced is shown here.

value: 88

value: Generics Test

The key point is that the Gen class is generic. Its type parameter is T, which is a placeholder for the real type that will be known when an object of type Gen is instantiated. Thus, Gen<Integer> creates an Gen reference in which Integer is substituted for T. Gen<String> creates a reference in which String is substituted for T. (Actually, the process used by the Java generics system is type erasure, not substitution, but conceptually that is how it appears to the programmer.) Most importantly, these types are enforced by the compiler.

For example, assuming the preceding program, this line will not compile because of a type mismatch error.

iOb = new Gen<Double>(88.0); // error!

In the program, iOb is of type Gen<Integer>. Because of this, it can't be assigned a reference to a Double object. This is a key feature of generics: type safety.

Josh, frankly, there is a whole lot more to generics than this simple example shows, but it gives you a look at the basic syntax.

Here are other important features of generics: bound types, wildcards, raw types, erasure, bridge methods, and potential ambiguity.