Gen(T o) {
    ob = o;
  }

  public T getob() {
    return ob;
  }

  // 输出T的类型
public  void showType() {
    System.out.println("Type of T is " +
                       ob.getClass().getName());
  }
}

// 示范这个范型类的用法
public class GenDemo {
  public static void main(String args[]) {
    // 声明一个类型参数为Integers的Gen对象 
    Gen< Integer> iOb; 

    // 创建一个Gen< Integer> 对象并分配其引用到iOb.  注意使用了自动装箱.
    iOb = new Gen< Integer>(88);

    // 显示类型
    iOb.showType();

    // 获取在iOb对象内的值,注意不需要类型转换.
 
    int v = iOb.getob();
    System.out.println("value: " + v);

    System.out.println();

    // 创建一个类型参数为String的Gen对象
    Gen< String> strOb = new Gen< String>("Generics Test");

  
    strOb.showType();

  
    String str = strOb.getob();
    System.out.println("value: " + str);
  }
}

清单2
// NonGen类没有使用范型, 与使用范型的Gen的等价
class NonGen { 
  Object ob; // ob 现在是一个Object类型
   
 
  NonGen(Object o) { 
    ob = o; 
  } 
 
  // 返回类型为 Object.
  Object getob() { 
    return ob; 
  } 

  // 显示ob的类型. 
  void showType() { 
    System.out.println("Type of ob is " + 
                       ob.getClass().getName()); 
  } 
} 
 
// 示范这个类用使用. 
class NonGenDemo { 
  public static void main(String args[]) { 
    NonGen iOb;  
 
   
    // 自动装箱还会发生.
    iOb = new NonGen(88); 
 
  
    iOb.showType();

    // 输出iOb的值,必须进行类型转换
    int v = (Integer) iOb.getob(); 
    System.out.println("value: " + v); 
 
    System.out.println(); 
 

    // 创建另一个对象,存字符串.
    NonGen strOb = new NonGen("Non-Generics Test"); 
 
    strOb.showType();

    String str = (String) strOb.getob(); 
    System.out.println("value: " + str); 

    // 下面这句编译能通过,因为没有语法错误
    iOb = strOb;
    v = (Integer) iOb.getob(); // 发生运行时错误!
  } 
}

清单 3
//带两个类型参数的范型
class TwoGen< T, V> {
  T ob1;
  V ob2;
  

  TwoGen(T o1, V o2) {
    ob1 = o1;
    ob2 = o2;
  }

  // 显示T 和 V的类型.
  void showTypes() {
    System.out.println("Type of T is " +
                       ob1.getClass().getName());

    System.out.println("Type of V is " +
                       ob2.getClass().getName());
  }

  T getob1() {
    return ob1;
  }

  V getob2() {
    return ob2;
  }
}

// 示范.
class SimpGen {
  public static void main(String args[]) {

    TwoGen< Integer, String> tgObj =
      new TwoGen< Integer, String>(88, "Generics");

    tgObj.showTypes();

    // 获取并显示值.
    int v = tgObj.getob1();
    System.out.println("value: " + v);

    String str = tgObj.getob2();
    System.out.println("value: " + str);
  }
}

清单 4
// 尝试创建一个能计算数字平均值的泛型类
// 这个类包括一个错误!
class Stats< T> { 
  T[] nums; // nums 是一个T类型的数组
   
 
  Stats(T[] o) { 
    nums = o; 
  } 
 
  // 所有的情况下都返回double.
  double average() { 
    double sum = 0.0;

    for(int i=0; i < nums.length; i++) 
      sum += nums[i].doubleValue(); // 错误!!!,编译器无法知道你只使用数字类型创建Stats对象.

    return sum / nums.length;
  } 
}

清单 5
// 这次使用有界类型的范型,声明一个上界,所有类型变量必须从超类派生.
class Stats< T extends Number> { 
  T[] nums; // Number或它的子类型的数组
   

  Stats(T[] o) { 
    nums = o; 
  } 
 
  double average() { 
    double sum = 0.0;

    for(int i=0; i < nums.length; i++) 
      sum += nums[i].doubleValue();

    return sum / nums.length;
  } 
} 
 
// 示范 
class BoundsDemo { 
  public static void main(String args[]) { 

    Integer inums[] = { 1, 2, 3, 4, 5 };
    Stats< Integer> iob = new Stats< Integer>(inums);  
    double v = iob.average();
    System.out.println("iob average is " + v);

    Double dnums[] = { 1.1, 2.2, 3.3, 4.4, 5.5 };
    Stats< Double> dob = new Stats< Double>(dnums);  
    double w = dob.average();
    System.out.println("dob average is " + w);

    // 这不能编译,因为String不是Number的子类
    // String strs[] = { "1", "2", "3", "4", "5" };
    // Stats< String> strob = new Stats< String>(strs);  
 
    // double x = strob.average();
    // System.out.println("strob average is " + v);

  } 
}

清单 6
// 使用通配符
class Stats< T extends Number> {  
  T[] nums;
    
 
  Stats(T[] o) {  
    nums = o;  
  }  
  
  double average() {  
    double sum = 0.0; 
 
    for(int i=0; i < nums.length; i++)  
      sum += nums[i].doubleValue(); 
 
    return sum / nums.length; 
  }

  // 确定两个包含数组的Stats对象是否有相同的平均值.
  // 注意使用通配符
  boolean sameAvg(Stats< ?> ob) {
    if(average() == ob.average()) 
      return true;

    return false;
  }
}  
  
// 示范.
class WildcardDemo {  
  public static void main(String args[]) {  
    Integer inums[] = { 1, 2, 3, 4, 5 }; 
    Stats< Integer> iob = new Stats< Integer>(inums);   
    double v = iob.average(); 
    System.out.println("iob average is " + v); 
 
    Double dnums[] = { 1.1, 2.2, 3.3, 4.4, 5.5 }; 
    Stats< Double> dob = new Stats< Double>(dnums);   
    double w = dob.average(); 
    System.out.println("dob average is " + w); 
 
    Float fnums[] = { 1.0F, 2.0F, 3.0F, 4.0F, 5.0F }; 
    Stats< Float> fob = new Stats< Float>(fnums);   
    double x = fob.average(); 
    System.out.println("fob average is " + x); 
 
    // 看哪二个数组有相同的平均值.
    System.out.print("Averages of iob and dob ");
    if(iob.sameAvg(dob))
      System.out.println("are the same."); 
    else
      System.out.println("differ."); 

    System.out.print("Averages of iob and fob ");
    if(iob.sameAvg(fob))
      System.out.println("are the same."); 
    else
      System.out.println("differ."); 
  }  
}

运行结果:

C:\java>java   WildcardDemo
iob average is 3.0
dob average is 3.3
fob average is 3.0
Averages of iob and dob differ.
Averages of iob and fob are the same.

listing 7
// 有界通配符.

// 二维空间.
class TwoD {
  int x, y;

  TwoD(int a, int b) {
    x = a;
    y = b;
  }
}

// 三维空间.
class ThreeD extends TwoD {
  int z;
  
  ThreeD(int a, int b, int c) {
    super(a, b);
    z = c;
  }
}

// 四维空间.
class FourD extends ThreeD {
  int t;

  FourD(int a, int b, int c, int d) {
    super(a, b, c);
    t = d; 
  }
}

class Coords< T extends TwoD> { //有界范型
  T[] coords;

  Coords(T[] o) { coords = o; }
}

// 示范.
class BoundedWildcard {
  static void showXY(Coords< ?> c) {
    System.out.println("X Y Coordinates:");
    for(int i=0; i < c.coords.length; i++)
      System.out.println(c.coords[i].x + " " +
                         c.coords[i].y);
    System.out.println();
  }

  static void showXYZ(Coords< ? extends ThreeD> c) {
    System.out.println("X Y Z Coordinates:");
    for(int i=0; i < c.coords.length; i++)
      System.out.println(c.coords[i].x + " " +
                         c.coords[i].y + " " +
                         c.coords[i].z);
    System.out.println();
  }

  static void showAll(Coords< ? extends FourD> c) {
    System.out.println("X Y Z T Coordinates:");
    for(int i=0; i < c.coords.length; i++)
      System.out.println(c.coords[i].x + " " +
                         c.coords[i].y + " " +
                         c.coords[i].z + " " +
                         c.coords[i].t);
    System.out.println();
  }

  public static void main(String args[]) {
    TwoD td[] = {
      new TwoD(0, 0),
      new TwoD(7, 9),
      new TwoD(18, 4),
      new TwoD(-1, -23)
    };

    Coords< TwoD> tdlocs = new Coords< TwoD>(td);    

    System.out.println("Contents of tdlocs.");
    showXY(tdlocs); // OK, is a TwoD
//  showXYZ(tdlocs); // Error, not a ThreeD
//  showAll(tdlocs); // Erorr, not a FourD

    // 创建一些四维点
    FourD fd[] = {
      new FourD(1, 2, 3, 4),
      new FourD(6, 8, 14, 8),
      new FourD(22, 9, 4, 9),
      new FourD(3, -2, -23, 17)
    };

    Coords< FourD> fdlocs = new Coords< FourD>(fd);    

    System.out.println("Contents of fdlocs.");
    //这些都不会产生错误.
    showXY(fdlocs); 
    showXYZ(fdlocs);
    showAll(fdlocs);
  }
}

清单 8
// 示范简单的范型方法
class GenMethDemo { 

  // 静态的范型方法,测试一个对象是否在一个数组中.
  static < T, V extends T> boolean isIn(T x, V[] y) {

    for(int i=0; i < y.length; i++)
      if(x.equals(y[i])) return true;

    return false;
  }

  public static void main(String args[]) { 

    // 对Integers使用isIn()方法.
    Integer nums[] = { 1, 2, 3, 4, 5 };

    if(isIn(2, nums))
      System.out.println("2 is in nums");

    if(!isIn(7, nums))
      System.out.println("7 is not in nums");

    System.out.println();

    // 对Strings使用isIn()
    String strs[] = { "one", "two", "three",
                      "four", "five" };

    if(isIn("two", strs))
      System.out.println("two is in strs");

    if(!isIn("seven", strs))
      System.out.println("seven is not in strs");

    // 不能编译,类型必须一致.
    //    if(isIn("two", nums))
    //      System.out.println("two is in strs");
  } 
}

清单 9
// 泛型构造器.
class GenCons {
  private double val;

  < T extends Number> GenCons(T arg) {
    val = arg.doubleValue();
  }

  void showval() {
    System.out.println("val: " + val);
  }
}

class GenConsDemo {
  public static void main(String args[]) {

    GenCons test = new GenCons(100);
    GenCons test2 = new GenCons(123.5F);

    test.showval();
    test2.showval();
  }
}
运行结果:
C:\java>java   GenConsDemo
val: 100.0
val: 123.5

清单 10
// 一个泛型接口的例子.

// 来用返回某个对象集的最小或最大值.
interface MinMax< T extends Comparable< T>> {
  T min();
  T max();
}

//MyClass实现接口MinMax
class MyClass< T extends Comparable< T>> implements MinMax< T> {
  T[] vals;

  MyClass(T[] o) { vals = o; }

  // 返回最小值.
  public T min() {
    T v = vals[0];

    for(int i=1; i < vals.length; i++)
      if(vals[i].compareTo(v) < 0) v = vals[i];

    return v;
  }

  // 返回最大值.
  public T max() {
    T v = vals[0];

    for(int i=1; i < vals.length; i++)
      if(vals[i].compareTo(v) > 0) v = vals[i];

    return v;
  }
}

class GenIFDemo {
  public static void main(String args[]) {
    Integer inums[] = {3, 6, 2, 8, 6 };
    Character chs[] = {'b', 'r', 'p', 'w' };

    MyClass< Integer> iob = new MyClass< Integer>(inums);
    MyClass< Character> cob = new MyClass< Character>(chs);

    System.out.println("Max value in inums: " + iob.max());
    System.out.println("Min value in inums: " + iob.min());

    System.out.println("Max value in chs: " + cob.max());
    System.out.println("Min value in chs: " + cob.min());
  }
}

清单 11
// 示范使用原始类型. 一个泛型类在使用时可以不带类型参数,同时带来的是失去了类型安全.
class Gen< T> { 
  T ob; // 声明一个T类型的对象
   
  Gen(T o) { 
    ob = o; 
  } 
 
  T getob() { 
    return ob; 
  } 
} 
 
// 使用原始类型.
class RawDemo { 
  public static void main(String args[]) { 

    Gen< Integer> iOb = new Gen< Integer>(88); 
  
    Gen< String> strOb = new Gen< String>("Generics Test"); 
 
    // 创建一个使用原始类型参数的Gen
    Gen raw = new Gen(new Double(98.6));

    // 类型转换是必须的
    double d = (Double) raw.getob();
    System.out.println("value: " + d);

    //int i = (Integer) raw.getob(); // 运行时错误

    strOb = raw; // 可以通过编译
    // String str = strOb.getob(); // 运行时错误 
    
    raw = iOb; // 可能编译
    // d = (Double) raw.getob(); // 运行时错误
  } 
}

清单 12
// 泛型类层次. 使用泛型超类
class Gen< T> { 
  T ob;
   
  Gen(T o) { 
    ob = o; 
  } 
 
  // Return ob. 
  T getob() { 
    return ob; 
  } 
} 

// Gen的子类
class Gen2< T> extends Gen< T> {
  Gen2(T o) {
    super(o);
  }
}

清单 13
// 子类能增加自己的类型参数.
class Gen< T> { 
  T ob;
   
  Gen(T o) { 
    ob = o; 
  } 
 
  T getob() { 
    return ob; 
  } 
} 

class Gen2< T, V> extends Gen< T> {
  V ob2;

  Gen2(T o, V o2) {
    super(o);
    ob2 = o2;
  }

  V getob2() {
    return ob2;
  }
}
 
// 创建一个Gen2类型的对象.
class HierDemo { 
  public static void main(String args[]) { 
   
    Gen2< String, Integer> x = new Gen2< String, Integer>("Value is: ", 99); 

    System.out.print(x.getob());
    System.out.println(x.getob2());
  } 
}

清单 14
// 泛型子类

class NonGen {
  int num;

  NonGen(int i) {
    num = i;
  }

  int getnum() {
    return num;
  }
}

// 一个泛型子类
class Gen< T> extends NonGen { 
  T ob;
   
  Gen(T o, int i) { 
    super(i);
    ob = o; 
  } 
 
  T getob() { 
    return ob; 
  } 
} 
 
class HierDemo2 { 
  public static void main(String args[]) { 
   
    Gen< String> w = new Gen< String>("Hello", 47);
   
    System.out.print(w.getob() + " ");
    System.out.println(w.getnum());
  } 
}

清单 15
// 泛型层次中的运行时类型比较. 
class Gen< T> {  
  T ob; 
    
  Gen(T o) {  
    ob = o;  
  }  
  
  T getob() {  
    return ob;  
  }  
}  
 
// Gen的子类. 
class Gen2< T> extends Gen< T> { 
  Gen2(T o) { 
    super(o); 
  } 
} 
 
class HierDemo3 {  
  public static void main(String args[]) {  
    
    // Create a Gen object for Integers. 
    Gen< Integer> iOb = new Gen< Integer>(88); 
 
    // Create a Gen2 object for Integers. 
    Gen2< Integer> iOb2 = new Gen2< Integer>(99);  
   
    // Create a Gen2 object for Strings. 
    Gen2< String> strOb2 = new Gen2< String>("Generics Test");  
 
    // See if iOb2 is some form of Gen2.
    if(iOb2 instanceof Gen2< ?>)  
      System.out.println("iOb2 is instance of Gen2"); 

    // See if iOb2 is some form of Gen.
    if(iOb2 instanceof Gen< ?>)  
      System.out.println("iOb2 is instance of Gen"); 
 
    System.out.println(); 
 
    // See if strOb2 is a Gen2.
    if(strOb2 instanceof Gen2< ?>)  
      System.out.println("strOb is instance of Gen2"); 
 
    // See if strOb2 is a Gen.
    if(strOb2 instanceof Gen< ?>)  
      System.out.println("strOb is instance of Gen"); 

    System.out.println(); 
 
    // See if iOb is an instance of Gen2, which its not.
    if(iOb instanceof Gen2< ?>)  
      System.out.println("iOb is instance of Gen2"); 
 
    // See if iOb is an instance of Gen, which it is.
    if(iOb instanceof Gen< ?>)  
      System.out.println("iOb is instance of Gen"); 
 
    // The following can't be compiled because 
    // generic type info does not exist at runtime.
    // if(iOb2 instanceof Gen2< Integer>)  
    // System.out.println("iOb2 is instance of Gen2< Integer>"); 
  }  
}

运行结果:

C:\java>java     HierDemo3
iOb2 is instance of Gen2
iOb2 is instance of Gen

strOb is instance of Gen2
strOb is instance of Gen

iOb is instance of Gen

listing 16
// 重写泛型类中的方法
class Gen< T> { 
  T ob;

  Gen(T o) { 
    ob = o; 
  } 
 
 
  T getob() { 
    System.out.print("Gen's getob(): " );
    return ob; 
  } 
} 

// Gen的子类重写了getob().
class Gen2< T> extends Gen< T> {

  Gen2(T o) {
    super(o);
  }
  
  T getob() { 
    System.out.print("Gen2's getob(): ");
    return ob; 
  } 
}
 
// 演示重写泛型方法.
class OverrideDemo { 
  public static void main(String args[]) { 
   
    // Create a Gen object for Integers.
    Gen< Integer> iOb = new Gen< Integer>(88);

    // Create a Gen2 object for Integers.
    Gen2< Integer> iOb2 = new Gen2< Integer>(99); 
  
    // Create a Gen2 object for Strings.
    Gen2< String> strOb2 = new Gen2< String>("Generics Test"); 

    System.out.println(iOb.getob());
    System.out.println(iOb2.getob());
    System.out.println(strOb2.getob());
  } 
}
运行结果:

C:\java>java   OverrideDemo
Gen's getob(): 88
Gen2's getob(): 99
Gen2's getob(): Generics Test

清单 17
// 不使用泛型,迭代一个collection.
import java.util.*;

class OldStyle { 
  public static void main(String args[]) {
    ArrayList list = new ArrayList();

    list.add("one");
    list.add("two");
    list.add("three");
    list.add("four");

    Iterator itr = list.iterator();
    while(itr.hasNext()) {

    
      String str = (String) itr.next(); // 这里需要类型转换.

      System.out.println(str + " is " + str.length() + " chars long.");
    }
  } 
}

清单 18
// 新的泛型版本.
import java.util.*;

class NewStyle { 
  public static void main(String args[]) {

    ArrayList< String> list = new ArrayList< String>();

    list.add("one");
    list.add("two");
    list.add("three");
    list.add("four");

    // 注意Iterator 也是泛型.
    Iterator< String> itr = list.iterator();

    // Iterator< Integer> itr = list.iterator(); // 这样会产生编译错误!

    while(itr.hasNext()) {
      String str = itr.next(); // no cast needed

      // Now, the following line is a compile-time,
      // rather than runtime, error.
      // Integer i = itr.next(); // this won't compile

      System.out.println(str + " is " + str.length() + " chars long.");
    }
  } 
}

清单 19(擦拭)
// 这个类编译后,T将被Object替换掉.
class Gen< T> { 
  T ob; // here, T will be replaced by Object
   
  Gen(T o) { 
    ob = o; 
  } 
 
  // Return ob. 
  T getob() { 
    return ob; 
  } 
} 

// 编译后.这个类中的T 将被String替换.
class GenStr< T extends String> {
  T str; // here, T will be replaced by String

  GenStr(T o) { 
    str = o; 
  } 

  T getstr() { return str; }
}

清单 20
class GenTypeDemo { 
  public  static void main(String args[]) { 
    Gen< Integer> iOb = new Gen< Integer>(99); 
    Gen< Float> fOb = new Gen< Float>(102.2F);

    System.out.println(iOb.getClass().getName());
    System.out.println(fOb.getClass().getName());
  }
}