带你入门Java的泛型

class TwoTuple<A,B>{

     public final A first;

     public final B second;

     public TwoTuple(A a,B b){

         first = a;

         second = b;

     }

?

     @Override

     public String toString() {

         return "{ " + first +

                 ", " + second +

                 '}' ;

     }

}

class LinkedStack<T>{

     private class Node {

         T item;

         Node next;

         Node() { item = null ; next = null ; }

         Node(T item, Node next) {

             this .item = item;

             this .next = next;

         }

         boolean end() { return item == null && next == null ; }

     }

?

     private Node top = new Node();

     public void push(T item) { top = new Node(item, top); }

     public T pop() {

         T result = top.item;

         if (!top.end())

             top = top.next;

         return result;

     }

}

（ 3 ）RandomList

class RandomList<T>{

     private ArrayList<T> storage = new ArrayList<>();

     private Random rand = new Random( 47 );

     public void add(T item){

         storage.add(item);

     }

     public T select(){

         return storage.get(rand.nextInt(storage.size()));

     }

}

import net.mindview.util.Generator;

import java.util.Iterator;

?

class Fibonacci implements Generator<Integer> {

     private int count = 0 ;

     public Integer next(){

         return fib(count++);

     }

     private int fib( int n){

         if (n< 2 ) return 1 ;

         return fib(n- 2 ) + fib(n- 1 );

     }

}

?

class IterableFibonacci implements Iterable<Integer> {

     private Fibonacci fib = new Fibonacci();

     private int n;

     public IterableFibonacci( int count){

         n = count;

     }

?

     @Override

     public Iterator<Integer> iterator() {

         return new Iterator<Integer>() {

             @Override

             public boolean hasNext() {

                 return n> 0 ;

             }

?

             @Override

             public Integer next() {

                 n--;

                 return fib.next();

             }

             public void remove() { // Not implemented

                 throw new UnsupportedOperationException();

             }

         };

     }

}

class GenericMethods{

      public <T> void f(T x){

       System.out.println(x.getClass().getSimpleName());

      }

}

Map<Person,List<? extends Pet>> petPerson =

     new HashMap<Person,List<? extends Pet>>();

class New{

     public static <K,V> Map<K,V> map(){

         return new HashMap<K,V>();

     }

?

     public static void main(String[] args) {

         Map<Person,List<? extends Pet>> petPerson = New.map();

     }

}

public class ExplicitTypeSpecification{

     static void f(Map<Person,List<? extends Pet>> petPerson){}

     public static void main(String[] args) {

         f(New.<Person,List<? extends Pet>>map());

     }

}

import net.mindview.util.Generator;

?

public class BasicGenerator<T> implements Generator<T>{

     private Class<T> type;

     public BasicGenerator(Class<T> type){

         this .type = type;

     }

     public T next(){

         try {

             return type.newInstance();

         } catch (Exception e){

             throw new RuntimeException(e);

         }

     }

     public static <T> Generator<T> create(Class<T> type){

         return new BasicGenerator<T>(type);

     }

}

public class Sets{

     @SuppressWarnings ( "unchecked" )

     protected static <T> Set<T> copy(Set<T> s) {

         if (s instanceof EnumSet)

             return ((EnumSet)s).clone();

         return new HashSet<T>(s);

     }

?

     //并集

     public static <T> Set<T> union(Set<T> a, Set<T> b) {

         Set<T> result = copy(a);

         result.addAll(b);

         return result;

     }

     //交集

     public static <T> Set<T> intersection(Set<T> a, Set<T> b) {

         Set<T> result = copy(a);

         result.retainAll(b);

         return result;

     }

     //差集

     public static <T> Set<T> difference(Set<T> superset, Set<T> subset) {

         Set<T> result = copy(superset);

         result.removeAll(subset);

         return result;

     }

     //包含除了交集以外的所有元素

     public static <T> Set<T> complement(Set<T> a, Set<T> b) {

         return difference(union(a, b), intersection(a, b));

     }

}

public class ClassTypeCapture<T>{

     Class<T> kind;

     public ClassTypeCapture(Class<T> kind){

         this .kind = kind;

     }

     public boolean f(Object arg){

         return kind.isInstance(arg);

     }

}

class ClassAsFactory<T>{

     T x;

     public ClassAsFactory(Class<T> kind){

         try {

             x = kind.newInstance();

         } catch (Exception e){

             throw new RuntimeException(e);

         }

     }

}

interface FactoryI<T>{

     T create();

}

class Foo2<T>{

     private T x;

     public <F extends FactoryI<T>> Foo2(F factory){

         x = factory.create();

     }

}

class IntegerFactory implements FactoryI<Integer>{

     public Integer create(){

         return new Integer( 6 );

     }

}

abstract class GenericWithCreate<T>{

     final T element;

     GenericWithCreate(){ element = create(); }

     abstract T create();

}

?

class X{}

?

class Creator extends GenericWithCreate<X>{

     X create(){ return new X(); }

}

public class GenericArray<T>{

     private T[] array;

     @SuppressWarnings ( "unchecked" )

     public GenericArray( int sz){

         array = (T[]) new Object[sz];

     }

     public T[] rep(){ return array; }

?

     public static void main(String[] args) {

         GenericArray<Integer> gai = new GenericArray<Integer>( 10 );

         Integer[] ia = gai.rep(); //引起ClassCastException

         Object[] oa = gai.rep();

     }

}

class GenericArray2<T>{

     private Object[] array;

     @SuppressWarnings ( "unchecked" )

     public GenericArray( int sz){

         array = new Object[sz];

     }

     public T[] rep(){ return (T[])array; }

     public static void main(String[] args) {

         GenericArray<Integer> gai = new GenericArray<Integer>( 10 );

         Integer[] ia = gai.rep(); //引起ClassCastException

         Object[] oa = gai.rep();

     }

}

class GenericArray3<T>{

     private T[] array;

     @SuppressWarnings ( "unchecked" )

     public GenericArray(Class<T> type, int sz){

         array = (T[]) Array.newInstance(type,sz);

     }

     public T[] rep(){ return array; }

     public static void main(String[] args) {

         GenericArray<Integer> gai = new GenericArray<Integer>(Integer. class , 10 );

         Integer[] ia = gai.rep(); //可以正常运行

         Object[] oa = gai.rep();

     }

}

public class Test {

     public static void main(String[] args) {

         Man m = new Man();

         m.hear();

         m.smell();

     }

}

?

interface SuperPower{}

interface SuperHearing extends SuperPower{

     void hearSubtleNoises();

}

interface SuperSmell extends SuperPower{

     void trackBySmell();

}

?

class SuperHero<POWER extends SuperPower>{

     POWER power;

     SuperHero(POWER power){ this .power = power; }

     POWER getPower(){ return power; }

}

?

class CaineHero<POWER extends SuperHearing & SuperSmell> extends SuperHero<POWER>{

     CaineHero(POWER power){ super (power); }

     void hear(){ power.hearSubtleNoises(); }

     void smell(){ power.trackBySmell(); }

}

?

class SuperHearSmell implements SuperHearing,SuperSmell{

?

     @Override

     public void hearSubtleNoises() {

         System.out.println( "hearSubtleNoises" );

     }

?

     @Override

     public void trackBySmell() {

         System.out.println( "trackBySmell" );

     }

}

?

class Man extends CaineHero<SuperHearSmell>{

     Man(){ super ( new SuperHearSmell()); }

}

List<? extends Fruit> flist =

     Arrays.asList( new Apple());

//Compile Error：can't add any type of object

//add()的参数是<? extends Fruit>，编译器不知道需要Fruit的哪个

//具体的子类型，因此不接受任何类型的Fruit

//flist.add(new Apple());

//flist.add(new Fruit());

//flist.add(new Object());

flist.add( null ); //Legal but uninteresting

Apple a = (Apple)flist.get( 0 ); //No warning

Fruit f = flist.get( 0 ); //No warning

flist.contains( new Apple()); //参数是Object

flist.indexOf( new Apple()); //参数是Object

List<? super Fruit> flist = new ArrayList<Fruit>();

         flist.add( new Apple());

         flist.add( new Fruit());

//Error:Incompatible Type

//Fruit f = flist.get(0);

Object f = flist.get( 0 ); //OK,but type information has been lost

Map<String,?> map = new HashMap<String,Integer>;

map = new HashMap<String,String>;

static void rawArgs(Holder holder,Object arg){

     //holder.set(arg);

     //Warning:Unchecked call to set(T) as member

     //of the raw type Holder

     //holder.set(new Wildcards());//Same Warning

     //Can't do this:don't have any 'T'

     //T t = holder.get();

     //OK,but type infomation has been lost

     Object obj = holder.get();

}

//Similar to rawArgs(),but errors instead of warnings

static void unboundedArg(Holder<?> holder,Object arg){

     //holder.set(arg);

     //Error:set(capture of ?) in Holder<capture of ?>

     //cannot be applied to (Object)

     //holder.set(new Wildcards());//Same Error

     //Can't do this:don't have any 'T'

     //T t = holder.get();

     //OK,but type infomation has been lost

     Object obj = holder.get();

}

static <T> void f1(Holder<T> holder){

     T t = holder.get();

      System.out.println(t.getClass().getSimpleName());

}

?

static <T> void f2(Holder<T> holder){

     f1(holder);

}

interface Payable<T>{}

?

class Employee implements Payable<Employee>{}

?

//Compile Error:cannot be inherited with different type arguments

class Hourly extends Employee implements Payable<Hourly>{}

private int index = 0 ;

private Object[] storage;

@SuppressWarnings ( "unchecked" )

public T pop(){ return (T)storage[--index]; }

public class UseList<W,T>{

      void f(List<T> v){}

      void f(List<W> v){}

  }

public class ComparablePet

implements Comparable<ComparablePet> {

   public int compareTo(ComparablePet arg) {

       return 0 ;

   }

}

?

class Cat extends ComparablePet implements Comparable<Cat>{

   // Error: Comparable cannot be inherited with

   // different arguments: <Cat> and <Pet>

   public int compareTo(Cat arg) { return 0 ; }

} ///:~

?

class Hamster extends ComparablePet

     implements Comparable<ComparablePet>{

     public int compareTo(ComparablePet arg) {

         return 0 ;

     }

}

class BasicHolder<T> {

     T element;

     void set(T arg) { element = arg; }

     T get() { return element; }

     void f() {

         System.out.println(element.getClass().getSimpleName());

     }

}

?

class Subtype extends BasicHolder<Subtype> {}

?

public class CRGWithBasicHolder {

     public static void main(String[] args) {

         Subtype st1 = new Subtype(), st2 = new Subtype(), st3 = new Subtype();

         st1.set(st2);

         st2.set(st3);

         Subtype st4 = st1.get().get();

         st1.f();

     }

} /* Output:

Subtype

*/

interface

Processor<T,E extends Exception> {

     void process(List<T> resultCollector) throws E;

}

?

class

ProcessRunner<T,E extends Exception>

         extends ArrayList<Processor<T,E>> {

     List<T> processAll() throws E {

         List<T> resultCollector = new ArrayList<T>();

         for (Processor<T,E> processor : this )

             processor.process(resultCollector);

         return resultCollector;

     }

}

?

class Failure extends Exception {}

?

class Processor1 implements

         Processor<String,Failure> {

     static int count = 3 ;

     public void process(List<String> resultCollector)

             throws Failure1_1, Failure1_2 {

         if (count-- > 1 )

             resultCollector.add( "Hep!" );

         else

             resultCollector.add( "Ho!" );

         if (count < 0 )

                 throw new Failure1();

     }

}

?

public class Test {

     public static void main(String[] args) {

         ProcessRunner<String,Failure> runner =

                 new ProcessRunner<String,Failure>();

         for ( int i = 0 ; i < 3 ; i++)

             runner.add( new Processor1());

         try {

             System.out.println(runner.processAll());

         } catch (Failure e) {

             System.out.println(e);

         }

     }

}