Java設計模式-回撥函式和觀察者模式

luoj_616發表於2018-02-23
Java設計模式函式

Android的框架中有非常多的地方使用了回撥的模式，例如Activity的生命週期，按鈕的點選事件等。

下面是回撥的基本模型：

[java] view plain copy
  1. public class A {  
  2.     private CallBack callback;  
  3.     //註冊一個事件  
  4.     public void register(CallBack callback){  
  5.         this.callback = callback;  
  6.     }  
  7.     // 需要呼叫的時候回撥  
  8.     public void call(){  
  9.         callback.oncall();  
  10.     }  
  11. }  
[java] view plain copy
  1. public interface CallBack {  
  2.     public void oncall();  
  3. }  
[java] view plain copy
  1. public static void main(String[] args) {  
  2.     A a = new A();  
  3.     a.register(new CallBack() {  
  4.         @Override  
  5.         public void oncall() {  
  6.             System.out.println("回撥函式被呼叫");  
  7.         }  
  8.     });  
  9.     a.call();  
  10. }  

如果把類A改成Button，CallBack改成OnClickListener，register函式改成setOnclickListener，和android裡面設定點選事件是一樣的。callback.oncall();只是在點選事件激發後呼叫而已。


觀察者模式：

定義物件間的一對多的依賴關係，當一個物件狀態發生改變時，所有依賴他的物件都得到通知並被自動更新。

目標：

[java] view plain copy
  1. public class Subject {  
  2.   
  3.     List<Observer> lists = new ArrayList<Observer>();  
  4.       
  5.     //註冊一個事件  
  6.     public void register(Observer observer){  
  7.         lists.add(observer);  
  8.     }  
  9.   
  10.     public void _notify(){  
  11.         for (Observer observer : lists) {  
  12.             observer.update();  
  13.         }  
  14.     }  
  15.       
  16.     public void unRegister(Observer observer){  
  17.         lists.remove(observer);  
  18.     }  
  19. }  

觀察者抽象介面
[java] view plain copy
  1. public interface Observer {  
  2.     public void update();  
  3. }  
觀察者1
[java] view plain copy
  1. public class ConcreteObserver1 implements  Observer{  
  2.   
  3.     public void update() {  
  4.         System.out.println("ConcreteObserver1獲得更新");  
  5.     }  
  6. }  
觀察者2
[java] view plain copy
  1. public class ConcreteObserver2 implements  Observer{  
  2.   
  3.     public void update() {  
  4.         System.out.println("ConcreteObserver2獲得更新");  
  5.     }  
  6. }  

[java] view plain copy
  1. public static void main(String[] args) {  
  2.     Observer observer1 = new ConcreteObserver1();  
  3.     Observer observer2 = new ConcreteObserver2();  
  4.     Subject subject = new Subject();  
  5.     subject.register(observer1);  
  6.     subject.register(observer2);  
  7.     subject._notify();  
  8.     //取消觀察者1的註冊  
  9.     subject.unRegister(observer1);  
  10.     subject._notify();  
  11. }  
目標物件儲存了各個觀察者的引用，當需要通知時傳送通知。
實際上，回撥是觀察者模式的簡單形式。觀察者模式也就是將回撥上升到設計模式的理論高度上了而已。
將回撥例子中的main方法改成        
[html] view plain copy
  1. public static void main(String[] args) {  
  2.     CallBack callback = new CallBackImp();  
  3.     A a = new A();  
  4.     a.register(callback);  
  5.     a.call();  
  6. }  
增加CallBack的實現類CallBackImp
[java] view plain copy
  1. public class CallBackImp implements CallBack{  
  2.     @Override  
  3.     public void oncall() {  
  4.         System.out.println("回撥函式被呼叫");  
  5.     }  
  6. }  
這樣看來，是一致的，區別是觀察者模式裡面目標類維護了所有觀察者的引用，而回撥裡面只是維護了一個引用。

原文地址：http://blog.csdn.net/cauchyweierstrass/article/details/44593807
            




相關文章