java 在观察者模式中使用泛型T的实例

public class Observable<T> {  List<Observer> observers = new ArrayList<Observer>();  boolean changed = false;  /**   * Adds the specified observer to the list of observers. If it is already   * registered, it is not added a second time.   *   * @param observer   *      the Observer to add.   */  public void addObserver(Observer observer) {    if (observer == null) {      throw new NullPointerException("observer == null");    }    synchronized (this) {      if (!observers.contains(observer))        observers.add(observer);    }  }  /**   * Clears the changed flag for this {@code Observable}. After calling   * {@code clearChanged()}, {@code hasChanged()} will return {@code false}.   */  protected void clearChanged() {    changed = false;  }  /**   * Returns the number of observers registered to this {@code Observable}.   *   * @return the number of observers.   */  public int countObservers() {    return observers.size();  }  /**   * Removes the specified observer from the list of observers. Passing null   * won't do anything.   *   * @param observer   *      the observer to remove.   */  public synchronized void deleteObserver(java.util.Observer observer) {    observers.remove(observer);  }  /**   * Removes all observers from the list of observers.   */  public synchronized void deleteObservers() {    observers.clear();  }  /**   * Returns the changed flag for this {@code Observable}.   *   * @return {@code true} when the changed flag for this {@code Observable} is   *     set, {@code false} otherwise.   */  public boolean hasChanged() {    return changed;  }  /**   * If {@code hasChanged()} returns {@code true}, calls the {@code update()}   * method for every observer in the list of observers using null as the   * argument. Afterwards, calls {@code clearChanged()}.   * <p>   * Equivalent to calling {@code notifyObservers(null)}.   */  public void notifyObservers() {    notifyObservers(null);  }  /**   * If {@code hasChanged()} returns {@code true}, calls the {@code update()}   * method for every Observer in the list of observers using the specified   * argument. Afterwards calls {@code clearChanged()}.   *   * @param data   *      the argument passed to {@code update()}.   */  public void notifyObservers(T data) {    int size = 0;    Observer[] arrays = null;    synchronized (this) {      if (hasChanged()) {        clearChanged();        size = observers.size();        arrays = new Observer[size];        observers.toArray(arrays);      }    }    if (arrays != null) {      for (Observer observer : arrays) {        observer.update(this, data);      }    }  }  /**   * Sets the changed flag for this {@code Observable}. After calling   * {@code setChanged()}, {@code hasChanged()} will return {@code true}.   */  protected void setChanged() {    changed = true;  }}

public interface Observer<T> {  public void update(Observable<T> observable, T data);}