我们用一个更加扩展的例子来完成，说明通用的 Subject-Observer 模式。与策略模式一样，Subject-Observer 模式使用并行类层次结构，但这次我们需要两个具有相互递归边界的类型变量，一个代表特定类型的主体，一个代表特定类型的观察者。这是我们的第一个带有相互递归边界的类型变量的例子。
Java 库在包 java.util 中使用 Observable 类和接口 Observer（前者对应于主题）实现了非通用版本的 Subject-Observer 模式，其签名示例如图 9-8 所示。
Observable 类包含注册观察者（addObserver）的方法，指示 observable 已更改（setChanged），并通知所有观察者有任何更改（notifyObservers）等等。 notifyObservers 方法可以接受将被广播给所有观察者的 Object 类型的任意参数。 Observer 接口指定由 notifyObservers 调用的更新方法。这个方法有两个参数：第一个是 Observable 类型，它是已经改变的主体;第二种类型的对象是广播参数。
对象在方法签名中的出现常常表明有机会进行基因组化。 因此，我们应该期望通过添加与参数类型相对应的类型参数 A 来生成类。 此外，我们可以用 Observable 和 Observer 自己替换类型参数 S 和 O（用于 Subject 和 Observer）。 然后在观察者的更新方法中，您可以调用主体 S 支持的任何方法，而无需先投射。
例 9-9 显示了如何为 Observable 类和 Observer 接口指定相应的通用签名。 这里是相关的标题：
public class Observable<S extends Observable<S,O,A>, O extends Observer<S,O,A>,A>
public interface Observer<S extends Observable<S,O,A>, O extends Observer<S,O,A>,A>这两个声明都采用相同的三个类型参数。这些声明是有趣的，因为它们说明了类型参数的范围可以是相互递归的：所有三个类型参数都出现在前两个的范围内。在此之前，我们看到了简单递归的其他例子，例如 Comparable 和 Enum 的声明，以及前面关于 Strategy 模式的部分。但这是我们第一次看到相互递归。
检查声明的主体，可以看到 O 但不是 S 出现在 Observable 类的主体中，并且 S 但不是 O 出现在 Observer 接口的主体中。所以你可能会想：通过从 Observable 中删除类型参数 S 和 Observer 中的类型参数 O，可以简化声明吗？但是这是行不通的，因为你需要 S 在 Observable 的范围内，所以它可以作为参数传递给 Observer，并且你需要 O 在 Observer 的范围内，以便它可以作为参数传递给 Observable。
如 5.4.2 节所述，通用声明使用存根。我们根据 Observable 和 Observer 的通用签名来编译客户端，但是针对标准 Java 分发中的类文件运行代码。我们使用存根，因为我们不想对库的源进行任何更改，因为它由 Sun 维护。
例 9-8。泛型之前的可观察和观察者
package java.util;
public class Observable {
public void addObserver(Observer o) {...}
protected void clearChanged() {...}
public int countObservers() {...}
public void deleteObserver(Observer o) {...}
public boolean hasChanged() {...}
public void notifyObservers() {...}
public void notifyObservers(Object arg) {...}
protected void setChanged() {...}
}
package java.util;
public interface Observer {
public void update(Observable o, Object arg);
}例9-9。 泛型的可观察和观察者
package java.util;
class StubException extends UnsupportedOperationException {}
public class Observable<S extends Observable<S,O,A>, O extends Observer<S,O,A>, A> {
public void addObserver(O o) { throw new StubException(); }
protected void clearChanged() { throw new StubException(); }
public int countObservers() { throw new StubException(); }
public void deleteObserver(O o) { throw new StubException(); }
public boolean hasChanged() { throw new StubException(); }
public void notifyObservers() { throw new StubException(); }
public void notifyObservers(A a) { throw new StubException(); }
protected void setChanged() { throw new StubException(); }
}
package java.util;
public interface Observer<S extends Observable<S,O,A>, O extends Observer<S,O,A>, A> {
public void update(S o, A a);
}作为 Observable 和 Observer 的演示客户端，示例 9-10 介绍了货币转换器。 转换器的屏幕截图如图 9-1 所示。 转换器允许您为三种货币（美元，欧元和英镑）中的每一种输入转换率，并以任何货币输入一个值。 更改费率条目会导致重新计算相应的值; 更改值的条目会导致重新计算所有值。
客户端通过声明 CModel 为 Observable 的子类并将 CView 作为 Observer 的子接口来实例化模式。 此外，参数类型被实例化为 Currency，一个枚举类型，可用于通知观察者该主题的哪些组件已更改。 这里是相关的标题：
enum Currency { DOLLAR, EURO, POUND }
class CModel extends Observable<CModel, CView, Currency>
interface CView extends Observer<CModel, CView, Currency>类RateView和ValueView实现CView，类Converter定义控制显示的顶层框架。
CModel类有一个方法来设置和获取给定货币的汇率和价值。汇率存储在一个映射中，该映射为每种货币分配一个汇率，并存储该值（作为一个长，
图 9-1。 货币换算
以美分，欧分或便士）与其实际货币。 要计算给定货币的价值，该值除以实际货币的利率并乘以给定货币的利率。
每当费率发生变化时，CModel 类将调用 RateView 的更新方法，并将相应货币作为参数传递（因为只需更新货币的费率和价值）; 当值更改时，它会调用 ValueView 的更新方法，并将 null 作为参数传递（因为需要更新所有货币的值）。
我们编译并运行代码如下。 首先，我们编译 Observable 和 Observer 的通用版本：
% javac -d . java/util/Observable.java java/util/Observer.java由于这些包位于 java.util 包中，它们必须保存在当前目录的子目录 java/util 中。 其次，我们在包 com.eg.converter 中编译 Converter 和相关的类。 默认情况下，Java 编译器首先搜索当前目录中的类文件（即使是标准库）。 因此，编译器使用为 Observable 和 Observer 生成的存根类文件，它们具有正确的通用签名（但不包含可运行代码）：
% javac -d . com/eg/converter/Converter.java第三，我们运行转换器的类文件。 默认情况下，java 运行时不会首先在当前目录中搜索包 java 和 javax 中的类文件 - 由于安全原因，它们始终从标准库中获取。 因此，运行时使用 Observable 和 Observer 的标准类文件，其中包含我们想要运行的遗留代码（但没有正确的通用签名）：
% java com.eg.converter.Converter例9-10。 货币换算
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
enum Currency { DOLLAR, EURO, POUND }
class CModel extends Observable<CModel,CView,Currency> {
private final EnumMap<Currency,Double> rates;
private long value = 0; // cents, euro cents, or pence
private Currency currency = Currency.DOLLAR;
public CModel() {
rates = new EnumMap<Currency,Double>(Currency.class);
}
public void initialize(double... initialRates) {
for (int i=0; i<initialRates.length; i++)
setRate(Currency.values()[i], initialRates[i]);
}
public void setRate(Currency currency, double rate) {
rates.put(currency, rate);
setChanged();
notifyObservers(currency);
}
public void setValue(Currency currency, long value) {
this.currency = currency;
this.value = value;
setChanged();
notifyObservers(null);
}
public double getRate(Currency currency) {
return rates.get(currency);
}
public long getValue(Currency currency) {
if (currency == this.currency)
return value;
else
return Math.round(value * getRate(currency) / getRate(this.currency));
}
}
interface CView extends Observer<CModel,CView,Currency> {}
class RateView extends JTextField implements CView {
private final CModel model;
private final Currency currency;
public RateView(final CModel model, final Currency currency) {
this.model = model;
this.currency = currency;
addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
try {
double rate = Double.parseDouble(getText());
model.setRate(currency, rate);
} catch (NumberFormatException x) {}
}
});
model.addObserver(this);
}
public void update(CModel model, Currency currency) {
if (this.currency == currency) {
double rate = model.getRate(currency);
setText(String.format("%10.6f", rate));
}
}
}
class ValueView extends JTextField implements CView {
private final CModel model;
private final Currency currency;
public ValueView(final CModel model, final Currency currency) {
this.model = model;
this.currency = currency;
addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
try {
long value = Math.round(100.0*Double.parseDouble(getText()));
model.setValue(currency, value);
} catch (NumberFormatException x) {}
}
});
model.addObserver(this);
}
public void update(CModel model, Currency currency) {
if (currency == null || currency == this.currency) {
long value = model.getValue(this.currency);
setText(String.format("%15d.%02d", value/100, value%100));
}
}
}
class Converter extends JFrame {
public Converter() {
CModel model = new CModel();
setTitle("Currency converter");
setLayout(new GridLayout(Currency.values().length+1, 3));
add(new JLabel("currency"));
add(new JLabel("rate"));
add(new JLabel("value"));
for (Currency currency : Currency.values()) {
add(new JLabel(currency.name()));
add(new RateView(model, currency));
add(new ValueView(model, currency));
}
model.initialize(1.0, 0.83, 0.56);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();
}
public static void main(String[] args) {
new Converter().setVisible(true);
}
}因此，当我们使用标准库类的存根时，我们不需要修改类路径，就像我们在 5.4.2 节中所做的那样，因为默认情况下会获得正确的行为。 （如果您确实想在运行时更改标准库类，则可以使用 -Xbootclass 路径标志。）
这就结束了我们对泛型的讨论。 现在，您已经有了一个全面的基础，可以使用其他人定义的通用库，定义自己的库，将遗留代码发展为通用代码，了解对泛型的限制并避免陷阱，在需要时使用检查和专业化，以及在设计模式中利用泛型。
泛型最重要的用途之一是集合框架，在本书的下一部分，我们将向您展示如何有效地使用此框架并提高您作为 Java 程序员的工作效率。