Puntatori di funzioni in Java

Questo può essere qualcosa di comune e banale, ma mi sembra di avere problemi a trovare una risposta concreta. In C # esiste un concetto di delegati, che è fortemente correlato all'idea di puntatori a funzioni di C ++. Esiste una funzionalità simile in Java? Dato che i puntatori sono in qualche modo assenti, qual è il modo migliore per farlo? E per essere chiari, stiamo parlando di prima classe qui.

Il linguaggio Java per funzionalità simili a puntatori a funzioni è una classe anonima che implementa un'interfaccia, ad es

Collections.sort(list, new Comparator<MyClass>(){
    public int compare(MyClass a, MyClass b)
    {
        // compare objects
    }
});

Aggiornamento: quanto sopra è necessario nelle versioni Java precedenti a Java 8. Ora abbiamo alternative molto più belle, vale a dire lambdas:

list.sort((a, b) -> a.isGreaterThan(b));

e riferimenti ai metodi:

list.sort(MyClass::isGreaterThan);

È possibile sostituire un puntatore a funzione con un'interfaccia. Diciamo che vuoi scorrere una raccolta e fare qualcosa con ogni elemento.

public interface IFunction {
  public void execute(Object o);
}

Questa è l'interfaccia che potremmo passare ad alcuni dire CollectionUtils2.doFunc (Collection c, IFunction f).

public static void doFunc(Collection c, IFunction f) {
   for (Object o : c) {
      f.execute(o);
   }
}

Ad esempio, abbiamo una raccolta di numeri e desideri aggiungere 1 a ogni elemento.

CollectionUtils2.doFunc(List numbers, new IFunction() {
    public void execute(Object o) {
       Integer anInt = (Integer) o;
       anInt++;
    }
});

Puoi usare la riflessione per farlo.

Passare come parametro l'oggetto e il nome del metodo (come stringa) e quindi invocare il metodo. Per esempio:

Object methodCaller(Object theObject, String methodName) {
   return theObject.getClass().getMethod(methodName).invoke(theObject);
   // Catch the exceptions
}

E poi usalo come in:

String theDescription = methodCaller(object1, "toString");
Class theClass = methodCaller(object2, "getClass");

Ovviamente, controlla tutte le eccezioni e aggiungi i cast necessari.

No, le funzioni non sono oggetti di prima classe in Java. Puoi fare la stessa cosa implementando una classe handler: ecco come vengono implementati i callback nello Swing ecc.

Ci sono comunque proposte di chiusure (il nome ufficiale di cui stai parlando) nelle future versioni di java - Javaworld ha un articolo interessante.

Questo mi ricorda l' Esecuzione di Steve Yegge nel regno dei nomi . Sostanzialmente afferma che Java ha bisogno di un oggetto per ogni azione, e quindi non ha entità "solo verbo" come i puntatori a funzioni.

Per ottenere funzionalità simili è possibile utilizzare classi interne anonime.

Se dovessi definire un'interfaccia Foo:

interface Foo {
    Object myFunc(Object arg);
}

Crea un metodo barche riceverà un 'puntatore a funzione' come argomento:

public void bar(Foo foo) {
    // .....
    Object object = foo.myFunc(argValue);
    // .....
}

Infine chiama il metodo come segue:

bar(new Foo() {
    public Object myFunc(Object arg) {
        // Function code.
    }
}

Java8 ha introdotto lambdas e riferimenti ai metodi . Pertanto, se la tua funzione corrisponde a un'interfaccia funzionale (puoi crearne una tua), puoi utilizzare un riferimento al metodo in questo caso.

Java fornisce una serie di interfacce funzionali comuni . mentre potresti fare quanto segue:

public class Test {
   public void test1(Integer i) {}
   public void test2(Integer i) {}
   public void consumer(Consumer<Integer> a) {
     a.accept(10);
   }
   public void provideConsumer() {
     consumer(this::test1);   // method reference
     consumer(x -> test2(x)); // lambda
   }
}

Non esiste nulla di simile in Java. Dovrai racchiudere la tua funzione in un oggetto e passare il riferimento a quell'oggetto per passare il riferimento al metodo su quell'oggetto.

Sintatticamente, questo può essere alleggerito in una certa misura usando le classi anonime definite sul posto o le classi anonime definite come variabili membro della classe.

Esempio:

class MyComponent extends JPanel {
    private JButton button;
    public MyComponent() {
        button = new JButton("click me");
        button.addActionListener(buttonAction);
        add(button);
    }

    private ActionListener buttonAction = new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            // handle the event...
            // note how the handler instance can access 
            // members of the surrounding class
            button.setText("you clicked me");
        }
    }
}

Ho implementato il supporto callback / delegate in Java usando la reflection. Dettagli e fonte di lavoro sono disponibili sul mio sito web .

Come funziona

Abbiamo una classe di principio chiamata Callback con una classe nidificata chiamata WithParms. L'API che necessita del callback prenderà un oggetto Callback come parametro e, se necessario, creerà un Callback.WithParms come variabile di metodo. Dal momento che molte delle applicazioni di questo oggetto saranno ricorsive, questo funziona in modo molto pulito.

Con le prestazioni ancora una priorità per me, non volevo che mi venisse richiesto di creare un array di oggetti usa e getta per contenere i parametri per ogni invocazione - dopotutto in una grande struttura di dati potrebbero esserci migliaia di elementi e nell'elaborazione di un messaggio scenario potremmo finire per elaborare migliaia di strutture di dati al secondo.

Per essere thread-safe, l'array di parametri deve esistere in modo univoco per ogni invocazione del metodo API e per efficienza lo stesso dovrebbe essere usato per ogni invocazione del callback; Avevo bisogno di un secondo oggetto che sarebbe stato economico da creare per legare il callback con un array di parametri per l'invocazione. Ma, in alcuni scenari, il chiamante avrebbe già un array di parametri per altri motivi. Per questi due motivi, l'array di parametri non apparteneva all'oggetto Callback. Anche la scelta dell'invocazione (passando i parametri come un array o come singoli oggetti) appartiene all'API usando il callback che le consente di usare qualunque invocazione sia più adatta al suo funzionamento interno.

La classe nidificata WithParms, quindi, è facoltativa e ha due scopi, contiene l'array di oggetti parametro necessario per le chiamate di callback e fornisce 10 metodi invoke () sovraccarichi (con da 1 a 10 parametri) che caricano l'array di parametri e quindi invocare il target di callback.

Controlla le chiusure su come sono state implementate nella libreria lambdaj. In realtà hanno un comportamento molto simile ai delegati C #:

http://code.google.com/p/lambdaj/wiki/Closures

Rispetto alla maggior parte delle persone qui sono nuovo di Java, ma poiché non ho visto un suggerimento simile ho un'altra alternativa da suggerire. Non sono sicuro che sia una buona pratica o no, o addirittura suggerito prima e non l'ho capito. Mi piace solo perché penso che sia auto-descrittivo.

 /*Just to merge functions in a common name*/
 public class CustomFunction{ 
 public CustomFunction(){}
 }

 /*Actual functions*/
 public class Function1 extends CustomFunction{
 public Function1(){}
 public void execute(){...something here...}
 }

 public class Function2 extends CustomFunction{
 public Function2(){}
 public void execute(){...something here...}
 }

 .....
 /*in Main class*/
 CustomFunction functionpointer = null;

quindi a seconda dell'applicazione, assegnare

 functionpointer = new Function1();
 functionpointer = new Function2();

eccetera.

e chiama da

 functionpointer.execute();