用 Java 编写函数？

发布于 2024-08-20 05:29:24 字数 802 浏览 11 评论 0原文

我正在为我们创建的 API 编写演示代码，但我不断遇到同样的问题，一遍又一遍地重复自己，令人作呕。我痛苦地意识到 Java 计划添加闭包，但我现在无法访问它们。以下是我想将其放入自己的小角落中的所有地方重复的内容：

public BarObj Foo(Double..._input){
    try{
        //things that vary per function
        //but everything else...
    } catch(NullException _null){
        m_Logger.error("Null error exception caught in Blah::Foo");

        return null;
    } catch(Exception ex){
        m_Logger.error( ex.getMessage() );

        return null;
    }
}

关于我想到解决此问题的唯一方法是将 Method 传递到函数中它带有 try-catch 逻辑并将其全部包装在另一个函数中，如下所示：

public BarObj MyFunc(Double..._input){
    return compose("MyLogic",_input);
}

private BarObj MyLogic(Double..._input) 
    throws Exception{
    //stuff
}

但它看起来很丑并且带有很多样板。在 Java 中是否有更简单的方法来组合函数？

原文

I'm writing demo code for an API we've created and I keep running into the same problem where I'm repeating myself, over and over ad nauseum. I am painfully aware that Java is scheduled to have closures added but I don't have access to them now. Here is what is repeated all over the place that I'd like to just box into it's own little corner:

public BarObj Foo(Double..._input){
    try{
        //things that vary per function
        //but everything else...
    } catch(NullException _null){
        m_Logger.error("Null error exception caught in Blah::Foo");

        return null;
    } catch(Exception ex){
        m_Logger.error( ex.getMessage() );

        return null;
    }
}

About the only way I've thought to go around this is by passing a Method into a function which carries with it the try-catch logic and wrapping it all up in another function like so:

public BarObj MyFunc(Double..._input){
    return compose("MyLogic",_input);
}

private BarObj MyLogic(Double..._input) 
    throws Exception{
    //stuff
}

but it looks ugly and carries with it a lot of boilerplate. Is there an easier way to compose functions in Java?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

浅暮の光 2024-08-27 05:29:24

在 Java 中，这是非常困难的，因为没有对函数的一流支持（与 clojure 或 scala 以及其他可能不同）。

但是，您可以封装对象中的操作：

interface Function<R, T> {

     R call(T... input);
}

然后将 Foo 重构为：

static <R, T> R runFunction(Function<R, T> function, T ... input){
    try{
       return function.call(input);
    } catch(NullPointerException _null){
       m_Logger.error("Null error exception caught in Blah::Foo");
       return null;
    } catch(Exception ex){
       m_Logger.error( ex.getMessage() );
       return null;
    }
}

testcase：

class SumDoubles implements Function<Double, Double> {

    @Override
    public Double call(Double... input) {
        Double sum = 0.0;

        for (Double d : input) {
            sum += d;
        }

        return sum;
    }
}

@Test
public void sum() {
    Double sum = runFunction(new SumDoubles(), 1.0, 2.0, 3.0);
    assertThat(sum, is(6.0));
}

in Java this is very difficult since there is no first class support for functions (unlike clojure or scala and probably other).

However, you can encapsulate the operation in an object:

interface Function<R, T> {

     R call(T... input);
}

then refactor Foo as:

static <R, T> R runFunction(Function<R, T> function, T ... input){
    try{
       return function.call(input);
    } catch(NullPointerException _null){
       m_Logger.error("Null error exception caught in Blah::Foo");
       return null;
    } catch(Exception ex){
       m_Logger.error( ex.getMessage() );
       return null;
    }
}

testcase:

class SumDoubles implements Function<Double, Double> {

    @Override
    public Double call(Double... input) {
        Double sum = 0.0;

        for (Double d : input) {
            sum += d;
        }

        return sum;
    }
}

@Test
public void sum() {
    Double sum = runFunction(new SumDoubles(), 1.0, 2.0, 3.0);
    assertThat(sum, is(6.0));
}

回复收藏 0 原文