Componer funciones en Java?

Question

Estoy escribiendo código de demostración de una API que hemos creado y sigo corriendo en el mismo problema donde yo estoy repitiendo, una y otra vez hasta la saciedad. Soy consciente de que Java está programado para tener cierres añadido pero no tienen acceso a ellos ahora. Esto es lo que se repite por todo el lugar que me gustaría a la caja solo en su propio pequeño rincón:

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

Acerca de la única manera que he pensado para ir de evitar esto es haciendo pasar una Method en una función que lleva consigo la lógica try-catch y envolviendo todo en otra función de este modo:

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

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

pero se ve feo y lleva consigo una gran cantidad de texto modelo. ¿Hay una manera más fácil para componer funciones en Java?

Answer 1

en Java esto es muy difícil ya que no hay soporte de primera clase para las funciones (a diferencia de clojure o Scala y probablemente otros).

Sin embargo, puede encapsulado la operación en un objeto:

interface Function<R, T> {

     R call(T... input);
}

entonces refactorizar Foo como:

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

caso_prueba:

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

Trate lambdaj . Permite añadir un poco de FP a Java de una manera muy ligera y fácil de leer. En particular, en esta página href="http://code.google.com/p/lambdaj/wiki/Closures" rel="nofollow se puede encontrar un ejemplo muy similar a lo usted está tratando de lograr,

Answer 3

Esto es obviamente su llamada, pero con la mayoría de las demostraciones del API he utilizado yo prefiero el formato más largo que usted tiene en la parte superior. Después miro el código Me suelen hacer copiar y pegar para verificar las obras de API como creo que lo hace entonces modificar desde allí. Cambiar el formato para ocultar algunas de las piezas repetative es definitivamente lo que quiere hacer para el desarrollo OO, pero creo que este código un poco de demostración es algo que los 'dioses' código limpio entenderían :-).

Answer 4

No hay manera de hacer esto en Java, pero trate de usar maravilloso si es posible para usted. La otra opción que puede tener envoltorio similar está usando aspecto. ver aspectj .

Answer 5

He aprendido la forma de hacerlo en Java es crear una interfaz que tiene un método. En su código utiliza las clases que implementan la interfaz.