IntegerProperty num1 = new SimpleIntegerProperty( 1 );
    IntegerProperty num2 = new SimpleIntegerProperty( 2 );

    NumberBinding sum = num1.add( num2 ); 1
    System.out.println( sum.getValue() );
    num1.set(2);                          2
    int result= sum.getValue();           3
    System.out.println( result );

1. Creates the binding but does NOT compute anything
2. Set the value, and invalidates the value, so observers must recalculate.
3. The get is the observer’s action that actually triggers the actual computation.

    NumberBinding sum = Bindings.add(num1,num2); 1
    System.out.println(sum.getValue());
    num1.setValue(2);                            2
    int result= sum.getValue();                  3
    System.err.println( result );

1. Creates the binding but does NOT compute anything
2. Set the value, and invalidates the value, so observers must recalculate.
3. The get is the observer’s action that actually triggers the actual computation.

IntegerBinding sum( IntegerProperty n1, IntegerProperty n2 ) {
    return new IntegerBinding() {      1

        {                              2
            super.bind( n1, n2 );
        }

        @Override
        protected int computeValue() { 3
            return n1.get()+n2.get();
        }
    };
}

1. Anonymous inner class with IntegerBinding as super class.
2. Anonymous 'constructor' that tells the binding what its dependencies are.
3. The computation, which can be arbitrarily complex, and is only executed if some one ask the super for get(), which will then invoke computeValue(). Note the use of protected, so this method is only callable from within the hierarchy between the IntegerBinding and its anonymous sub class. computeValue is the only abstract method in abstract class IntegerBinding.

class ModifyableSumBinding extends DoubleBinding {

    Set<ObservableDoubleValue> values = new HashSet<>();

    @Override
    protected double computeValue() {
        double result = values.stream()
                .mapToDouble( ObservableDoubleValue::get ).sum();
        return result;
    }

    void add( ObservableDoubleValue v ) {
        unbind( values.toArray( ObservableDoubleValue[]::new ) ); 1
        values.add( v );
        bind( values.toArray( ObservableDoubleValue[]::new ) );
        invalidate();
    }

    void remove( ObservableDoubleValue v ) {
        unbind( values.toArray( ObservableDoubleValue[]::new ) );
        values.remove( v );
        bind( values.toArray( ObservableDoubleValue[]::new ) );
        invalidate();
    }
}

1. Collection.toArray(IntFunction<T[]> generator) is a method introduced in Java 11.

    DoubleBinding lengthBinding( Line aLine ) { 1
        return lengthBindings
            .computeIfAbsent( aLine,
                l -> lengthBinding(
                      l.startXProperty(),
                      l.startYProperty(),
                      l.endXProperty(),
                      l.endYProperty()
                )
            );
    }

1. We use the line object as key in the map

   /**
    * Cache for area binding.
    */
   private DoubleBinding areaBinding = null;

   /**
    * Create a binding to compute the area with a triangle determined by side
    * lengths a, b and c. This method consults the cache
    * and has the value computed if required.
    *
    * @return the area binding
    */
   final DoubleBinding areaBinding() {
       if ( areaBinding == null ) {
           areaBinding =
               areaBinding(
                   distanceBinding( redCircle, greenCircle ), 1
                   distanceBinding( greenCircle, blueCircle ),
                   distanceBinding( blueCircle, redCircle )
                );
       }
       return areaBinding;
   }
   // method that creates the binding is left as an exercise

1. Compute the binding if not yet available.

<AnchorPane id="AnchorPane" fx:id="root" prefHeight="564.0" prefWidth="535.0" stylesheets="@stylesheet.css"
  >
</AnchorPane>

<fx:root type="javafx.scene.Group" xmlns="http://javafx.com/javafx/16"
       xmlns:fx="http://javafx.com/fxml/1"
       >
    <Circle fx:id="redCircle" centerX="10.0" centerY="10.0"
       fill="RED" radius="5.0" />
    <Circle fx:id="greenCircle" centerX="400.0" centerY="10.0"
       fill="GREEN" radius="5.0" />
    <Circle fx:id="blueCircle" centerX="10.0" centerY="400.0"
       fill="BLUE" radius="5.0" />
    <Circle fx:id="centerCircle" fill="GREY" radius="5.0" />
   <Line id="redLine" fx:id="redLine" endX="10.0" endY="400.0"
       startX="400.5" startY="9.5" stroke="RED" />
   <Line id="greenLine" fx:id="greenLine" endX="10.0" endY="400.0"
        startX="10.0" startY="10.0" stroke="GREEN" />
   <Line id="blueLine" fx:id="blueLine" endX="10.0" endY="10.0"
        startX="400.0" startY="10.0" stroke="BLUE" />
   <Label fx:id="redLabel" text="a" />
   <Label fx:id="greenLabel" text="b" />
   <Label fx:id="blueLabel" text="c" />
   <Label fx:id="areaLabel" text="" />
</fx:root>

public class Triangulator extends Group implements Initializable {

    @FXML
    Circle redCircle;
    @FXML
    Circle blueCircle;
    @FXML
    Circle greenCircle;


// stuff left out
    Triangulator( BindingBusiness bb ) {
        this.bb = bb;
        FXMLLoader fxmlLoader =
           new FXMLLoader( getClass().getResource( "triangulator.fxml" ) ); 1

        connectLoader( fxmlLoader ); 2

        try {
            fxmlLoader.load();
        } catch ( IOException exception ) {
            throw new RuntimeException( exception );
        }
    }

    final void connectLoader( FXMLLoader fxmlLoader ) { 3
        fxmlLoader.setRoot( this );
        fxmlLoader.setController( this );
    }

// more stuff left out
}

1. Load the widgets fxml definitions. This will insert all @FXML annotated fields and would attach the actions to the @FXML annotated methods.
2. Connect this to the loaded FXML document.
3. Use a final or private method to set the root and controller of the loaded object to this, to avoid the warning of exposing this in the constructor.