如何在不调用call方法的情况下调用functor对象的函数

Question

I have a functor object:

private static Func1<MyEvent, Observable<Data>> getDataOnEvent = new Func1<MyEvent, Observable<Data>>() {
    @Override
    public Observable<Data> call(MyEvent event) {
        return ApiFactory.get().getData()
    }
};

For its invoking I need to do this:

result = getDataOnEvent.call(someEvent)

Is it possible to do this instead:

result = getDataOnEvent(someEvent)

Like it is done with Python and Javascript? Maybe a new version of java OR some library like Lombok?

Answer 1

Just use,

private static Observable<Data> getDataOnEvent(MyEvent event) {
    return ApiFactory.get().getData()
}

and you can call result = getDataOnEvent(someEvent); whenever you need it. As you can see, writing it this way, will save even more boiler code than the five letters .call on the invocation side.

If Func1 is a functional interface, you can use ContainingClass::getDataOnEvent wherever a Func1<MyEvent, Observable<Data>> is expected. You can also store it into a static variable, if you prefer using the simple identifier getDataOnEvent as function:

private static Func1<MyEvent, Observable<Data>> getDataOnEvent
                                              = ContainingClass::getDataOnEvent;

Then you can use getDataOnEvent(event) to call it or getDataOnEvent to refer to it as a Func1 instance whenever you need it.

If Func1 is not a functional interface, then you can't create the function in this compact form, but on the other hand, in that case it wouldn't be reasonable to ask for a support for calling an arbitrary method without naming it explicitly, either.

Answer 2

I know what you mean, groovy code call a closure like this:

def code = { 123 };

//can be called like any other method if the variable is a closure.
assert code() == 123;
//can be call explicitly by using `call` method
assert code.call() == 123;

javascript code call a function like this:

let code = () => 123;

//can be called like any other function if the variable is a function.
assert code() == 123;
//can be call explicitly by using `call` method
assert code.call() == 123;

But I can tell you java gammar not support this feature for fields/variables, maybe in the next jdk will be enable this feature which a field/variable refer to Callable .

Fortunately, Single-Static-Import Declarations supports calling a method directly if the static member is a method, for example:

import static java.lang.Math.abs;

assert abs(-1) == 1;

If you really want to make an identifier called like a method call, you can fake something like this:

class ApiFactory {

    public static Func1<MyEvent, Observable<Data>> getDataOnEvent = new Func1<MyEvent, Observable<Data>>() {
        public Observable<Data> call(MyEvent event) {
            return ApiFactory.get().getData();
        }
    };

    public static Observable<Data> getDataOnEvent(MyEvent event) {
        return getDataOnEvent.call(event);
    }

}

then you can call like this:

import static ${package}.ApiFactory.getDataOnEvent;
// which is calling a static method
result = getDataOnEvent(event);
// which is calling a static field
result = getDataOnEvent.call(event);