I assume this should have been feeling.

I don't think JNI can do it.

I you can modify class B then you can create a class
tha extends class A and do the notification in an
overriden smile method.

If modifying source code is banned, but modifying
byte code is OK, then you could look at AOP and AspectJ.

Arne

What you want is probably the observer pattern:

public interface Observer<T> {
    public void notice (T object);
}

public final class Observable<T> {
    private T object;
    private Set<Observer<? super T>> observers;
    public Observable (T object) {
        this.object = object;
        observers = new HashSet<Observer<? super T>>;
    }
    public T get () { return object; }
    public void set (T object) {
        this.object = object;
        for (Observer<? super T> observer : observers)
            observer.notice(object);
    }
    public void addObserver (Observer<? super T> observer) {
        observers.add(observer);
    }
    public void removeObserver (Observer<? super T> observer) {
        observers.remove(observer);
    }
}

class A {
    private Observable<String> feeling =
        new Observable<String>(":-(");
    public void smile () {
        feeling.set(":-)");
    }
    public void addFeelingObserver
        (Observer<? super String> observer) {
            feeling.addObserver(observer);
    }
    public void removeFeelingObserver
        (Observer<? super String> observer) {
            feeling.removeObserver(observer);
    }
    public String getCurrentFeeling () {
        return feeling.get();
    }
}

public class StdoutObserver implements Observer<Object> {
    public void notice (Object object) {
        System.out.println("Changed to " + object);
    }
}

class B {
    public static void main (String[] args) {
        A a = new A();
        A.addFeelingObserver(new StdoutObserver());
        A.smile();    // Prints "Changed to :-)"
    }
}

The beauty of this is that you can extend this easily. If something else
wants notification of feeling changing it can call an A's
addFeelingObserver as well, and nothing else needs to be changed (in A
or B or anywhere else). You can add new methods in A that change the
feeling using feeling.set(whatever) and the observers are automatically
notified without your having to remember to put a bunch of notifying
calls in the new method; the need to notify is encapsulated in the
Observable.set method, and because there's no other way to change the
field, you can't forget even to do that. The getCurrentFeeling method in
A demonstrates that A can access and use the field's value as needed.

And you can observe if any field changes by making it an Observable<Foo>
instead of a Foo and putting (at least) an addFooObserver method that
takes an Observer<? super Foo>.

You can even make A itself observable and make changing feeling notify
A's observers: make A's constructor private, provide a static factory
method A.getInstance such as

public static Observable<A> getInstance () {
    final A a = new A();
    Observable<A> result = new Observable<A>(a);
    a.observer = result;
    a.addFeelingObserver(new Observer<String>() {
        public void notify (String s) {
            a.observer.set(a);
        }
    }
    return result;
}

A now needs a private "observer" field of type Observer<A> and that's
it! This uses an anonymous inner class to observe A's feeling, which
references the "a" local variable in the getInstance method. "a" has to
be final for this to work, but that's no problem. It gets bound to the
same instance of A whose feeling the instance of the anonymous inner
class is observing, and a new one gets bound to a new instance of that
observer each time the method runs. The observer notices the string
change and just changes the Observable<A> the factory method returned to
refer to the same A it already did refer to. This doesn't change
anything, except that the set method notifies anything the factory
method's caller set to observing A. If A's own observers check
getCurrentFeeling() they will discover that it has been altered.

The caveat is that if you create a separate Observable<A> wrapping the A
(e.g. new Observable<A>(A.getInstance().get())) that one will not be
notified if the feeling changes. Only the one Observable<A> directly
returned by getInstance will.