Equivalente de C # los métodos anónimos en Java?

Question

En C # se puede definir de forma anónima delegados (a pesar de que no son nada más que el azúcar sintáctica). Por ejemplo, yo puedo hacer esto:

public string DoSomething(Func<string, string> someDelegate)
{
     // Do something involving someDelegate(string s)
} 

DoSomething(delegate(string s){ return s += "asd"; });
DoSomething(delegate(string s){ return s.Reverse(); });

¿Es posible pasar código como este en Java? Estoy usando el marco de procesamiento, que tiene una versión muy antigua de Java (que no tiene los genéricos).

Answer 1

Pre Java 8:

El más cercano de Java tiene que delegados son interfaces de métodos individuales. Se podría utilizar una clase interna anónima.

interface StringFunc {
   String func(String s);
}

void doSomething(StringFunc funk) {
   System.out.println(funk.func("whatever"));
}

doSomething(new StringFunc() {
      public String func(String s) {
           return s + "asd";
      }
   });


doSomething(new StringFunc() {
      public String func(String s) {
           return new StringBuffer(s).reverse().toString();
      }
   });

---

Java 8 y superior:

Java 8 añade expresiones lambda a la lengua.

    doSomething((t) -> t + "asd");
    doSomething((t) -> new StringBuilder(t).reverse().toString());

Answer 2

No es exactamente así, pero Java tiene algo similar.

Se llama clases internas anónimas.

Te voy a dar un ejemplo:

DoSomething(new Runnable() {
   public void run() {
       // "delegate" body
   }
});

Es un poco más detallado y requiere una interfaz de implementar, pero aparte de eso es más o menos lo mismo

Answer 3

Su ejemplo se vería así en Java, usando clases internas anónimas:

interface Func {
    String execute(String s);
}

public String doSomething(Func someDelegate) {
    // Do something involving someDelegate.execute(String s)
}

doSomething(new Func() { public String execute(String s) { return s + "asd"; } });
doSomething(new Func() { public String execute(String s) { return new StringBuilder(s).reverse().toString(); } } });

Answer 4

  

¿Es posible pasar un código como éste   en Java? Estoy usando el procesamiento   marco, que tiene una bastante antiguo   versión de Java (que no tiene   genéricos).

Dado que la pregunta le preguntó sobre la respuesta de Proceso específica, no existe un equivalente directo. Pero Processing utiliza el nivel de lenguaje Java 1.4 y Java 1.1 introdujo clases internas anónimas, que son una aproximación.

Answer 5

Por ejemplo:

public class Delegate
{
    interface Func
    {
        void execute(String s);
    }

    public static void doSomething(Func someDelegate) {
        someDelegate.execute("123");
    }

    public static void main(String [] args)
    {

        Func someFuncImplementation = new Func() 
        {
            @Override
            public void execute(String s) {
                System.out.println("Bla Bla :"  + s);
            }
        };

        Func someOtherFuncImplementation = new Func() 
        {
            @Override
            public void execute(String s) {
                System.out.println("Foo Bar:"  + s);
            }
        };


        doSomething(someFuncImplementation);
        doSomething(someOtherFuncImplementation);
    }
}

Salida:

  

Bla Bla: 123

     

Foo Bar: 123

Answer 6

Todos han olvidado aquí que un C # en primer lugar delegado - es hilo de seguridad . Estos ejemplos son sólo para un solo hilo App ..

La mayoría de las aplicaciones actuales están escritos en el concepto de multiproceso .. Así que hay una sola respuesta es la respuesta.

No hay un equivalente en Java