Binding objects in JavaFX

The problem in your code is, that you don't change the property, but only the underlying data. In order to make Property-Bindings recognise your change, you need to set the property:

    A a = new A();

    SimpleObjectProperty aProperty = new SimpleObjectProperty<>(a);
    SimpleObjectProperty bProperty = new SimpleObjectProperty<>(a.b);

    System.out.println(aProperty.get()); // A, because we set it to a.

    aProperty.bind(bProperty);

    System.out.println(aProperty.get()); // null, because a.b is null (and we bound the value from bProperty now)

    bProperty.set(new B()); // Set the bProperty. This will update the aProperty as well, because it is bound to bProperty

    System.out.println(aProperty.get()); 
    // B, because we set bProperty to B, and as aProperty is bound to bProperty, this will change aProperty to it as well.

This is also done in all JavaFX Controls. Just take a look in e.g. TableView:

private ObjectProperty<ObservableList<S>> items = new SimpleObjectProperty<ObservableList<S>>(this, "items");
public final ObjectProperty<ObservableList<S>> itemsProperty() { return items; }
public final void setItems(ObservableList<S> value) { itemsProperty().set(value); }
public final ObservableList<S> getItems() {return items.get(); }

So every setter will set the property. You then can bind the property to another one (or add a listener with addListener to react to changes).

More or less my explanation is similar to @Maran23. You can make the bindings work between observable properties only.

• In the example you provided, the binding is between C.c and a "new SimpleObjectProperty" instance in the Binding class.

• You are updating a.b value, which is not an observable property.

• To get the value reflected in C.c, the value in "new SimpleObjectProperty" should be updated. And this is not possible with your example because the instance is created on fly and there is no reference to update it.

• So to make your example work, create a reference for the observable property you are creating in the ObjectBindingImpl and ensure you update this observable property value.

I would also like to correct one of your assumptions about

"...and then sometime later, it uses the computeValue() method impl to assign it updated value"

It is does not update at some random time. It calls the computeValue only when you explicitly call the "get" method of the observable property. Untill the getter is called, the observable property will be in "invalid" state.

Please find below demo, with the changes I mentioned. Also note that there can be many other efficient ways to let the binding happen, but I am trying to answer your actual OP with the example you provided.

import javafx.beans.binding.ObjectBinding;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.beans.property.SimpleObjectProperty;

public class ObjectBinding_Demo {

    public static void main(String[] args) {
        new ObjectBinding_Demo().init();
    }

    private void init() {
        A a = new A();
        C c = new C();

        ObjectBindingImpl binding = new ObjectBindingImpl(a);
        c.c.bind(binding);
        a.b = new B(20);
        binding.obj.setValue(a.b); // Update the observable property with the new value
        System.out.println("Value set in binding observable property..");
        System.out.println(c.c); // Output:: IntegerProperty [bound, invalid]
        System.out.println(c.c.get()); // Output:: 'Computing value...' string and then 20
        System.out.println(c.c); // Output:: IntegerProperty [bound, value: 20]

    }

    class ObjectBindingImpl extends ObjectBinding {
        private A a;
        ObjectProperty obj; // Observable property reference for future updating.

        public ObjectBindingImpl(A a) {
            this.a = a;
            obj = new SimpleObjectProperty(a.b);
            bind(obj);
        }

        @Override
        protected Object computeValue() {
            System.out.println("Computing value...");
            return a.b == null ? null : a.b.b;
        }
    }

    class A {
        B b = new B(10); // Assigned it value 10.
    }

    class B {
        Integer b;

        B(int b) {
            this.b = b;
        }
    }

    class C {
        SimpleIntegerProperty c = new SimpleIntegerProperty();
    }
}