Optional.of(new Outer())
  .map(Outer::getNested)
  .map(Nested::getInner)
  .map(Inner::getFoo)
  .ifPresent(System.out::println);

Optional.of(outerObject).else(LOG.error("Outer was null"))
  .map(Outer::getNested).else(LOG.error("Nested was null"))
  .map(Nested::getInner).else(LOG.error("Inner was null"))
  .map(Inner::getFoo).else(LOG.error("Foo was null"))
  .ifPresent(System.out::println);

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer(new Nested(new Inner("value")));
//        Outer outer = new Outer(new Nested(new Inner(null)));
//        Outer outer = new Outer(new Nested(null));
//        Outer outer = new Outer(null);
//        Outer outer = null;
        try {
            Optional.ofNullable(outer).or(() -> throwEx("Outer was null"))
                    .map(Outer::nested).or(() -> throwEx("Nested was null"))
                    .map(Nested::inner).or(() -> throwEx("Inner was null"))
                    .map(Inner::foo).or(() -> throwEx("Foo was null"))
                    .ifPresent(System.out::println);
        } catch (NullValueException e) {
            System.out.println(e.getMessage());
        }
    }
    private static <T> T throwEx(String msg) {
        throw new NullValueException(msg);
    }
}
class NullValueException extends RuntimeException {
    public NullValueException(String msg) {
        super(msg);
    }
}
record Outer(Nested nested) {
}
record Nested(Inner inner) {
}
record Inner(String foo) {
}

如果这只是一次性的事情，我会编写一个帮助方法来“包装”方法引用。包装器将返回包装的函数返回的内容，但如果包装的方法返回null，它还会记录一条消息。
```java
private static <T, R> Function<T, R> withNullMessage(Function<? super T, ? extends R> function, String message) {
    return t -> {
        R r = function.apply(t);
        if (r == null) {
            Log.error(message);
        }
        return r;
    };
}

Optional.of(foo)
        .map(withNullMessage(Foo::getBar, "Bar is null!"))
        .map(withNullMessage(Bar::getBaz, "Baz is null!"))
        ...

Optional.of("")
        .map(withNullMessage(x -> foo, "Foo is null!"))
        .map(withNullMessage(Foo::getBar, "Bar is null!"))
        .map(withNullMessage(Bar::getBaz, "Baz is null!"))

.flatMap(withNullMessage(Foo::thisReturnsAnotherOptional, "...")

<details>
<summary>英文:</summary>
If this is a one-off thing, I would write a helper method that &quot;wraps&quot; the method references. The wrapper would return what the wrapped function returns, but if the wrapped method returns null, it also logs a message.

Note that this does not handle the case where `foo` is null. If `foo` is null, this will throw an exception. To handle this, you can start with a definitely-not-null thing,

Or you can write your own `of` that logs nulls.
Another drawback of this is that it doesn't work with `flatMap`s. e.g. this does not work as you'd expect:
    .flatMap(withNullMessage(Foo::thisReturnsAnotherOptional, "..."))
You would need another wrapper method to handle that case.
If you need this sort of thing a lot, it's probably worth it to write your own `Optional`-like type, whose `map` methods take an extra argument.
</details>
# 答案3
**得分**: 1
根据前面清扫工的答案中提到的一次性错误算法，我们可以实现如下。这将处理角落的空值情况以及其他情况：
```java
public static void clientMethod() {
    Outer validOuter = new Outer(new Nested(new Inner("s")));
    Outer nullNested = new Outer(new Nested(null));
    Optional.ofNullable(nullNested)
            .map(outer -> eam(outer, Function.identity(), "提取的值：Outer 为 null"))
            .map(outer -> eam(outer, Outer::getNested, "提取的值：Nested 为 null"))
            .map(nested -> eam(nested, Nested::getInner, "提取的值：Inner 为 null"))
            .map(inner -> eam(inner, Inner::getFoo, "提取的值：Foo 为 null"))
            .ifPresent(System.out::println);
}
public static <T, R> R eam(T object, Function<T, R> extractor, String extractedValueNullMessage) {
    if (object != null) {
        R extractedValue = extractor.apply(object);
        if (extractedValue == null) {
            LOG.error(extractedValueNullMessage);
        }
        return extractedValue;
    }
    return null;
}