檢測整數變化

Question

有什麼辦法可以檢測整數變化嗎？比如創建一個偵聽器來偵聽整數來檢測並更改它的值。我知道這可能與布爾有一些技巧，但我似乎無法適應這個int值。有沒有人有任何想法如何做到這一點？我需要知道如何在Java語言中執行此操作。下面是我在網上找到的允許布爾型監聽器的代碼。我怎樣才能將其轉換爲整數監聽器？

import java.util.List; 
import java.util.ArrayList; 
import java.util.EventListener; 
import java.util.EventObject; 
import java.awt.EventQueue; 

//can u see this austin? can u see this i typed this at 9:33 my time 
/** 
* This class uses the EventQueue to process its events, but you should only 
* really do this if the changes you make have an impact on part of a GUI 
* eg. adding a button to a JFrame. 
* 
* Otherwise, you should create your own event dispatch thread that can handle 
* change events 
*/ 
public class test1 implements BooleanChangeDispatcher { 

    public static void main(String[] args) { 

     BooleanChangeListener listener = new BooleanChangeListener() { // add this to the class 
      @Override 
      public void stateChanged(BooleanChangeEvent event) { 
       System.out.println("Detected change to: " 
        + event.getDispatcher().getFlag() 
        + " -- event: " + event); 
      } 
     }; 

     test1 test = new test1(false); 
     test.addBooleanChangeListener(listener); 

//  test.setFlag(false); // no change, no event dispatch 
//  test.setFlag(true); // changed to true -- event dispatched 

    } 

    private boolean flag; 
    private List<BooleanChangeListener> listeners; 

    public test1(boolean initialFlagState) { 
     flag = initialFlagState; 
     listeners = new ArrayList<BooleanChangeListener>(); 
    } 

    @Override 
    public void addBooleanChangeListener(BooleanChangeListener listener) { 
     listeners.add(listener); 
    } 

    @Override 
    public void setFlag(boolean flag) { 
     if (this.flag != flag) { 
      this.flag = flag; 
      dispatchEvent(); 
     } 
    } 

    @Override 
    public boolean getFlag() { 
     return flag; 
    } 

    private void dispatchEvent() { 
     final BooleanChangeEvent event = new BooleanChangeEvent(this); 
     for (BooleanChangeListener l : listeners) { 
      dispatchRunnableOnEventQueue(l, event); 
     } 
    } 

    private void dispatchRunnableOnEventQueue(
       final BooleanChangeListener listener, 
       final BooleanChangeEvent event) { 

     EventQueue.invokeLater(new Runnable() { 
      @Override 
      public void run() { 
       listener.stateChanged(event); 
      } 
     }); 
    } 

} 

interface BooleanChangeDispatcher { 

    public void addBooleanChangeListener(BooleanChangeListener listener); 
    public boolean getFlag(); 
    public void setFlag(boolean flag); 

} 

/** 
* Listener interface for classes interested in knowing about a boolean 
* flag change. 
*/ 
interface BooleanChangeListener extends EventListener { 

    public void stateChanged(BooleanChangeEvent event); 

} 

/** 
* This class lets the listener know when the change occured and what 
* object was changed. 
*/ 
class BooleanChangeEvent extends EventObject { 

    private final BooleanChangeDispatcher dispatcher; 

    public BooleanChangeEvent(BooleanChangeDispatcher dispatcher) { 
     super(dispatcher); 
     this.dispatcher = dispatcher; 
    } 

    // type safe way to get source (as opposed to getSource of EventObject 
    public BooleanChangeDispatcher getDispatcher() { 
     return dispatcher; 
    } 
} 

Answer 1

我會創建一個能夠註冊監聽器的類。下面是一個模擬的例子。它甚至可以按原樣編譯（假設你編寫相應的VocalIntegerListener接口存在並以某種方式實現......這很簡單）。

class VocalInteger { 

    private int value; 
    private final Object lock = new Object(); 
    Set<VocalIntegerListener> listeners; // assume interface exists - it's easy 


    public VocalInteger() { 
     this(0); 
    } 

    public VocalInteger(int value) { 
     this.value = value; 
     listeners = new HashSet<VocalIntegerListener>(); 
    } 

    public int getValue() { 
     return value; 
    } 

    public void setValue(int value) { 
     synchronized(lock) { 
      int oldValue = this.value; 
      this.value = value; 
      for(VocalIntegerListener listener : listeners) { 
       listener.fireChangedEvent(oldvalue, value); // assume exists 
      } 
     } 
    } 

    public void registerListener(VocalIntegerListener listener) { 
     synchronized(lock) { 
      listeners.add(listener); 
     } 
    } 
} 

Answer 2

看一看「Java組件」和「約束性」爲標準的做法如何偵聽屬性更改事件：

http://docs.oracle.com/javase/tutorial/javabeans/writing/properties.html

http://docs.oracle.com/javase/tutorial/javabeans/