Comment appeler la fonction des objets foncteur sans invoquer la méthode d'appel

Question

J'ai un objet foncteur:

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

Pour son invocation que je dois faire ceci:

result = getDataOnEvent.call(someEvent) 

Est-il possible de le faire à la place:

result = getDataOnEvent(someEvent) 

Comme il est fait avec Python et Javascript? Peut-être une nouvelle version de Java OU une bibliothèque comme Lombok?

Answer 1

utiliser juste,

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

et vous pouvez appeler result = getDataOnEvent(someEvent); chaque fois que vous en avez besoin. Comme vous pouvez le voir, en écrivant de cette façon, vous économiserez encore plus de code de chaudière que les cinq lettres .call du côté de l'invocation.

Si Func1 est une interface fonctionnelle, vous pouvez utiliser ContainingClass::getDataOnEvent partout où un Func1<MyEvent, Observable<Data>> est prévu. Vous pouvez également enregistrer dans une variable static, si vous préférez utiliser l'identifiant simple, getDataOnEvent en fonction:

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

Ensuite, vous pouvez utiliser getDataOnEvent(event) appeler ou getDataOnEvent de s'y référer comme Func1 exemple chaque fois que vous en avez besoin .

Si Func1 n'est pas une interface fonctionnelle, alors vous ne pouvez pas créer la fonction sous cette forme compacte, mais d'autre part, dans ce cas, il ne serait pas raisonnable de demander un support pour appeler une méthode arbitraire sans le nommer explicitement non plus.

Answer 2

Je sais ce que vous entendez, le code groovy call a closure comme ceci:

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; 

code javascript call a function comme ceci:

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; 

Mais je peux vous dire java Gammar pas en charge cette fonctionnalité pour les champs/variables, peut-être dans le prochain jdk sera activer cette fonctionnalité dont un champ/variable se référer à Callable.

Heureusement, Single-Static-Import Declarations soutient appeler une méthode directement si le membre statique est une méthode, par exemple:

import static java.lang.Math.abs; 

assert abs(-1) == 1; 

Si vous voulez vraiment faire un identifiant appelé comme un appel de méthode, vous pouvez faux quelque chose comme ceci:

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); 
    } 

} 

vous pouvez appeler comme ceci:

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