Fixed some comments.

Author: nicolaiparlog

src/main/java/org/codefx/libfx/nesting/Nesting.java

@@ -21,8 +21,8 @@
  * perhaps most importantly, the last step will lead to the hierarchy's <b>inner observable</b>.
  * <p>
  * As nesting steps require a value to be accessible, all observables on which a step is used must provide a value.
- * Hence they must all implement {@link ObservableValue} (of {@code T}, where {@code T} is no primitive type wrapper or
- * {@code String}). No step is used on the inner observable so it suffices that it implements {@link Observable}.
+ * Hence they must all implement {@link ObservableValue ObservableValue}. No step is used on the inner observable so it
+ * suffices that it implements {@link Observable}.
  * <h3>Example</h3> Consider a class {@code Employee} which has an {@code Property<Address> address}, where
  * {@code Address} has a {@code StringProperty streetName}. There might be a {@code Property<Emplyee> currentEmployee},
  * which always holds the current employee.
@@ -31,15 +31,20 @@
  * the outer observable and {@code address} and {@code streetName} are nested observables. Additionally,
  * {@code streetName} is the inner observable.
  * <h2>Present or Missing Inner Observable</h2> If all steps return non-null observables and none of them contains null,
- * the inner observable can be computed and will be contained in the {@link #innerObservableProperty() innerObservable}
+ * the inner observable can be accessed and will be contained in the {@link #innerObservableProperty() innerObservable}
  * property. In this case it is said to be <b>present</b>. The same is true if only the inner observable contains null.
  * <p>
  * If any nesting step returns null or any observable except the inner contains null as a value, the nesting hierarchy
- * can not be completely computed. The inner observable is said to be <b>missing</b> and the {@code innerObservable}
- * property contains {@link Optional#empty()}.
+ * can not be fully accessed. The inner observable is said to be <b>missing</b> and the {@code innerObservable} property
+ * contains {@link Optional#empty()}.
  * <h2>Evaluation</h2> Nestings will usually be implemented such that they eagerly evaluate the nested observables.
  * <h2>Build</h2> Instances of {@code Nesting} can be created with dedicated builders. These can be obtained by starting
  * with one of the methods in {@link Nestings}. More details can be found there.
+ * <p>
+ * Nestings are also an important building block for creating other nested instances like
+ * {@link org.codefx.libfx.nesting.property.NestedProperty NestedProperty}. A
+ * {@link org.codefx.libfx.nesting.NestingObserver NestingObserver} provides a convenient way to work directly with a
+ * {@code Nesting}.
  *
  * @see Nestings
  * @param <O>

src/main/java/org/codefx/libfx/nesting/NestingObserver.java

@@ -8,7 +8,8 @@
 
 /**
  * Usability class which observes a {@link Nesting} and executes some methods when the nesting's
- * {@link Nesting#innerObservableProperty() innerObservable} changes (in that order):
+ * {@link Nesting#innerObservableProperty() innerObservable} changes. These are the methods and the order in which they
+ * are called:
  * <ol>
  * <li>if the old inner observable was present, a method is called with that observable as its argument; the method is
  * specified during building (see {@link NestingObserverBuilder#withOldInnerObservable(Consumer) withOldInnerObservable})
@@ -18,7 +19,7 @@
  * new observable were/are present; the method is specified during building (see
  * {@link NestingObserverBuilder#whenInnerObservableChanges(BiConsumer) whenInnerObservableChanges})
  * </ol>
- * These methods are also called once after construction. At this point, there is of course no old inner observable
+ * These methods are also called once during construction. At this point, there is of course no old inner observable
  * present.
  * <p>
  * The observer is created with a {@link NestingObserverBuilder} which can be obtained from