程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> Java設計形式開辟中應用不雅察者形式的實例教程

Java設計形式開辟中應用不雅察者形式的實例教程

編輯：關於JAVA

Java設計形式開辟中應用不雅察者形式的實例教程。本站提示廣大學習愛好者：（Java設計形式開辟中應用不雅察者形式的實例教程）文章只能為提供參考，不一定能成為您想要的結果。以下是Java設計形式開辟中應用不雅察者形式的實例教程正文

不雅察者形式是軟件設計形式中的一種，應用也比擬廣泛，特別是在GUI編程中。關於設計形式的文章，收集上寫的都比擬多，並且許多文章寫的也不錯，固然說有一種反復早輪子的嫌疑，但此輪子非彼輪子，著重點分歧，思緒也分歧，講述方法也不近雷同。
症結要素

主題:

主題是不雅察者不雅察的對象，一個主題必需具有上面三個特點。

持有監聽的不雅察者的援用
支撐增長和刪除不雅察者
主題狀況轉變，告訴不雅察者

不雅察者:

當主題產生變更，收到告訴停止詳細的處置是不雅察者必需具有的特點。

為何要用這類形式

這裡舉一個例子來講明，牛奶送奶站就是主題，訂奶客戶為監聽者，客戶從送奶站定閱牛奶後，會天天收到牛奶。假如客戶不想定閱了，可以撤消，今後就不會收到牛奶。

松耦合

不雅察者增長或刪除無需修正主題的代碼，只需挪用主題對應的增長或許刪除的辦法便可。
主題只擔任告訴不雅察者，但無需懂得不雅察者若何處置告訴。舉個例子，送奶站只擔任送遞牛奶，不關懷客戶是喝失落照樣洗臉。
不雅察者只需期待主題告訴，無需不雅察主題相干的細節。照樣誰人例子，客戶只需關懷送奶站送到牛奶，不關懷牛奶由哪一個快遞人員，應用何種交通對象投遞。

Java完成不雅察者形式
1. Java自帶的完成
類圖

/** 
 * 不雅察目的 繼續自 java.util.Observable 
 * @author stone 
 * 
 */ 
public class UpdateObservable extends Observable { 
   
  private int data; 
   
  public UpdateObservable(Observer observer) { 
    addObserver(observer); 
    /* 
     * add other observer 
     */ 
  } 
   
  public int getData() { 
    return data; 
  } 
   
  public void setData(int data) { 
    if (data != this.data) { 
      this.data = data; 
      setChanged(); //標志 轉變, 只要標志後能力告訴到 
      notifyObservers(); //告訴 
    } 
     
  } 
 
  @Override 
  public synchronized void addObserver(Observer o) { 
    super.addObserver(o); 
  } 
 
  @Override 
  public synchronized void deleteObserver(Observer o) { 
    super.deleteObserver(o); 
  } 
 
  @Override 
  public void notifyObservers() { 
    super.notifyObservers(); 
  } 
 
  @Override 
  public void notifyObservers(Object arg) { 
    super.notifyObservers(arg); 
  } 
 
  @Override 
  public synchronized void deleteObservers() { 
    super.deleteObservers(); 
  } 
 
  @Override 
  protected synchronized void setChanged() { 
    super.setChanged(); 
  } 
 
  @Override 
  protected synchronized void clearChanged() { 
    super.clearChanged(); 
  } 
 
  @Override 
  public synchronized boolean hasChanged() { 
    return super.hasChanged(); 
  } 
 
  @Override 
  public synchronized int countObservers() { 
    return super.countObservers(); 
  } 
   
}

/** 
 * 不雅察者 完成 java.util.Observer接口 
 * @author stone 
 * 
 */ 
public class UpdateObserver implements Observer { 
 
  @Override 
  public void update(Observable o, Object arg) { 
    System.out.println("吸收到數據變更的告訴:"); 
    if (o instanceof UpdateObservable) { 
      UpdateObservable uo = (UpdateObservable) o; 
      System.out.print("數據變革為：" + uo.getData()); 
    } 
  } 
 
}

2. 自界說的不雅察模子
類圖

/** 
 * 籠統不雅察者  Observer 
 * 不雅察 更新     
 * @author stone 
 * 
 */ 
public interface IWatcher { 
  /* 
   * 告訴接口： 
   * 1. 簡略告訴 
   * 2. 不雅察者須要目的的變更的數據，那末可以將目的用作參數, 見Java的Observer和Observable 
   */ 
// void update(IWatched watched); 
   
  void update(); 
   
}

/** 
 * 籠統目的 Subject 
 * 供給注冊和刪除不雅察者對象的接口, 及告訴不雅察者停止不雅察的接口 
 * 及目的 本身被不雅察的營業的接口 
 * @author stone 
 * 
 */ 
public interface IWatchedSubject { 
   
  public void add(IWatcher watch); 
 
  public void remove(IWatcher watch); 
   
  public void notifyWhatchers(); 
   
  public void update();//被不雅察營業變更的接口 
}

/** 
 * 詳細不雅察者    Concrete Observer 
 * 
 * @author stone 
 * 
 */ 
public class UpdateWatcher implements IWatcher { 
 
  @Override 
  public void update() { 
    System.out.println(this + "不雅察到：目的曾經更新了"); 
  } 
 
}

/** 
 * 詳細目的腳色  Concrete Subject 
 * @author stone 
 * 
 */ 
public class UpdateWatchedSubject implements IWatchedSubject { 
  private List<IWatcher> list; 
   
  public UpdateWatchedSubject() { 
    this.list = new ArrayList<IWatcher>(); 
  } 
   
  @Override 
  public void add(IWatcher watch) { 
    this.list.add(watch); 
  } 
 
  @Override 
  public void remove(IWatcher watch) { 
    this.list.remove(watch); 
  } 
 
  @Override 
  public void notifyWhatchers() { 
    for (IWatcher watcher : list) { 
      watcher.update(); 
    } 
  } 
   
  @Override 
  public void update() { 
    System.out.println("目的更新中...."); 
    notifyWhatchers(); 
  } 
 
}

監聽器是不雅察者的一種完成：
類圖

/** 
 * 監聽 用戶在注冊後 
 * @author stone 
 * 
 */ 
public interface IRegisterListener { 
  void onRegistered(); 
}

/** 
 * 監聽 當用戶登錄後 
 * @author stone 
 * 
 */ 
public interface ILoginListener { 
  void onLogined(); 
}

/* 
 * 監聽器 是不雅察者形式的一種完成 
 * 一些須要監聽的營業接口上添加 監聽器，挪用監聽器的響應辦法，完成監聽 
 */ 
public class User { 
   
  public void register(IRegisterListener register) { 
    /* 
     * do ... register 
     */ 
    System.out.println("正在注冊中..."); 
    //注冊後 
    register.onRegistered(); 
  } 
 
  public void login(ILoginListener login) { 
    /* 
     * do ... login 
     */ 
    System.out.println("正在登錄中..."); 
    //登錄後 
    login.onLogined(); 
  } 
 
}

/** 
 * 不雅察者(Observer)形式 行動型形式 
 *  不雅察者形式界說了一種一對多的依附關系，讓多個不雅察者對象同時不雅察某一個目的對象。 
 *  這個目的對象在狀況上產生變更時，會告訴一切不雅察者對象，讓它們可以或許主動更新本身 
 * 目的對象中須要有添加、移除、告訴 不雅察者的接口 
 *  
 * @author stone 
 */ 
public class Test { 
   
  public static void main(String[] args) { 
    /* 
     * 應用Java自帶的Observer接口和Observable類 
     */ 
    UpdateObservable observable = new UpdateObservable(new UpdateObserver()); 
    observable.setData(99); 
    System.out.println(""); 
    System.out.println(""); 
    /* 
     * 自界說的不雅察者模子 
     */ 
    IWatchedSubject watched = new UpdateWatchedSubject(); 
    watched.add(new UpdateWatcher()); 
    watched.add(new UpdateWatcher()); 
    watched.update(); 
    System.out.println(""); 
     
    /* 
     * 子形式-監聽器 
     */ 
     
    User user = new User(); 
    user.register(new IRegisterListener() { 
       
      @Override 
      public void onRegistered() { 
        System.out.println("監聽到注冊後。。。"); 
      } 
    }); 
    user.login(new ILoginListener() { 
       
      @Override 
      public void onLogined() { 
        System.out.println("監聽到登錄後。。。"); 
      } 
    }); 
     
  } 
}

打印

吸收到數據變更的告訴: 
數據變革為：99 
 
目的更新中.... 
observer.UpdateWatcher@457471e0不雅察到：目的曾經更新了 
observer.UpdateWatcher@5fe04cbf不雅察到：目的曾經更新了 
 
正在注冊中... 
監聽到注冊後。。。 
正在登錄中... 
監聽到登錄後。。。