Thinking in java Chapter15 泛型

• 1 與C ++比較
• 2 簡單泛型 泛型 類
• 3 泛型 接口
• 4 泛型 方法
• 5 匿名內部類
• 6 構建復雜模型
• 7
• 8
• 9
• 10

“泛型”意思就是：適用於許多許多的類型

1 與C++比較

C++模版，了解泛型的邊界所在

2 簡單泛型

使用泛型的目的之一： 指定容器持有什么類型，讓編譯器確保正確性，而不是在運行期發現錯誤

java泛型的核心概念:告訴編譯器想使用什么類型,然后編譯器幫你處理一切細節

2.1 元組

元組允許讀取元素，但不能插入新元素，不可以修改元素值，因為元素被設置為final。

元組可以任意長度，可以存儲任何類型對象。

創建一個元組，使其返回一組任意類型的對象。

package generics;

import generics.e3.SixTuple;
import net.mindview.util.*;

class Amphibian{} //兩棲動物
class Vehicle{}//車輛
public class TupleTest {
    static TwoTuple<String,Integer> f(){
        return new TwoTuple<String,Integer>("hi",47);
    }

    static ThreeTuple<Amphibian,String,Integer> g(){
        return new ThreeTuple<Amphibian,String,Integer>(new Amphibian(),"hi",47);
    }

    static FourTuple<Vehicle,Amphibian,String,Integer> h(){
        return new FourTuple<Vehicle,Amphibian,String,Integer>(new Vehicle(),new Amphibian(),"hi",47);
    }

    static FiveTuple<Vehicle,Amphibian,String,Integer,Double> k(){
        return new FiveTuple<Vehicle,Amphibian,String,Integer,Double>(new Vehicle(),new Amphibian(),"hi",47,11.1);
    }

    static SixTuple<Vehicle,Amphibian,String,Integer,Double,Float> i(){
        return new SixTuple<Vehicle,Amphibian,String,Integer,Double,Float>(new Vehicle(),new Amphibian(),"hi",47,11.1,22.22F);
    }


    public static void main(String[] args) {
        TwoTuple<String,Integer> ttsi = f();
//        ttsi.first = "there"; //編譯錯誤，final
        System.out.println(ttsi);
        System.out.println(g());
        System.out.println(h());
        System.out.println(k());
        System.out.println(i());
    }
}

/*

 */

2.2 一個堆棧類

傳統的下推堆棧

11章使用LinkedList

不用LinkedList，實現自己內部的鏈式存儲機制

package generics;

public class LinkedStack<T> {
    private static class Node<U> {
        U item;
        Node<U> next;

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

        Node(U item, Node<U> next) {
            this.item = item;
            this.next = next;
        }

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

    private Node<T> top = new Node<T>(); // End Sentinel 末端哨兵

    public void push(T item) {
        top = new Node<T>(item, top); 
        // push "Phasers"時，創建對象Node<String>("Phasers",top),top.item == null top.next == null ,
        // 並將創建的Node結點，指向top,即top.item == "Phasers",top.next ==  item和next為null的結點
        
        // push "on"時，創建對象Node<String>("on",top)，將"Phasers"的結點，作為"on"的next

        // push "stun!"時，創建對象Node<String>("stun!",top)，將"on"的結點，作為"stun!"的next
    }

    public T pop() {
        T result = top.item; // 取值
        if (!top.end())
            top = top.next; // 下移
        return result; // 返回取出的值
    }

    public static void main(String[] args) {
        LinkedStack<String> lss = new LinkedStack<String>();
        for (String s : "Phasers on stun!".split(" "))
            lss.push(s);
        String s;
        while ((s = lss.pop()) != null)
            System.out.println(s);
    }
}
/*
stun!
on
Phasers
 */

內部類可以訪問外部類堆類型參數

package generics.e5;

public class LinkedStack<T> {
    private  class Node{ //將原來的嵌套類 修改 為普通內部類。即Node不能為static
        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(); // End Sentinel 未端哨兵

    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;
    }

    public static void main(String[] args) {
        LinkedStack<String> lss = new LinkedStack<String>();
        for (String s : "Phasers on stun!".split(" "))
            lss.push(s);
        String s;
        while ((s = lss.pop()) != null)
            System.out.println(s);
    }
}
/*
stun!
on
Phasers
 */


復習 嵌套內部類 和普通內部類

兩種內部類
嵌套類（靜態內部類 static）:形式上（寫法上）和外部類有關系， 其實在邏輯上和外部類並沒有直接的關系。可以嵌套類做測試代碼main，上線后，將測試類刪除

普通內部類:不僅在形式上和外部類有關系（寫在外部類的里面）， 在邏輯上也和外部類有聯系。
1. 內部類對象的創建依賴於外部類對象；

2. 內部類對象持有指向外部類對象的引用。


public class Outer {
    int outerField = 0;
    class Inner{
        void InnerMethod(){
            int i = outerField;
        }
    }
}

javac Outer.java

Outer$Inner.class       Outer.class

javap -v Outer\$Inner.class 
Classfile /Users/erin/JavaProject/thinking_in_java_example/src/main/java/generics/e5/Outer$Inner.class
  Last modified 2019-11-27; size 435 bytes
  MD5 checksum 0e4b5eee2db5f187c00dec5216b5ad8a
  Compiled from "Outer.java"
class generics.e5.Outer$Inner
  minor version: 0
  major version: 52
  flags: ACC_SUPER
Constant pool:
   #1 = Fieldref           #4.#16         // generics/e5/Outer$Inner.this$0:Lgenerics/e5/Outer;
   #2 = Methodref          #5.#17         // java/lang/Object."<init>":()V
   #3 = Fieldref           #18.#19        // generics/e5/Outer.outerField:I
   #4 = Class              #20            // generics/e5/Outer$Inner
   #5 = Class              #23            // java/lang/Object
   #6 = Utf8               this$0
   #7 = Utf8               Lgenerics/e5/Outer;
   #8 = Utf8               <init>
   #9 = Utf8               (Lgenerics/e5/Outer;)V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               InnerMethod
  #13 = Utf8               ()V
  #14 = Utf8               SourceFile
  #15 = Utf8               Outer.java
  #16 = NameAndType        #6:#7          // this$0:Lgenerics/e5/Outer;
  #17 = NameAndType        #8:#13         // "<init>":()V
  #18 = Class              #24            // generics/e5/Outer
  #19 = NameAndType        #25:#26        // outerField:I
  #20 = Utf8               generics/e5/Outer$Inner
  #21 = Utf8               Inner
  #22 = Utf8               InnerClasses
  #23 = Utf8               java/lang/Object
  #24 = Utf8               generics/e5/Outer
  #25 = Utf8               outerField
  #26 = Utf8               I
{
  final generics.e5.Outer this$0; //在內部類Outer$Inner中， 存在一個名字為this$0 ， 類型為Outer的成員變量， 並且這個變量是final的。 其實這個就是所謂的“在內部類對象中存在的指向外部類對象的引用”。但是我們在定義這個內部類的時候， 並沒有聲明它， 所以這個成員變量是編譯器加上的
    descriptor: Lgenerics/e5/Outer;
    flags: ACC_FINAL, ACC_SYNTHETIC

  generics.e5.Outer$Inner(generics.e5.Outer); //編譯器會為內部類的構造方法添加一個參數， 參數的類型就是外部類的類型。
    descriptor: (Lgenerics/e5/Outer;)V
    flags:
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0         //  將局部變量表中的第一個引用變量加載到操作數棧。 這里有幾點需要說明。 局部變量表中的變量在方法執行前就已經初始化完成；局部變量表中的變量包括方法的參數；成員方法的局部變量表中的第一個變量永遠是this；操作數棧就是執行當前代碼的棧。所以這句話的意思是： 將this引用從局部變量表加載到操作數棧。
         1: aload_1 //將局部變量表中的第二個引用變量加載到操作數棧。 這里加載的變量就是構造方法中的Outer類型的參數。
         2: putfield      #1                  // Field this$0:Lgenerics/e5/Outer;使用操作數棧頂端的引用變量為指定的成員變量賦值。 這里的意思是將外面傳入的Outer類型的參數賦給成員變量this$0 。 這一句putfield字節碼就揭示了， 指向外部類對象的這個引用變量是如何賦值的。
         5: aload_0
         6: invokespecial #2                  // Method java/lang/Object."<init>":()V
         9: return
      LineNumberTable:
        line 5: 0

  void InnerMethod();
    descriptor: ()V
    flags:
    Code:
      stack=1, locals=2, args_size=1
         0: aload_0
         1: getfield      #1                  // Field this$0:Lgenerics/e5/Outer;
         4: getfield      #3                  // Field generics/e5/Outer.outerField:I
         7: istore_1
         8: return
      LineNumberTable:
        line 7: 0
        line 8: 8
}
SourceFile: "Outer.java"
InnerClasses:
     #21= #4 of #18; //Inner=class generics/e5/Outer$Inner of class generics/e5/Outer


關於內部類如何訪問外部類的成員， 主要是通過以下幾步做到的：
1 編譯器自動為內部類添加一個成員變量， 這個成員變量的類型和外部類的類型相同， 這個成員變量就是指向外部類對象的引用；
2 編譯器自動為內部類的構造方法添加一個參數， 參數的類型是外部類的類型， 在構造方法內部使用這個參數為1中添加的成員變量賦值；
3 在調用內部類的構造函數初始化內部類對象時， 會默認傳入外部類的引用。
https://blog.csdn.net/weixin_39214481/article/details/80372676

2.3 RandomList

package generics;

import java.util.ArrayList;
import java.util.Random;

public class RandomList<T> {
    private ArrayList<T> storage = new ArrayList<T>();
    private Random rand = new Random(47);

    public void add(T item) {
        storage.add(item);//ArrayList 的 boolean add(E e)
    }

    public int size() {
        return storage.size();
    }

    public T select() {
        return storage.get(rand.nextInt(storage.size()));
    } //ArrayList 的 E get(int index)

    public static void main(String[] args) {
        RandomList<String> rs = new RandomList<String>();
        for (String s : ("The quick brown fox jumped over " +
                "the lazy brown dog").split(" "))
            rs.add(s);
        for (int i = 0; i < rs.size(); i++)
            System.out.print(rs.select() + " ");
    }
}
/*
brown over fox quick quick dog brown The brown lazy
 */

3 泛型接口

用Coffee和斐波那契數列 分別實現 Generator接口，Iterator接口方式，展示泛型接口。

泛型也可以用於接口，例如生成器，生成器是專門負責創建對象類。

是工廠方法設計模式的一種應用。但工廠方法一般需要參數，

生成器不需要任何參數，一般只定義一個方法。

public interface Generator { T next(); } //接口使用泛型 與 類使用泛型，沒有什么區別。

這個例子中，有兩種繁殖Coffee的方法，
一種是實現了有next()的Generator，
第二種是實現有遍歷功能Iterable
這里兩種都是運用了泛型，在Generator和Iterable的泛型類型中加入了Coffee
下面是書上例子，后續對書上例子拆分，清楚顯示兩種方法。
其中第二個例子中，實現Iterable的Iterator方法，生成Coffee的Iterator方法（hasNext()，next()）使用類第一種方法的next方法。

package generics.coffee;

import net.mindview.util.Generator;

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

public class CoffeeGenerator implements Generator<Coffee>, Iterable<Coffee> {
    private Class[] types = {Latte.class, Mocha.class,
            Cappuccino.class, Americano.class, Breve.class,};
    private static Random rand = new Random(47);

    public CoffeeGenerator() {
    }

    //For iteration
    private int size = 0;

    public CoffeeGenerator(int sz) {
        size = sz;
    }

    class CoffeeItertor implements Iterator<Coffee>{
        int count =size;

        @Override
        public boolean hasNext() {
            return count > 0;
        }

        @Override
        public Coffee next() {
            count--;
            return CoffeeGenerator.this.next();
        }

        public void remove() { // 不實現
            throw new UnsupportedOperationException();
        }
    }

    @Override
    public Iterator<Coffee> iterator() {
        return new CoffeeItertor();
    }

    @Override
    public Coffee next() {
        try {
            return (Coffee) types[rand.nextInt(types.length)].newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }


    public static void main(String[] args) {
        CoffeeGenerator gen = new CoffeeGenerator();
        for (int i =0;i < 5;i ++)
            System.out.println(gen.next());
        System.out.println("=====");
        for (Coffee c: new CoffeeGenerator(5))
            System.out.println(c);
    }
}

將上面的例子拆分下，第一種方法，使用Generator的next方法生成coffee

package generics.coffee;

import net.mindview.util.Generator;

import java.util.Random;

public class CoffeeMethod1Generator implements Generator<Coffee> {
    private Class[] types = {
            Latte.class,
            Mocha.class,
            Cappuccino.class,
            Americano.class,
            Breve.class
    };

    public CoffeeMethod1Generator() {
    }

    private static Random rand = new Random(47);

    @Override
    public Coffee next() {
        try {
            return (Coffee) (types[rand.nextInt(types.length)]).newInstance();// 這句話是關鍵，隨機生成一個指定類型范圍內的coffee實例
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        CoffeeMethod1Generator coffee1 = new CoffeeMethod1Generator();
        for (int i = 0; i < 5; i++)
            System.out.println(coffee1.next());
    }
}
/*
Americano 0
Latte 1
Americano 2
Mocha 3
Mocha 4
 */

將上面的例子拆分下，第二種方法

package generics.coffee;

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

public class CoffeeMethod2Iterable implements Iterable<Coffee> {

    private  Class[] types = {
            Latte.class,
            Mocha.class,
            Cappuccino.class,
            Americano.class,
            Breve.class
    };

    private Random rand = new Random(47);



    public Coffee next(){
        try {
            return (Coffee) (types[rand.nextInt(types.length)]).newInstance();
        } catch (Exception e) {
           throw  new RuntimeException(e);
        }
    }
    private int size;

    public CoffeeMethod2Iterable(int sz){size = sz;} //因為使用Iterable接口，所以需要有size的構造方法，作為末端哨兵的功能

    @Override
    public Iterator<Coffee> iterator() {
        return new CoffeeIerator();
    }


    private class CoffeeIerator implements Iterator<Coffee> {
        public int index;
        @Override
        public boolean hasNext() {
            return index <= size;
        }

        @Override
        public Coffee next() {
            index++;
            return CoffeeMethod2Iterable.this.next();// 外部類對象的引用，使用的方法1中的next方法，獲取下一個Coffee對象
        }
    }

    public static void main(String[] args) {
        CoffeeMethod2Iterable coffees = new CoffeeMethod2Iterable(5);
        for (Coffee coffee: coffees)
            System.out.println(coffee);
    }
}

以下用另外一個例子，是Generator 接口實現，生成斐波那契數列

方法一，使用Generator方法

類型參數為Integer ,基本類型無法作為類型參數

自動打包、自動拆包 可以在基本類型和相應的包裝器類型之間進行轉換

package generics;

import net.mindview.util.Generator;

public class Fib2 implements Generator<Integer> {// 實現Generator（只有next方法）接口
//public class Fib2 implements Generator<int> {// type argument cannot be of primitive type
    private int count = 0;

    public int fib(int cnt) {
        if (cnt < 2) return 1;// 斐波那契數列，當為0，1時，為1
        return fib(cnt - 2) + fib(cnt - 1);//大於1時，為前兩個數字之和
    }

    @Override
    public Integer next() {
        return fib(count++);
    }

    public static void main(String[] args) {
        Fib2 fib2 = new Fib2();
        for (int i = 0; i < 10; i++)
            System.out.print(fib2.next() +  " ");
    }
}

使用實現Iterable接口生成斐波那契生成器，通過使用繼承

package generics;

import java.util.Iterator;

public class FibIterator extends Fib2 implements Iterable<Integer> {
    private int n;

    public FibIterator(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 FibIterator.this.next();// 繼承通過Generator（生成next方法），創建適配器，外部類類對象的引用方法
            }
        };
    }

    public static void main(String[] args) {
//        FibIterator fibIterator = new FibIterator(10);
//        for (Integer integer: fibIterator)
        for (Integer integer: new FibIterator(10)) //foreach語句，需要邊界值。用於hasNext知道何時返回false
            System.out.print(integer + " ");
        
    }
}

使用實現Iterable接口生成斐波那契生成器，通過使用組合

e7 使用組合代替繼承

package generics.e7;

import generics.Fib2;

import java.util.Iterator;

public class IterableFibonacci implements Iterable<Integer> {
    Fib2 fib2 = new Fib2();// 通過組合方式

    private int count;

    public IterableFibonacci(int cnt){count = cnt;}

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            @Override
            public boolean hasNext() {
                return count >0;
            }

            @Override
            public Integer next() {
                count--;
                return fib2.next();
            }
        };
    }

    public static void main(String[] args) {
        for (int i : new IterableFibonacci(10))
            System.out.print(i + " ");
    }
}

作業8，與coffee例子一樣
package generics.e8;

import net.mindview.util.Generator;

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

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

class GoodGuy extends StoryCharacter{
    public String toString(){
        return super.toString() + " is a good guy";
    }
}

class BadGuy extends StoryCharacter{
    public String toString(){
        return super.toString() + " is a bad guy";
    }
}

class Morton extends BadGuy{}
class Frank extends BadGuy{}
class Harmonica extends GoodGuy{}
class Cheyenne extends GoodGuy{}

class CharacterGenerator implements Generator<StoryCharacter>,Iterable<StoryCharacter>{
    private Class[] types = {
            Morton.class,
            Frank.class,
            Harmonica.class,
            Cheyenne.class
    };

    private Random rand = new Random(47);


    // for iteratation;
    private int size;
    public CharacterGenerator(){}

    public CharacterGenerator(int count){
        size = count;
    }


    @Override
    public Iterator<StoryCharacter> iterator() {
        return new Iterator<StoryCharacter>() {
            @Override
            public boolean hasNext() {
                return size > 0;
            }

            @Override
            public StoryCharacter next() {
                size--;
                return CharacterGenerator.this.next();
            }
        };
    }

    @Override
    public StoryCharacter next() {
        try {
            return (StoryCharacter)(types[rand.nextInt(types.length)]).newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

public class E08_CharacterGenerator {
    public static void main(String[] args) {
        CharacterGenerator cg= new CharacterGenerator();
        for (int i = 0; i < 5; i++)
            System.out.println(cg.next());

        System.out.println("======");

        for (StoryCharacter sc: new CharacterGenerator(5))
            System.out.println(sc);


    }
}

4 泛型方法

泛型方法所在的類可以是泛型類，也可以不是泛型類，

並且泛型標識符可以完全不一樣，也就是說泛型方法和泛型類無關。

普通static方法無法訪問泛型類的類型參數，如果要是使用泛型就要定義成泛型靜態方法

定義泛型方法只需要將泛型參數列表置於返回值前
public void f(T x)

package generics;

public class GenericMethods {
    public <T> void f(T x) {
        System.out.println(x.getClass().getName());
    }

    public static void main(String[] args) {
        GenericMethods gm = new GenericMethods();
        gm.f("");
        gm.f(1);
        gm.f(1.0);
        gm.f(1.0F);
        gm.f('c');
        gm.f(gm);
    }
}

package generics.e10;

public class GenericMethods {
    public <B,C> void f(String a,B b,C c) {//多個類型不同參數，非參數化類型
        System.out.println(a.getClass().getName());
        System.out.println(b.getClass().getName());
        System.out.println(c.getClass().getName());
    }

    public static void main(String[] args) {
        GenericMethods gm = new GenericMethods();
        gm.f("",1,gm);
    }
}

4.1 杠桿利用類型參數推斷

使用泛型方法時編譯期會通過類型參數推斷來為我們找出具體類型，而不必自己聲明時什么類型

類型推斷只對賦值操作有效,其它時候不起作用 JDK8不存在例子中編譯問題

顯示類型說明

package generics;

import net.mindview.util.New;
import typeinfo.pets.*;

import java.util.*;

public class LimitsOfInference {
    static void
    f(Map<Person, List<? extends Pet>> petPeople) {
    }

    public static void main(String[] args) {
        f(New.<Person, List<? extends Pet>>map()); // 顯示的類型說明
        // 如果是在定義該方法的類的內部，需要this.
        // static方法，需要 ClassName.
        f(New.map()); // Does not compile JDK8 正常
    }
}

4.2 可變參數與泛型方法

泛型方法與可變參數列表能夠很好地共存

下面的方法展示了和類庫java.util.Arrays.asList()方法相同的功能

package generics;
//: generics/GenericVarargs.java

import java.util.*;

public class GenericVarargs {
    public static <T> List<T> makeList(T... args) {
        List<T> result = new ArrayList<T>();
        for (T item : args)
            result.add(item);
        return result;
    }

    public static void main(String[] args) {
        List<String> ls = makeList("A");
        System.out.println(ls);
        ls = makeList("A", "B", "C");
        System.out.println(ls);
        ls = makeList("ABCDEFFHIJKLMNOPQRSTUVWXYZ".split(""));
        System.out.println(ls);
    }
} /* Output:
[A]
[A, B, C]
[, A, B, C, D, E, F, F, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z]
*///:~

4.3 用於Generator的泛型方法

package generics;
//: generics/Generators.java
// A utility to use with Generators.
import generics.coffee.*;
import java.util.*;
import net.mindview.util.*;

public class Generators {
    public static <T> Collection<T>
    fill(Collection<T> coll, Generator<T> gen, int n) { //Generator的泛型方法
        for(int i = 0; i < n; i++)
            coll.add(gen.next());
        return coll;
    }
    public static void main(String[] args) {
        Collection<Coffee> coffee = fill(
                new ArrayList<Coffee>(), new CoffeeGenerator(), 4);
        for(Coffee c : coffee)
            System.out.println(c);
        Collection<Integer> fnumbers = fill(
                new ArrayList<Integer>(), new Fibonacci(), 12);
        for(int i : fnumbers)
            System.out.print(i + ", ");
    }
} /* Output:
Americano 0
Latte 1
Americano 2
Mocha 3
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,
*///:~

4.4 一個通用的Generator

package generics;

import net.mindview.util.Generator;

public class BasicGenerator<T> implements Generator<T> {
    private Class<T> type;

    public BasicGenerator(Class<T> type){this.type = type;}

    @Override
    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);
    }

}



package generics;

public class CountedObject {
    private static long counter = 0;
    private final long id = counter++;
    public long id(){return id;}
    public String toString(){
        return "CountedObject " + id;
    }
}


package generics;

import net.mindview.util.Generator;

public class BasicGeneratorDemo {
    public static void main(String[] args) {
        Generator<CountedObject> gen = BasicGenerator.create(CountedObject.class);
        //  BasicGenerator<CountedObject> gen = new BasicGenerator(CountedObject.class); 等價
        for (int i = 0; i < 5;i ++)
            System.out.println(gen.next());
    }
}

4.5 簡化元組的使用

4.6一個Set實用工具

5 匿名內部類

泛型用於內部類及匿名內部類。

示例使用匿名內部類實現Generator接口

package generics;

import net.mindview.util.Generator;

import java.util.*;

class Customer {
    private static long counter = 1;
    private final long id = counter++;

    //私有化構造方法，只能通過Generator 獲取實例
    private Customer() {
    }

    public String toString() {
        return "Customer " + id;
    }

    // A method to produce Generator objects:
    // Customer 對象生成器
    // Generator 每次調用 都會創建 一個 Generator對象，但這不是必要的。
    public static Generator<Customer> generator() {
        return new Generator<Customer>() {
            @Override
            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:
    // 匿名內部類2
    // 單例Generator對象:
    // 可以對比Customer的generator方法 這里只會創建一個generator實例
    public static Generator<Teller> generator =
            new Generator<Teller>() {
                @Override
                public Teller next() {
                    return new Teller();
                }
            };
}

public class BankTeller {
    public static void serve(Teller t, Customer c) {
        System.out.println(t + " serves " + c);
    }

    public static void main(String[] args) {
        Random rand = new Random(47);
        Queue<Customer> line = new LinkedList<Customer>();
        Generators.fill(line, Customer.generator(), 15);
        List<Teller> tellers = new ArrayList<Teller>();
        Generators.fill(tellers, Teller.generator, 4);
        for (Customer c : line)//遍歷line，隨機取出teller與 Customer 按序輸出
            serve(tellers.get(rand.nextInt(tellers.size())), c);
    }
}

6 構建復雜模型

1

1

1