Newsgroup: it.comp.java
Titolo: C'è qualcuno che mi può aiutare?

Ho bisogno di passare una funzione come parametro al costruttore di un
oggetto ma non so se in Java ciň č possibile.
Quello che mi serve č definire una classe i cui oggetti abbiano una funzione
membro definibile all'atto dell'istanziazione.
Ad esempio la classe A ha un oggetto membro di tipo Funzione (ovviamente una
funzione) che viene specificato solo quando si crea l'oggetto.
La classe A č fatta cosě:
class A {
...
Funzione funzione_membro; (l'oggetto incriminato)
...
}
L'ideale costruttore della classe A dovrebbe assomigliare a questo
A::A(..., Funzione f, ...) {..., funzione_membro = f, ....};
In questo modo posso definire due funzioni mia_funzione1 e mia_funzione2 che
diffriscono solo nel corpo
double mia_funzione1 (...) {...}
double mia_funzione2 (...) {...}
passarle come parametro quando costruisco 2 oggetti
A oggetto1(..., mia_funzione1, ..);
A oggetto2(..., mia_funzione2, ..);
e poi richiamare la funzione membro degli oggetti creato
x = oggetto1.funzione_membro(...);
y = oggetto2.funzione_membro(...);
ottenendo ovviamente due risultati diversi.
In C++ questo lo implementerei definendo la mia funzione con typedef cosě:
typedef double (*Funzione) (... parametri ...);
e poi creando il costruttore e la classe come visto sopra.
Non so se in Java questo č possibile, se si puň ottenere in altro modo o se
la risposta č banale ma se c'č qualcuno che mi puň dare questo suggerimento
lo apprezzerei moltissimo. Grazie.

e poi creando il costruttore e la classe come visto sopra.
Anche in C++, sarebbe molto meglio fare di Funzione una classe,
un oggetto-funtore -- in questo caso, uno che ha l'opportuno overload
di operator(), in modo da chiamarlo "trasparentemente".  Lo standard
C++, nell'header <functional>, definisce vari template di utility che
permettono di fare queste cose in modo elegante e comodo
    class Funzione: public std::unary_function<double,double> {
        public: virtual double operator() const = 0;
    };
eccetera (meglio ancora, naturalmente, fare un template della
stessa Funzione, ma queste non sono considerazioni rilevanti
per Java quindi ti invito a proseguire il discorso su it.comp.lang.c++
se esso ti interessa).
Java ha il vantaggio delle inner classes, e l'elegante e comoda
distinzione fra class e interface (ed extends e implements), per
aiutare questo tipo di approccio; C++ ha, per contraltare, i vari
template, i relativi header standard, e l'overload di operator();
personalmente la considero una "patta" fra i due linguaggi per
questo specifico problema.  Naturalmente, C++ ti permette
anche un altro approccio alternativo, non O-O e tutto sommato
poco consigliabile, quello basato sui puntatori a funzione -- qui,
pero`, mi sembra che il NON offrire questi approcci all'antica, e
obbligare invece il programmatore a usare gli schemi piu`
moderni ed eleganti, sia un _vantaggio_ di Java (ti guida di piu`;
C++, invece, ti da` tanta corda -- se sei perfetto, benissimo, ma,
se sei invece un essere umano, c'e` sempre il rischio che quella
corda tu la usi per impiccarti...:-).
Alex

 lo apprezzerei moltissimo. Grazie.
Ci sono le inner class che ti aspettano, ma solo dal Jdk 1.1 in poi!
Ugo

 Alex
Perfettamente daccordo... buuu ai puntatori a funzione e all'ereditarietą (di
implementazione) multipla. Certo perņ che l'overloading degli operatori... ma
forse qualcuno ne avrebbe abusato!
Ugo