Observer設計模式的有點：解除了觀察者與被觀察者之間的耦合關係，被觀察者不需要知道觀察者的任何資訊。被觀察者只需要允許觀察者監聽相應的事件，被觀察者可以有多個觀察者。簡單的理解為觀察者實在監聽被觀察者狀態的改變。被觀察者簡單的將事件傳遞給每一個觀察者。

    （二）.程式碼簡單實現

     a.定義一個觀察者介面

1. publicinterface Observer {  
2.     publicvoid update();  
3. } 
   

1. publicclass Observer1 implements Observer {
   
2.     @Override
3.     publicvoid update() {  
4.         System.out.println("觀察者1");  
5.     }  
6. } 
   

1. publicclass Observer2 implements Observer {  
2.     @Override
3.     publicvoid update() {  
4.         System.out.println("觀察者2"
   );  
5.     }
   
6. } 
   

Subject介面及實現類：

1. publicinterface Subject {  
2.     /*增加觀察者*/
3.     publicvoid add(Observer observer);  
4.     /*刪除觀察者*/
5.     publicvoid del(Observer observer);  
6.     /*通知所有的觀察者*/
7.     publicvoid notifyObservers();  
8.     /*自身的操作*/
9.     publicvoid operation();  
10. }  

1. publicabstractclass AbstractSubject implements Subject {
   
2.     private Vector<Observer> vector = new Vector<Observer>();  
3.     @Override
4.     publicvoid add(Observer observer) {  
5.         vector.add(observer);  
6.     }  
7.     @Override
8.     publicvoid del(Observer observer) {  
9.         vector.remove(observer);  
10.     }  
11.     @Override
12.     publicvoid notifyObservers() {  
13.         Enumeration<Observer> enumo = vector.elements();  
14.         while(enumo.hasMoreElements()){  
15.             enumo.nextElement().update();  
16.         }  
17.     }  
18. }  

1. publicclass MySubject extends AbstractSubject {  
2.     @Override
3.     publicvoid operation() {  
4.         System.out.println("自身操作");  
5.         notifyObservers();  
6.     }  
7. }  
   

程式主入口：

1. publicclass ObserverTest {  
2.     publicstaticvoid main(String[] args) {  
3.         Subject sub = new MySubject();  
4.         sub.add(new Observer1());  
5.         sub.add(new Observer2());        
   
6.         sub.operation();  
7.     }  
8. }

自身操作
觀察者1
觀察者2

    最後程式碼沒有多複雜，多加用斷點跟程序序就能接單的瞭解觀察者模式！