Java中的泛型 第二部分

import java.io.Serializable;
import java.util.*;

public class Tree>
 implements Serializable, Comparable<tree

{
 V value;
 List<tree branches = new ArrayList<tree();

 public Tree(V value) { this.value = value; }

 // Instance methods
 V getValue() { return value; }
 void setValue(V value) { this.value = value; }
 int getNumBranches() { return branches.size(); }
 Tree getBranch(int n) { return branches.get(n); }
 void addBranch(Tree branch) { branches.add(branch); }

 // This method is a nonrecursive implementation of Comparable<tree

 // It only compares the value of this node and ignores branches.
 public int compareTo(Tree that) {
  if (this.value == null && that.value == null) return 0;
  if (this.value == null) return -1;
  if (that.value == null) return 1;
  return this.value.compareTo(that.value);
 }

 // javac -Xlint warns us if we omit this field in a Serializable class
 private static final long serialVersionUID = 833546143621133467L;
}

public class Tree {
 // These fields hold the value and the branches
 V value;
 List<tree<? extends V>> branches = new ArrayList<tree<? extends V>>();

 // Here's a constructor
 public Tree(V value) { this.value = value; }

 // These are instance methods for manipulating value and branches
 V getValue() { return value; }
 void setValue(V value) { this.value = value; }
 int getNumBranches() { return branches.size(); }
 Tree<? extends V> getBranch(int n) { return branches.get(n); }
 void addBranch(Tree<? extends V> branch) { branches.add(branch); }
}

Tree t = new Tree(0); // Note autoboxing
t.addBranch(new Tree(1));  // int 1 autoboxed to Integer

Tree<? extends Number> b = t.getBranch(0);
Tree<?> b2 = t.getBranch(0);
Tree b3 = t.getBranch(0); // compilation error

Tree<? extends Number> b = t.getBranch(0);
Number value = b.getValue();

b.setValue(3.0); // Illegal, value type is unknown
b.addBranch(new Tree(Math.PI));

/** Recursively compute the sum of the values of all nodes on the tree */
public static double sum(Tree<? extends Number> t) {
 double total = t.value.doubleValue();
 for(Tree<? extends Number> b : t.branches) total += sum(b);
 return total;
}

public static  double sum(Tree t) {
 N value = t.value;
 double total = value.doubleValue();
 for(Tree<? extends N> b : t.branches) total += sum(b);
 return total;
}

// This method returns the largest of two trees, where tree size
// is computed by the sum() method. The type variable ensures that 
// both trees have the same value type and that both can be passed to sum().
public static  Tree max(Tree t, Tree u) {
 double ts = sum(t);
 double us = sum(u);
 if (ts > us) return t;
 else return u;
}

public static 
 Tree<? extends Number> max(Tree t, Tree u) {...}

public static Tree<? extends Number> max(Tree<? extends Number> t,
           Tree<? extends Number> u) {...}

public static  Tree max(Tree t, Tree u) {...}

Tree x = new Tree(1);
Tree y = new Tree(2);
Tree z = Tree.max(x, y);

public class Util {
 /** Set all elements of a to the value v; return a. */
 public static  T[] fill(T[] a, T v) {
  for(int i = 0; i < a.length; i++) a[i] = v;
  return a;
 }
}

Boolean[] booleans = Util.fill(new Boolean[100], Boolean.TRUE);
Object o = Util.fill(new Number[5], new Integer(42));

Set empty = Collections.emptySet();

Set empty = Collections.emptySet();

printWords(Collections.emptySet());

/** Return the largest of the specified values or null if there are none */
public static > T max(T... values) { ... }

public interface Command {
 public void doit(String arg) throws X;
}

Command save = new Command() {
 public void doit(String filename) throws IOException {
  PrintWriter out = new PrintWriter(new FileWriter(filename));
  out.println("hello world");
  out.close();
 }
};

try { save.doit("/tmp/foo"); }
catch(IOException e) { System.out.println(e); }

public final class Integer extends Number implements Comparable

public class BigInteger extends Number implements Comparable

>

public static  boolean addAll(Collection<? super T> c, T... a)

public class Enum> implements Comparable, Serializable