Equivalente di C # i metodi anonimi in Java?

Question

In C # è possibile definire i delegati anonimo (anche se non sono altro che zucchero sintattico). Ad esempio, posso fare questo:

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

E 'possibile passare codice come questo in Java? Sto utilizzando il framework di elaborazione, che ha una versione piuttosto vecchia di Java (non ha farmaci generici).

Answer 1

Pre Java 8:

Il Java più vicino deve delegati sono interfacce singolo metodo. Si potrebbe utilizzare una classe interna anonima.

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 e sopra:

Java 8 aggiunge espressioni lambda alla lingua.

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

Answer 2

Non è esattamente così, ma Java ha qualcosa di simile.

Si chiama classi interne anonime.

Lasciate che vi faccia un esempio:

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

E 'un po' più prolisso e richiede un'interfaccia per implementare, ma a parte questo è più o meno la stessa cosa

Answer 3

Il vostro esempio sarà simile a questa in Java, utilizzando le classi interne anonime:

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

  

E 'possibile passare codice come questo   in Java? Sto utilizzando il trattamento   quadro, che ha un bel vecchio   versione di Java (che non ha   farmaci generici).

Poiché la questione ha chiesto circa la risposta specifica-Processing, non v'è alcun equivalente diretto. Ma l'elaborazione utilizza il livello di linguaggio Java 1.4 e Java 1.1 ha introdotto le classi interne anonime, che sono una rozza approssimazione.

Answer 5

Ad esempio:

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

Output:

  

Bla Bla: 123

     

Foo Bar: 123

Answer 6

Hai dimenticato tutto qui che un C # delegato prima di tutto - è thread-safe . Questi esempi sono solo per un singolo thread App ..

La maggior parte delle applicazioni contemporanee sono scritte sul concetto di multithread .. Così nessuno risposta è la risposta.

Non c'è un equivalente in Java