假设我想执行以下命令：
house.getFloor(0).getWall(WEST).getDoor().getDoorknob();
if (house != null && house.getFloor(0) && house.getFloor(0).getWall(WEST) != null
&& house.getFloor(0).getWall(WEST).getDoor() != null) ...
是否有一种方法或已经存在的Utils类可以更优雅地完成这个任务，就像以下代码一样？
checkForNull(house.getFloor(0).getWall(WEST).getDoor().getDoorknob());
Optional类型将使您能够在一系列map操作（其中包含get调用）中进行管道传输。空值检查在幕后自动处理。System.out.println("----- Not Initialized! -----");
Optional.ofNullable(new Outer())
.map(out -> out.getNested())
.map(nest -> nest.getInner())
.map(in -> in.getFoo())
.ifPresent(foo -> System.out.println("foo: " + foo)); //no print
System.out.println("----- Let's Initialize! -----");
Optional.ofNullable(new OuterInit())
.map(out -> out.getNestedInit())
.map(nest -> nest.getInnerInit())
.map(in -> in.getFoo())
.ifPresent(foo -> System.out.println("foo: " + foo)); //will print!
class Outer {
Nested nested;
Nested getNested() {
return nested;
}
}
class Nested {
Inner inner;
Inner getInner() {
return inner;
}
}
class Inner {
String foo = "yeah!";
String getFoo() {
return foo;
}
}
class OuterInit {
NestedInit nested = new NestedInit();
NestedInit getNestedInit() {
return nested;
}
}
class NestedInit {
InnerInit inner = new InnerInit();
InnerInit getInnerInit() {
return inner;
}
}
class InnerInit {
String foo = "yeah!";
String getFoo() {
return foo;
}
}
Optional.ofNullable(house)
.map(house -> house.getFloor(0))
.map(floorZero -> floorZero.getWall(WEST))
.map(wallWest -> wallWest.getDoor())
.map(door -> wallWest.getDoor())
Optional<Door>，这将使您更加安全地工作，而无需担心空指针异常。public static <T> T opt(Supplier<T> statement) {
try {
return statement.get();
} catch (NullPointerException exc) {
return null;
}
}
您可以使用以下语法来调用它：
Doorknob knob = opt(() -> house.getFloor(0).getWall(WEST).getDoor().getDoorknob());
这段代码也是类型安全的，通常按预期工作：
您可以将opt方法放入共享的util类中，并在应用程序的任何地方使用它。
.getFloor(0)时，我会以相同的方式处理IndexOutOfBoundsException。返回一个Optional<T>会更加优雅。 - sanya最好的方法是避免这个链。如果您不熟悉迪米特法则（LoD），我认为您应该了解一下。你提供了一个完美的例子，说明这个消息链与它不应该知道任何信息的类之间关系过于亲密。
当然，你可以将整个表达式包装在try-catch块中，但这是不好的做法。更好的方法是使用空对象模式。使用此模式，如果你的房子没有0楼，它将返回一个像普通楼层一样的楼层，但没有实际内容；当要求不存在的墙时，楼层会返回类似“空”墙等等。
确保那些逻辑上不能为null的事物不为空。例如，房子总是有一面西墙。为了避免状态异常，可以编写方法来检查你希望的状态是否存在：
if (wall.hasDoor()) {
wall.getDoor().etc();
}
这实质上是一个空指针检查，但并不总是如此。
关键是在你有一个null的情况下应该做些什么。例如 - return或抛出IllegalStateException
而你不应该做的事情 - 不要捕获NullPointerException。运行时异常不应该被捕获 - 不能期望从中恢复，也不应该依赖异常来控制逻辑流程。想象一下，你实际上并不希望某个东西为null，然后你捕获（并记录）一个NullPointerException。这将不是非常有用的信息，因为此时许多东西可能为null。
你无法编写一个checkForNull方法来实现这个功能（这不是Java中方法调用和参数评估的工作方式）。
你可以将链式语句分解为多个语句，并在每个步骤检查。然而，也许更好的解决方案是一开始就不要让这些方法返回null。有一种叫做Null Object Pattern的东西，你可能想使用它。
public static <T> void ifPresentThen(final Supplier<T> supplier, final Consumer<T> consumer) {
T value;
try {
value = supplier.get();
} catch (NullPointerException e) {
// Don't consume "then"
return;
}
consumer.accept(value);
}
现在你就能够做到了
ifPresentThen(
() -> house.getFloor(0).getWall(WEST).getDoor().getDoorknob(),
doorKnob -> doSomething());
使用Supplier实现空指针try/catch，您可以将其发送到所有的get链中
public static <T> T getValue(Supplier<T> getFunction, T defaultValue) {
try {
return getFunction.get();
} catch (NullPointerException ex) {
return defaultValue;
}
}
然后以这种方式调用它。
ObjectHelper.getValue(() -> object1.getObject2().getObject3().getObject4()));
虽然这是一个很老的问题，但我仍然想提出我的建议：
我建议你不要在一个方法调用链中从房子深处获取门把手，而是尝试让门把手由调用代码提供给这个类，或者创建一个专门用于此目的的中央查找设施（例如门把手服务）。
松耦合设计的简化示例：
class Architect {
FloorContractor floorContractor;
void build(House house) {
for(Floor floor: house.getFloors()) {
floorContractor.build(floor);
}
}
}
class FloorContractor {
DoorMaker doorMaker;
void build(Floor floor) {
for(Wall wall: floor.getWalls()) {
if (wall.hasDoor()) {
doorMaker.build(wall.getDoor());
}
}
}
}
class DoorMaker {
Tool tool;
void build(Door door) {
tool.build(door.getFrame());
tool.build(door.getHinges());
tool.build(door.getDoorKnob());
}
}