funzioni di comporre in Java?

Question

Sto scrivendo il codice demo per un'API che abbiamo creato e continuo a correre nello stesso problema in cui mi sto ripetendo, più e più volte fino alla nausea. Sono dolorosamente consapevole che Java è previsto per avere chiusure aggiunto ma non hanno accesso a loro ora. Ecco cosa si ripete in tutto il posto che mi piacerebbe box solo in essa la propria piccolo angolo:

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

Circa l'unico modo che ho pensato di andare in giro questo è passando un Method in una funzione che porta con sé la logica try-catch e avvolgendo tutto in un'altra funzione in questo modo:

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

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

ma sembra brutto e porta con sé un sacco di testo standard. C'è un modo più semplice per comporre le funzioni in Java?

Answer 1

in Java questo è molto difficile in quanto non v'è alcun supporto di prima classe per le funzioni (a differenza clojure o Scala e probabilmente altri).

Tuttavia, puoi incapsulare l'operazione in un oggetto:

interface Function<R, T> {

     R call(T... input);
}

quindi refactoring Foo come:

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 . Esso consente di aggiungere un po 'di FP a Java in modo abbastanza chiaro e leggibile. In particolare in questa pagina href="http://code.google.com/p/lambdaj/wiki/Closures" rel="nofollow potete trovare un esempio molto simile a quello che si sta cercando di ottenere,

Answer 3

Questa è ovviamente la chiamata, ma con la maggior parte delle API demo ho usato io preferisco il formato più che si ha in alto. Dopo Guardo il codice Io di solito faccio copia-e-incolla per verificare le opere di API come penso lo fa quindi modificare da lì. Cambiare il formato per nascondere alcuni dei pezzi ripetitivi è sicuramente quello che si vuole fare per lo sviluppo OO ma penso che questo codice genere di demo è qualcosa che i 'dèi codice pulito' avrebbero capito :-).

Answer 4

Non c'è modo di fare questo in Java, ma provare a utilizzare Groovy se è possibile per voi. L'altra opzione è possibile avere involucro simile è usando aspetto. vedi aspectj .

Answer 5

Ho imparato il modo in cui questo viene fatto in Java è quello di creare un'interfaccia che ha un metodo. Nel codice si utilizzano le classi che implementano l'interfaccia.