如果对象（或任何函数结果）为空，则调用函数应返回默认值

Question

是否可以将以下代码包装在可重用函数中？

编辑： 这只是一个例子，我想要一个适用于所有递归深度的工作解决方案

我想要的是生成以下代码：

if (MyObject o == null || 
    o.getSubObject() == null ||
    o..getSubObject().getSubSubObject() == null /*|| 
    ... */)
    return defaultValue;
return o.getSubObject().getSubObject()/*...*/.getDesiredValue();

通过调用类似的东西

Object defaultValue = null;
Object result = NullSafeCall(o.getSubObject().getSubObject()/*...*/.getDesiredValue(), defaultValue);

第二个代码块只是一个想法，我不在乎它看起来如何，我想要的是，如果需要，我可以在调用更深层次的函数之前避免所有 null 检查...

注入可以适当地做到这一点，但是没有其他/更简单的解决方案吗？以前从未看过注射...

EDIT2： 另一种语言的示例：http://groovy.codehaus.org/Operators#Operators-SafeNavigationOperator

Answer 1

并非如此，您以这种方式编写的任何代码都会看起来很糟糕和/或使用非常缓慢的反射。除非您使用可以理解和更改您编写的代码的实际 Java 预处理器。

更好的（但与相当多的重构相关）方法是确保有问题的值不可能为空。例如，您可以将各个访问器（getSubObject()、getDesiredValue()）修改为从不返回 null：让它们返回默认值。默认值上的访问器依次返回默认值。

Answer 2

你可以这样做

public static Object  NullSafeCall(MyObject o,Object defaultValue){
    if ( o == null || o.getSubObject() == null)
    {
        return defaultValue;
    }
    else 
    {
        return o.getSubObject().getDesiredValue();
    }
}

现在你可以如下调用这个方法

 Object result = NullSafeCall(o, defaultValue);

Answer 3

我建议只替换

Object result = NullSafeCall(o.getSubObject().getDesiredValue(), defaultValue);

由

Object result = (o == null || o.subObject == null) ? defaultVlue : o.getSubObject().getDesiredValue();

只有在可以重复使用的情况下才创建方法......

Answer 4

你想要的都是不可能的。必须了解使用以下语法：Object result = NullSafeCall(o.getSubObject().getSubObject() ...); o.getSubObject().getSubObject() 的部分将在任何控制传递给函数/方法从而引发异常之前进行评估。

在执行此类代码之前需要有某种类型的上下文。我能想到的最接近这个的，可以使用匿名内部类来完成，如下例所示：

// intended to be implemented by an anonymous inner class
interface NullSafeOperation<T> {
    public T executeSafely();
};

// our executor that executes operations safely
public static class NullSafeExecutor<T> {
    public NullSafeExecutor() {}

    public T execute(T defaultValue, NullSafeOperation<T> nso) {
        T result = defaultValue;
        try {
            result = nso.executeSafely();
        } catch(NullPointerException e) {
            // ignore
        }
        return result;
    }

    // utility method to create a new instance and execute in one step
    public static <T> T executeOperation(T defaultValue, NullSafeOperation<T> nso) {
        NullSafeExecutor<T> e = new NullSafeExecutor<T>();
        T result = e.execute(defaultValue, nso);
        return result;
    }
}


public static void main(String[] args) {

    final String aNullString = null;

    String result = NullSafeExecutor.executeOperation("MyDefault", new NullSafeOperation<String>() {
        @Override
        public String executeSafely() {
            // trying to call a method on a null string
            // it will throw NullPointerException but it will be catched by the executor
            return aNullString.trim(); 
        }
    });

    System.out.println("Output = " + result); // prints: Output = MyDefault
}

Answer 5

Java8 有助于以我怀疑的良好性能获得最接近您的语法；

// Evaluate with default 5 if anything returns null.
int result = Optional.eval(5, o, x->x.getSubObject(), x->x.getDesiredValue());

这可以通过这个实用程序类来完成；

class Optional {
    public static <T, Tdef, T1> Tdef eval(Tdef def, T input, Function<T,T1> fn1,
                                          Function<T1, Tdef> fn2)
    {
        if(input == null) return def;
        T1 res1 = fn1.apply(input);
        if(res1 == null) return def;
        return fn2.apply(res1);
    }
}

遗憾的是，您需要为链中的方法调用次数定义一个单独的 eval()，因此您可能需要定义一些，但编译时类型安全且可重用，几乎可以用于任何调用/类型。