检测整数变化

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/