I guess this sort of functionality is not added in any framework/runtime since it would create a big overhead (think on how many times you modify a variable holding a primitive type within the average application) while being not used under normal circunstances.

Anyway, in .NET at least (and I guess that in other OO environments as well), you can define properties, which are accessed as normal variables but can have associated code that reacts when its value is read or modified.

I don t think there is anything by default, however, you can create a custom event and raise it on the set of the method. Something like...

C# example

public delegate void MyValueChangedEventHandler(bool oldValue, bool newValue);
public event MyValueChangedEventHandler MyValueChanged;
private bool myValue;
...

public bool MyValue
{
    get { return myValue; }
    set
    {
        if (myValue != value)
        {
            var old = myValue;
            myValue = value;
            MyValueChanged(old, myValue); 
        }
    }
}

It is possible if you wrap your variables in getters and setters and fire the event when the setter is called.

How about using setter methods and having them register events when changing the value of the variable?

In general, no. The reason is that primitive types are simply bits and bytes stored in some memory location: changing the data in that memory location does just that, and nothing else. Firing events would require calling some methods/functions. So the functionality can be achieved by wrapping the primitive types in some kind of wrapper objects - but of course, they re not 100 % interchangeable: for instance Java s primitive wrapper types (Integer etc.) are marked final, so it s not possible to extend them with event-firing versions to take advantage of auto(un)boxing.

Another approach is to poll the variable frequently and fire appropriate events if it has changed. This is a "dirty" approach with obvious disadvantages (performance overhead, not immediate reaction), but could regardless be useful in some situations. If you do this from another thread in Java, be sure to mark the variable volatile.

It is possible to create listeners, as some of ther others have mentioned, by making a class that fires an event whenever a property changes. This is obviously a lot less efficient than just assigning a value, but there are cases where it could be useful.

Some languages (VB6 and some others) have the ability in debug mode to stop execution when the value of a variable changes. I haven t seen this in .net, but it s liable to be in there somewhere. :-)

It seems to me that using an event to signal a simple variable change could be accomplished with if statements at each assignment, unless the value that variable is being changed externally, in which case you could use a class to handle it.