泛型（4）：匿名内部类、构建复杂模型

悠悠 2023-07-15 09:12 7阅读 0赞

### 一、匿名内部类 ###

泛型还可以应用于内部类以及匿名内部类。下面的示例使用匿名内部类实现了Generator接口：

import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Queue;
    import java.util.Random;
    
    import com.buba.util.Generator;
    
    class Customer {
    	private static long counter = 1;
    	private final long id = counter++;
    
    	private Customer() {
    	}
    
    	public String toString() {
    		return "Customer " + id;
    	}
    
    	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;
    	}
    
    	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 r = new Random();
    		Queue<Customer> line = new LinkedList<Customer>();
    		Generators.fill(line, Customer.generator(), 15);
    		List<Teller> tellers = new ArrayList<>();
    		Generators.fill(tellers, Teller.generator, 4);
    		for (Customer c : line) {
    			serve(tellers.get(r.nextInt(tellers.size())), c);
    		}
    	}
    }

Customer和Teller类都只有private的构造器，这可以强制你必须使用Generator对象。Customer有一个Generator()方法，每次执行它都会生成一个新的Generator<Customer>对象。我们其实不需要多个Generator对象，Teller就只创建了一个public的Generator对象。在main()方法中可以看到，这两种创建Generator的方法都在fill()中用到了。

由于Customer中的Generator()方法，以及Teller中的Generator对象都声明成了static的，所以它们无法作为接口的一部分，因此无法用接口这种特定的惯用法来泛化这二者。尽管如此，它们在fill()方法中都工作的很好。

### 二、构建复杂模型 ###

泛型的一个重要的好处是能够简单而安全地创建复杂的模型。例如，我们可以很容易地创建List元组：

import java.util.ArrayList;
    
    import com.buba.util.FourTuple;
    
    public class TupleList<A, B, C, D> extends ArrayList<FourTuple<A, B, C, D>> {
    	public static void main(String[] args) {
    		TupleList<Vehicle, Amphibian, String, Integer> tl = new TupleList<>();
    		tl.add(TupleTest.h());
    		tl.add(TupleTest.h());
    		for (FourTuple<Vehicle, Amphibian, String, Integer> i : tl) {
    			System.out.println(i);
    		}
    	}
    }

尽管这看上去有些冗长（特别是迭代器的创建），但是最终还是没有用过多的代码就得到了一个相当强大的数据结构。

下面是另一个示例，它展示了使用泛型类型来构建复杂模型是多么简单。即使每个类都是作为一个构建块创建的，但是其整个还是包含许多部分。在本例中，构建的模型是一个零售店，它包含走廊、货架和商品：

import java.util.ArrayList;
    import java.util.Random;
    
    import com.buba.util.Generator;
    
    /**
     * 商品
     */
    class Product {
    	private final int id;
    	private String description;
    	private double price;
    
    	public Product(int IDnumer, String descr, double price) {
    		id = IDnumer;
    		description = descr;
    		this.price = price;
    		System.out.println(toString());
    	}
    
    	public String toString() {
    		return id + ": " + description + ", price: $" + price;
    	}
    
    	public void priceChange(double change) {
    		price += change;
    	}
    
    	public static Generator<Product> generator = new Generator<Product>() {
    		private Random r = new Random();
    
    		@Override
    		public Product next() {
    			return new Product(r.nextInt(1000), "Test", Math.round(r.nextDouble() * 1000.0) + 0.99);
    		}
    	};
    }
    
    /**
     * 保存期限
     */
    class Shelf extends ArrayList<Product> {
    	public Shelf(int nProducts) {
    		Generators.fill(this, Product.generator, nProducts);
    	}
    }
    
    /**
     * 通道
     */
    class Aisle extends ArrayList<Shelf> {
    	public Aisle(int nShelves, int nProducts) {
    		for (int i = 0; i < nShelves; i++) {
    			add(new Shelf(nProducts));
    		}
    	}
    }
    
    /**
     * 收银台
     */
    class CheckoutStand {
    }
    
    class Office {
    }
    
    /**
     * 商店
     */
    public class Store extends ArrayList<Aisle> {
    	private ArrayList<CheckoutStand> checkouts = new ArrayList<>();
    	private Office office = new Office();
    
    	public Store(int nAisles, int nShelves, int nProducts) {
    		for (int i = 0; i < nAisles; i++) {
    			add(new Aisle(nShelves, nProducts));
    		}
    	}
    
    	public String toString() {
    		StringBuilder result = new StringBuilder();
    		for (Aisle a : this)
    			for (Shelf s : a)
    				for (Product p : s) {
    					result.append(p);
    					result.append("\n");
    				}
    		return result.toString();
    	}
    
    	public static void main(String[] args) {
    		System.out.println(new Store(14, 5, 10));
    	}
    }

正如我们在Store.toString()中看到的，其结果是许多层容器，但是它们是类型安全且可管理的。令人印象深刻之处是组装这个的模型十分容易，并不会成为智力挑战。

**如果本文对您有很大的帮助，还请点赞关注一下。**