Object-Oriented Programming with Java Lecture Notes

27 March 2008 • Advanced Generics

Outline

• Generic methods.

• Mixing new and old code.

Remember This?

• Write a method that accepts an arbitrary mailbox as a parameter.

  • Use a wildcard generic parameter.

    void lock(Mailbox<?> mb) { ... }
    

  • Read-only access to mb's generic references.

• Another way to write the method is use generics.

Generic Methods

• A generic method is a method with declared type variables.

  • The declaration precedes the return type.

  <T> void lock(Mailbox<T> mb) { ... }
  

  • The type variables behave in the generic method as they do in the generic class.

  <T> void lock(Mailbox<T> mb)
    T letter = mb.get();
  

Calling Generic Methods

• Actual types are supplied before the method call.

  • This requires dot notation.

  Mailbox<blob> bmb = new Mailbox<blob>()
  Mailbox<spot> smb = new Mailbox<spot>()
  
  <blob>lock(bmb)  // syntax error
  <spot>lock(smb)  // Syntax error
  
  this.<blob>lock(bmb)
  this.<spot>lock(smb)
  

Type Inference

• The Java compiler can (usually) use type inference to find the type variables itself.

  lock(bmb)  // T is blob.
  lock(smb)  // T is spot.
  

  • Sometimes type inferencing fails, usually due to casting.

  • Infrencing failures require explicit type assignment.

• As in C++, type infrencing is the source of useful tricks.

Generic Classes and Methods

• Generic classes and methods are indpenendent of one another.

  • Generic classes may or may not have generic methods.

  • Generic methods may or may not appear in generic classes.

  • Generic methods in generic classes may or may not be independent of one-another.

Generic-Method Mutation

• Generic methods can write their generic parameters.

  <T> addIfEmpty(Mailbox<T> mb, T letter)
    T letter = mb.get()
    if letter == null
      mb.put(letter)
      return null
    return letter
  

• Note that T still can't appear in a new expression.

  mb.put(new T())
  

  • Erasure is still going on.

Old Code

• Code written prior to Java 1.5 doesn't have generics.

  • That is, it may rely on object-based polymorphism.

  • Java 1.5 warns against that sort of thing.

• A reminder:

  Stack stringStk = new Stack()
  stringStk.push(new Object())
    // Could be dangerous.
  String str = (String) stringStk.pop()
    // It is! Boom!
  

Example

$ cat j.java
import java.util.Stack;

class t {
  void moo() {
    Stack intStk = new Stack();
    intStk.push(new Integer(1));
    }
  }

$ javac j.java
Note: j.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

$ javac -Xlint:unchecked j.java
j.java:6: warning: [unchecked] unchecked call to push(E) 
as a member of the raw type java.util.Stack
    intStk.push(new Integer(1));
               ^
1 warning

$ 

Unchecked Warnings

• Once a generic instance is passed through uncheck code, the run-time safety guarantee no longer applies.

• Unchecked warnings can either be fixed or ignored.

  • Fixing is better, but maybe not possible.

  • Unfortunately, fixing large, involved classes is tricky.

• Consider passing generic-instance clones as parameters to untrusted code.

Rewriting Old Code

• If possible, rewrite the old code to use generics.

  • Restores the run-time safety guarantee and simplifies code.

  import java.util.Stack
  
  void moo()
    Stack<Integer> intStk = 
      new Stack<Integer>()
    intStk.push(new Integer(1))
  

• Only works if you can change the source.

Ignoring Unchecked Warnings.

• It may be the warnings are harmless and can be safely ignored.

  void swap(Stack stk)
    if stk.size() > 1
      final Object e1 = stk.pop()
      final Object e2 = stk.pop()
      stk.push(e1)  // warning
      stk.push(e2)  // warning
  

• In that case use the @SuppressWarnings("unchecked") annotation.

Example

$ cat j.java
class s
  @SuppressWarnings("unchecked")
  void quiteSwap(Stack quietStk)
    Object e1 = quietStk.pop()
    Object e2 = quietStk.pop()
    quietStk.push(e1)
    quietStk.push(e2)

  void noisySwap(Stack noisyStk)
    Object e1 = noisyStk.pop()
    Object e2 = noisyStk.pop()
    noisyStk.push(e1)
    noisyStk.push(e2)

$ javac -Xlint:unchecked j.java
j.java:18: warning: [unchecked] unchecked call to push(E) 
as a member of the raw type java.util.Stack
      noisyStk.push(e1);
                   ^
j.java:19: warning: [unchecked] unchecked call to push(E) 
as a member of the raw type java.util.Stack
      noisyStk.push(e2);
                   ^
2 warnings

$ 

Ignoring Unchecked Warnings..

• Compile old code as old code using the -source javac command-line option.

  $ cat j.java
  class s
    void swap(Stack stk)
      Object e1 = stk.pop()
      Object e2 = stk.pop()
      stk.push(e1)
      stk.push(e2)
  
  $ javac -Xlint -source 1.4 j.java
  
  $