泛型全面分析和应用（二）

接着上篇文章，我们介绍了很多有关于泛型使用和注意的事项，这次将给一个很好的代码实例来演示泛型的有趣性----代码来着《Java编程思想》

例子一：再来一杯coffee

---

代码的思路如下：

1. 构建一个Generator的接口，这个接口用来实现“繁殖功能”的作用
2. 定义一个Coffee类，接着用几种Coffee子类继承这个Coffee父类
3. 构建一个CoffeeGenerator的类，这个类有两个特点，一个是实现了Generator<Coffee>和Iterable<Coffee>，这就是泛型的两种实现“繁殖功能”的关键了。

Generator接口

package Generic.Coffee;

public interface Generator<T> {

    T next();
}

Coffee父类

package Generic.Coffee;

public class Coffee {

    private static long counter = 0;
    private final long id = counter++;
    public String toString(){
        return getClass().getSimpleName() + " " + id;
    }
}

几种Coffee子类

package Generic.Coffee;

public class Latte extends Coffee {

}

package Generic.Coffee;

public class Mocha extends Coffee {

}

package Generic.Coffee;

public class Americano extends Coffee{

}

package Generic.Coffee;

public class Cappuccino extends Coffee {

}

CoffeeGenerator实例

package Generic.Coffee;

import java.util.Iterator;
import java.util.Random;

/**
 * 这里两种繁殖Coffee的方法，一种是实现了有next()的Generator，另外一种是实现有遍历功能Iterable
 * 这里两种都是运用了泛型，在Generator和Iterable的泛型类型中加入了Coffee
 * @author keguirong
 *
 */
public class CoffeeGenerator implements Generator<Coffee>,Iterable<Coffee>{

    private Class[] types = {Latte.class,Mocha.class,Americano.class,Cappuccino.class};
    private static Random rand = new Random(47);
    public CoffeeGenerator(){}
    //For iteration
    private int size = 0;
    public CoffeeGenerator(int sz){ size = sz;}
    //@Override
    public Iterator<Coffee> iterator() {
        // 直接返回了一个CoffeeIterable
        return new CoffeeIterator();
    }

    @Override
    public Coffee next() {
        // TODO Auto-generated method stub
        try {
            return (Coffee) types[rand.nextInt(types.length)].newInstance();
            //Report programmer errors at run time
        } catch (Exception e) {
            // TODO: handle exception
            throw new RuntimeException(e);
        }
    }

    class CoffeeIterator implements Iterator<Coffee>{

        int count = size;
        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            return count >0;
        }

        @Override
        public Coffee next() {
            // TODO Auto-generated method stub
            count --;
            return CoffeeGenerator.this.next();
        }

        @Override
        public void remove() {
            // TODO Auto-generated method stub
            throw new UnsupportedOperationException();
        }
    }
    
    public static void main(String[] args) {
        CoffeeGenerator gen = new CoffeeGenerator();
        for(int i = 0; i < 5; i ++)
            System.out.println(gen.next());
        //如果没有实现了Iterable<Coffee>接口，下面的for循环是不能进行的
        for(Coffee c : new CoffeeGenerator(5))
            System.out.println(c);
    }
}

运行结果

Americano 0
Mocha 1
Americano 2
Latte 3
Latte 4
Americano 5
Latte 6
Mocha 7
Americano 8
Americano 9

 

例子二：服务器接客

---

代码思路如下：

1. 和“例子一”一样，需要一个Generator的有next()的接口，和一个有自动填充功能的类
2. 客户能自动生成，需要有实现了Generator的实现内部类
3. 当然，服务器也有相应的实现，实现方式却是另一种方式。
4. 关联客户和服务器

Generator的接口

package Generic.Coffee;

public interface Generator<T> {

    T next();
}

自动填充类

package Generic.Coffee;

import java.util.ArrayList;
import java.util.Collection;

public class Generators {

    /**
     * 一个参数是Collection泛型的容器，一个是生成Generator的类，一个是要填充数量
     * @param coll
     * @param gen
     * @param n
     * @return
     */
    public static <T> Collection<T>  fill(Collection<T> coll,Generator<T> gen ,int n){
        for(int i = 0 ; i < n ; i++)
            coll.add(gen.next());
        return coll;
    }
    
}

客户类

public class Customer {

    private static long counter = 1;
    private final long id = counter++;
    public Customer(){}
    public String toString(){
        return "Customer"+ id ;
    }
    //一种是Generator的方法，内部类
    public static Generator<Customer> generator(){
        return new Generator<Customer>(){
            public Customer next(){ return new Customer();}
        };
    }
    
}

服务类

class Teller{
    private static long counter = 1;
    private final long id = counter ++;
    private Teller(){}
    public String toString(){return "Teller" + id;}
    //A single Generator object;
    //一种是新建一个Generator，这个Generator是一个内部类
    public static Generator<Teller> generator = new Generator<Teller>(){
        public Teller next(){return new Teller();}
    };
}

实现两者的关联

package Generic;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Random;

import Generic.Coffee.Generators;

public class BankTeller {

    /**
     * 关联客户和服务的方法
     * @param t
     * @param c
     */
    public static void server(Teller t ,Customer c){
        System.out.println( t + " serves " + c);
    }
    public static void main(String[] args) {
        Random rand = new Random(47);
        //15个LinkList的Customer
        Queue<Customer> line = new LinkedList<Customer>();
        Generators.fill(line, Customer.generator(), 15);
        //4个ArrayList的tellers
        List<Teller> tellers = new ArrayList<Teller>();
        Generators.fill(tellers, Teller.generator, 4);
        //随机分配
        for(Customer c : line){
            server(tellers.get(rand.nextInt(tellers.size())),c);
        }
    }
}

运行结果

Teller3 serves Customer1
Teller2 serves Customer2
Teller3 serves Customer3
Teller1 serves Customer4
Teller1 serves Customer5
Teller3 serves Customer6
Teller1 serves Customer7
Teller2 serves Customer8
Teller3 serves Customer9
Teller3 serves Customer10
Teller2 serves Customer11
Teller4 serves Customer12
Teller2 serves Customer13
Teller1 serves Customer14
Teller1 serves Customer15

结束

---

  好了，其实很多情况我们都用到了泛型，但是却不知道自己使用到了。泛型具有限定性，规范性，最重要的一点是 模拟代表性，可以被范围内的多种参数类型使用同一个方法，在上一篇已经介绍了，这一篇展示2个有趣的例子就好了，嘻嘻嘻