Trying to pick them apart in previous weblogs and in the chapter, I finally realized that each example of generics that you see is usually comprised of multiple use cases, which can make them confusing to learn from. So I've started a list of use cases, where I try to focus on only one issue of generics for each item in the list.

What I'm hoping you will do is to look over this list and see if there are any (A) improvements and (B) additions that you can make. The resulting list will not only ensure that I cover everything in the chapter, but I think it will make a very nice summary of generic issues.

Thanks for your help.

import java.util.*;

// 1. Just want to call a specific method inside your 
// code. (You don't need generics for this; just pass
// the class or interface directly).

interface MyInterface1 { void method(); }

class CallMethod {
  void call(MyInterface1 mi) { mi.method(); }
}

// 2. Return a specific type, rather than a base type:

interface MyInterface2<T> {
  T returnMySpecificType();
  // ...
}

class Pet {}
class Dog extends Pet {}
class Waffle {}

class MI2Test1 implements MyInterface2<Pet> {
  public Pet returnMySpecificType() { return new Pet(); }
}

class MI2Test2 implements MyInterface2<Dog> {
  public Dog returnMySpecificType() { return new Dog(); }
}

class MI2Test3 implements MyInterface2<Waffle> {
  public Waffle returnMySpecificType() {
    return new Waffle();
  }
}

// 3. Constrain the use of (2):

interface MyInterface3<T extends Pet> {
  T returnMySpecificType();
  // ...
}

class MI3Test1 implements MyInterface3<Pet> {
  public Pet returnMySpecificType() { return new Pet(); }
}

class MI3Test2 implements MyInterface3<Dog> {
  public Dog returnMySpecificType() { return new Dog(); }
}

// Error: type parameter Waffle is not within its bound:
/*! 
class MI3Test3 implements MyInterface3<Waffle> {
  public Waffle returnMySpecificType() {
    return new Waffle();
  }
} */

// 4. Pass a generic class into a method:

class GenericUseCases4 {
  static <T> T method(List<T> list, T item) {
    // Modify the list:
    list.remove(1);
    list.clear();
    // Can call a method that takes a T argument:
    list.add(item);
    // Can call a method that returns a T argument:
    return list.get(0);
  }
  static void test() {
    method(new ArrayList<Integer>(), 1);
  }
}

// 5. Constrained form of the above:

class GenericUseCases5<U> {
  <T extends U> T method(List<T> list, T item) {
    // Modify the list:
    list.remove(1);
    list.clear();
    // Can call a method that takes a T argument:
    list.add(item);
    // Can call a method that returns a T argument:
    return list.get(0);
  }
  static void test() {
    new GenericUseCases5<Number>().method(
      new ArrayList<Integer>(), 1);
  }
}

// 6. Pass a generic class or a class holding a subtype:

class GenericUseCases6 {
  <T> T method(List<? extends T> list, T item) {
    // Modify the list:
    list.remove(1); // (Method with a non-T argument)
    list.clear();
    // Cannot call a method that takes a T argument:
    //! list.add(item);
    // Error message: cannot find symbol  : method add(T)
    // Can call a method that returns a T argument:
    return list.get(0);
  }
}

// 7. Loosen constraints but still write to the list:

class GenericUseCases7 {
  <T> void method(List<? super T> list, T item) {
    // Modify the list:
    list.remove(1);
    list.clear();
    // Can call a method that takes a T argument:
    list.add(item);
    // Requires an unsafe cast for a T return value:
    T x = (T)list.get(0);
    // Warning: uses unchecked or unsafe operations
  }
}

// 8. Simplify usage with type inference:

class GenericUseCases8<T> {
  private T type;
  public GenericUseCases8(T type) {
    this.type = type;
  } 
  public static <T> GenericUseCases8<T> inferType(T t) {
    return new GenericUseCases8<T>(t);
  }
  static void test() {
    GenericUseCases8<Waffle> w = inferType(new Waffle());
  }
}

// 9. Utilize capture conversion:

class GenericUseCases9 {
  public static void captureType(List<?> list) {
    explicitType(list);
  } 
  private static <T> void explicitType(List<T> list) {
    // ...
  }
  static void test() {
    captureType(new ArrayList<Waffle>());
  }
}

void captureType( List< ? > list )
 
< T > void explicitType( List< T > list )

List< ? > l = new ArrayList< Integer >; // OK
< T > List< T > l = new ArrayList< Integer >; // Error

interface Prototype< T extends Prototype > {
    T instance();
    T[] array( int size );
    // etc.
}
 
class ArrayListP< E extends Prototype< E > > extends AbstractList< E > {
    private final E[] values;
    ArrayListP( final E prototype, final int size ) {
        values = prototype.array( size );
        for ( int i = 0; i < size; i++ ) values[ i ] = prototype.instance();
    }
    public E get( final int index ) { return values[ index ]; }
    public int size() { return values.length; }
}
 
class PInteger implements Prototype< PInteger > {
    public int value;
    public PInteger instance() { return new PInteger(); }
    public PInteger[] array( final int size ) { return new PInteger[ size ]; }
}
 
public class Main {
    public static void main( final String[] notUsed ) {
        final PInteger pi = new PInteger();
        final ArrayListP< PInteger > pil = new ArrayListP< PInteger >( pi, 2 );
        out.println( pil );
    } 
}

class ArrayListC< E > extends AbstractList< E > {
    private final E[] values;
    ArrayListC( final Class< E > prototype, final int size ) throws InstantiationException, IllegalAccessException {
        values = (E[])newInstance( prototype, size ); // ignore unchecked warning
        for ( int i = 0; i < size; i++ ) values[ i ] = prototype.newInstance();
    }
    public E get( final int index ) { return values[ index ]; }
    public int size() { return values.length; }
}
 
public class Main {
    public static void main( final String[] notUsed ) throws InstantiationException, IllegalAccessException {
        final ArrayListC< Object > col = new ArrayListC< Object >( Object.class, 2 );
        out.println( col );
    } 
}

public abstract class Shape
 {
 public abstract void draw(Canvas c);
 }
 
public class Circle extends Shape 
 
{
 private int x, y, radius;
public void draw(Canvas c) { ... }
}
 
public class Rectangle extends Shape
 
{
 private int x, y, width, height;
public void draw(Canvas c) { ... }
}
 

public class Canvas { public void draw(Shape s) { s.draw(this);
}
}

public void drawAll(List<Shape> shapes) { for (Shape s: shapes) { s.draw(this);
}
}

 public void drawAll(List<? extends Shape> shapes) { ... } 

public void drawAll( final List< Shape > shapes ) for ( final Shape s : shapes ) { s.draw( this ); }

drawAll( new ArrayList< Shape >() );
drawAll( new LinkedList< Shape >() );

public void drawAll( final List< ? extends Shape > shapes ) { for ( final Shape s : shapes ) s.draw( this ); }

public void drawAll( final Shape[] shapes ) for ( final Shape s : shapes ) { s.draw( this ); }

public void fillAll( final Shape[] shapes ) for ( int i; i < shapes.length; i++ ) { shapes[i] = new Shape(); }

public void fillAll( final List< ? super Shape > shapes ) { for ( int i; i < shapes.size(); i++ ) shapes.set( i, new Shape() ); }

static < T > void rev( final List< T > list ) {
    final ListIterator< T > fwd = list.listIterator();
    final ListIterator< T > rev = list.listIterator( list.size() );
    final int mid = list.size() >> 1;
    for ( int i = 0; i < mid; i++ ) {
        T tmp = fwd.next();
        fwd.set( rev.previous() );
        rev.set( tmp );
    }
}
    
static void reverse( final List< ? > list ) { rev( list ); }

void drawAll( final List< ? extends Shape > shapes ) { for ( final Shape s : shapes ) s.draw(); }

< S extends Shape > void drawAll( final List< S > shapes ) { for ( final Shape s : shapes ) s.draw(); }

return x;

    public static <T> T[] mergeArrays(T[] a1, T[] a2) {
        Class cType = a1.getClass().getComponentType();
        T[] arr =(T[]) Array.newInstance(cType, a1.length+a2.length);

        for(int i = 0; i < a1.length; i++) {
            arr[i] = a1[i];
        }

        for(int i = 0; i < a2.length; i++) {
            arr[a1.length + i] = a2[i];
        }

        return (T[]) arr;
    }

public interface Graph <V extends Vertex<V,G>, G extends Graph<V,G>>{
    V getVertexAt(int index);
}
 
public interface Vertex <V extends Vertex<V,G>, G extends Graph<V,G>>{
    G getGraph();
}
 
public class FlowGraph implements Graph<FlowVertex,FlowGraph> {
    private FlowVertex root=new FlowVertex(this);
    public FlowGraph(){}
    public FlowVertex getRoot(){return root;}
    public FlowVertex getVertexAt(int i){return root;}
}
 
public class FlowVertex implements Vertex<FlowVertex,FlowGraph> {
    private FlowGraph fg;
    FlowVertex(FlowGraph fg){this.fg=fg;}
    public FlowGraph getGraph(){return fg;}
    public FlowVertex getIdom(){return null;}
}
 
public class Test {
    public static void main(String args[]){
        FlowGraph tree=new FlowGraph();
        FlowVertex fvert=tree.getVertexAt(0);
        FlowGraph theSameGraph=fvert.getGraph();
        FlowVertex idom=fvert.getIdom();
    }
}

static void reverse( List< ? > list )

static < T > void reverse( List< T > list )

static void reverse( List< ? T > list )

/* The idea below is that l1 and l2 are of the same type, T, 
   but that exact type is an unkown (i.e. I don't care what 
   it is so long as they are the same) */
List< ? T > l1 = ...; // declares and uses T
List< T > l2 = ...; // uses T

interface List< ? E > extends Collection< E > { ... }