Class 25: Generics: Parameterized Types

Held: Monday, March 6, 2006

Summary: Today we consider generics in Java. Generics are a new feature of Java 1.5 that permit us to give parameters to type (class) definitions.

Related Pages:

• EBoard.
• Sample Code.

Due

• Exam 1.

Assignments

• Read Espresso: Arrays and Vectors in Java (ready this afternoon).

Notes:

• Some of you seem to have gotten quite frustrated on the exam, and for that I apologize. I'd rather give you challenges than easy stuff.
• Sample solutions will be available. I hope to return the exam a week from tomorrow.
• I brought back a few gifts from my trip.

Overview:

• A problem: Swapping.
• A solution.
• Improving the solution.
• Generics: Improving the new solution.
• Comparisons.

A Problem: Swapping Values

• Suppose we want to swap the values of variables a and b (of the same type).
• If we've declare a variable, tmp of the same type we can write

  tmp = a;
  a = b;
  b = tmp;
  

• If we write that code enough, we'd like to turn it into a procedure.
• But we can't. Putting the code in a method fails.

An Initial Solution

• What we'd really like to do is have getValue and setValue methods that permit us to do something like the following

  tmp = a.getValue();
  a.setValue(b.getValue());
  b.setValue(tmp);
  

• That will work for the classes we write, but not for built-in classes, like Integer
• We can wrap those classes in our own classes,

  public class IntegerVariable
  {
    Integer value;
    public IntegerVariable(Integer _value)
    {
      this.value = _value;
    } // IntegerVariable(Integer)
    public void setValue(Integer newvalue)
    {
      this.value = newvalue;
    } // setValue(Integer)
    public Integer getValue()
    {
      return this.value;
    } // getValue()
    public void swap(IntegerVariable other)
    {
      Integer tmp = this.value;
      this.setValue(other.getValue());
      other.setValue(tmp);
    } // swap(IntegerVariable other)
  } // class IntegerVariable
  

• But there are problems with this solution.
  • We have to write an XXXVariable class for every class XXX

Improving the Solution with Polymorphism

• Write a more generic variable that just stores objects.

  public class Variable
  {
    Integer value;
    public Variable(Object _value)
    {
      this.value = _value;
    } // Variable(Object)
    public void setValue(Object newvalue)
    {
      this.value = newvalue;
    } // setValue(Object)
    public Object getValue()
    {
      return this.value;
    } // getValue()
    public void swap(Variable other)
    {
      Object tmp = this.value;
      this.setValue(other.getValue());
      other.setValue(tmp);
    } // swap(Variable other)
  } // class Variable
  

• This works, in general, but it loses some of the nice type checking in Java. For example, we can swap create a variable intended to store integers and a variable intended to store strings, and accidentally swap the two.
• You also have to do a lot of casting.

Generics to the Rescue

• Java generics (introduced in Java 1.5) provide a better solution. We can write a class and parameterize it with a type.
• A parameterized class is followed by <type-variables>
• For example, Variable<T&*gt;
• We can then use T anywhere we want in the code.

  public class Variable<T>
  {
    Integer value;
    public Variable(T _value)
    {
      this.value = _value;
    } // Variable(T)
    public void setValue(T newvalue)
    {
      this.value = newvalue;
    } // setValue(T)
    public T getValue()
    {
      return this.value;
    } // getValue()
    public void swap(Variable<T> other)
    {
      T tmp = this.value;
      this.setValue(other.getValue());
      other.setValue(tmp);
    } // swap(Variable<T> other)
  } // class Variable<T>
  

• When we create one of these things, we supply the type.
• For example,

  Variable<Integer> ivar = new Variable<Integer>(new Integer(2));
  Variable<String> svar = new Variable<String>("Hello");
  

Comparing Values

• That's why we use the interface Comparable<T>.
• Java also supplies Comparator<T>.
• Consider max.