Fonctions en Java Composer?

Question

Je vous écris du code de démonstration pour une API que nous avons créé et je continue à courir dans le même problème où je me répète, encore et ad nauseam. Je suis douloureusement conscient que Java est prévu d'avoir des fermetures supplémentaires mais je ne pas avoir accès à eux maintenant. Voici ce qui se répète partout que je voudrais boîte juste dans son propre petit coin:

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

A propos de la seule façon que je l'ai pensé pour aller contourner ce problème est en passant un Method dans une fonction qui porte avec elle la logique try-catch et enveloppant le tout dans une autre fonction comme ceci:

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

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

mais il semble laid et porte avec lui beaucoup de passe-partout. Y at-il un moyen plus facile de composer des fonctions en Java?

Answer 1

en Java ce qui est très difficile, car il n'y a pas soutien de première classe pour les fonctions (contrairement Clojure ou scala et probablement d'autres).

Cependant, vous pouvez encapsulent l'opération dans un objet:

interface Function<R, T> {

     R call(T... input);
}

factoriser puis Foo comme:

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

Answer 2

lambdaj . Il permet d'ajouter un peu de FP à Java de manière assez léger et facile à lire. En particulier dans cette de href="http://code.google.com/p/lambdaj/wiki/Closures" vous pouvez trouver un exemple très semblable à ce que vous essayez d'atteindre,

Answer 3

Ceci est évidemment votre appel, mais avec la plupart des démos API je l'ai utilisé, je préfère le format plus que vous avez en tête. Après je regarde le code que je fais généralement copier-coller à vérifier les travaux de l'API comme je pense qu'il ne modifie alors à partir de là. Modification du format pour cacher quelques-unes des pièces est certainement ce que répétitive que vous voulez faire pour le développement OO, mais je pense que ce code démo est un peu quelque chose que les « dieux de code propres » comprendraient :-).

Answer 4

Il n'y a pas moyen de le faire en Java, mais essayez d'utiliser groovy s'il est possible pour vous. L'autre option, vous pouvez avoir l'emballage similaire en utilisant aspect. voir aspectj .

Answer 5

J'ai appris la façon dont cela se fait en Java est de créer une interface qui a une méthode. Dans votre code que vous utilisez des cours de mise en œuvre de cette interface.