Newsgroup: it.comp.java
Titolo: Problema con polimorfismo.

Ho un oggetto Vector contenente tanti oggetti simili (e quindi non uguali).
Tali oggettti implementano la stessa interfaccia per cui dovrei poter
chiamare i loro metodi semplicemente ottenendo un oggetto dal Vector
castomizzarlo al tipo di interfaccia che implementa e chiamando i metodi che
mi interessano. Il problema è che tali oggetti contengono metodi
neccessariamente statici nella specifica dell'interfaccia non posso inserire
nessun metodo statico.
Come faccio per chiamare i metodi statici di ogni oggetto attravero il
vettore di istanze ?
Ggrazie 1000000.

 vettore di istanze ?
Scusa,
ma se devi invocare dei metodi statici, a cosa ti servono le istanze
dei singoli oggetti?
-- 
+-------------------+
| Bagnoli Roberto   |
| Nouvelle srl      |
| MODENA (ITALY)    |
| 
rbag...@orion.it
 |
+-------------------+

 ha scritto nel messaggio
news:6PAi9.19039$Av4.3...@twister2.libero.it...

La domanda non è molto chiara, forse puoi provare usando l'operatore
instanceof sugli oggetti che sono contenuti nel Vector.
--
Antonio Pelleriti
Brainbench Java Master: score 4.34,
higher than 99% of all previous test takers.

 dei singoli oggetti?
E' quello che ho pensato anch'io, ma forse lui intende che ha oggetti di
classi diverse, quindi con metodi statici diversi, ma che implementano la
stessa interfaccia, quindi vuole risalire alla classe di tali oggetti.
Credo.



Le istanze mi servono perchè voglio poter risalire all'oggetto dato il nome
dell'oggetto sotto forma di stringa. In pratica ho costruito una tabella che
mi associa al nome di ogni oggetto il suo indice allinterno del vettore.


e perchč vuoi usare dei metodi statici? Il confronto di un istanza con un
altro  oggetto la determini tu in base ai metodi equals e se vuoi hashCode.
Non ho ben capito cosa vuoi fare. Perchč non posti il codice?
Allora, tu parti da una stringa tipo "MioOggetto1", prendi questa stringa e
la confronti in una tabella di corrispondenze (č un Hashtable?) e reperisci
l'indice, e poi in base all'indice fai a prenderti l'oggetto i-esimo nel
Vettore? E' cosě?
Giuseppe

 stessa interfaccia, quindi vuole risalire alla classe di tali oggetti.
si, ma come Andrea Giotto ha confermato, non si possono dichiarare metodi
statici in un interfaccia, il che avrebbe davvero poco senso ;)
Giuseppe

 mi associa al nome di ogni oggetto il suo indice allinterno del vettore.
Non ho abbastanza elementi per capire qual'e' lo scopo
che ti prefiggi, ma certo e' che se hai una collezione 
di oggetti e su di questi devi invocare un metodo, la cosa 
migliore e' cercare di sfruttare il polimorfismo prima 
di andare ad "scomodare" implementazioni macchinose basate 
sulla reflection.
Ovviamente, il polimorfismo lo puoi utilizzare solo se e'
verificata una delle seguenti ipotesi:
- i tuoi oggetti hanno un capostipite comune che 
  definisce/dichiara il metodo da invocare;
- i tuoi oggetti implementano tutti una stessa interfaccia
  che dichiara il metodo da invocare;
Questi sono gli assunti di base, poi si possono applicare
specifici pattern per adattarsi a casi particolari.
Se tu chiarissi meglio l'obiettivo del tuo codice, forse
ti si puo' indirizzare verso una soluzione piu' "pulita"
di quella che hai accennato tu.
Buon lavoro
Roberto



E' cosě ed in tutto questo c'e' il problema che ognuno degli oggetti
al'interno del vettore deve poter utilizzare alcuni metodi di altri ogetti
del vettore. Una "soluzione" poteva essere quella di dichiarare statici tali
metodi ma c'e' il problema che non devono essere nell'interfaccia attraverso
la quale faccio il cast. In questo modo essi non possono piů essere
utilizzati dall'oggetto generico ritornato dal vettore.
In pratica e' un "DEADLOCK" concettuale: caro C++ quanto ti amai.....

mi associa al nome di ogni oggetto il suo indice allinterno del vettore.
Ma perché non usare un derivato di java.util.Map che č fatto (quasi) 
apposta?
-- 
Ciao
	Fabrizio C.

In pratica e' un "DEADLOCK" concettuale: caro C++ quanto ti amai.....
Cosa rimpiangi in particolare del C++?
Ogni strumento ha i suoi modi privilegiati/"naturali" per essere 
utilizzato: tutto sta a "vederli".
-- 
Ciao
	Fabrizio C.


Il problema si capisce bene rileggendo i post precedenti, comunque, per chi
non ci riesce, proverò a riassumerlo.
Ho bisogno di istanziare una serie di oggetti (qualche centinaio) simili  ma
non uguali che implementano tutti gli stessi metodi.
All'interno della classe in cui ho istanziato gli oggetti ho un metodo che,
dato il nome di una delle refernce degli oggetti sopra mi chiami i metodi
dell'oggetto corrispondente.
Ognuno degli oggetti istanziati, poi, ha la necessità di chiamare alcuni
metodi dei suoi "simili" e quali siano questi "simili" ed in quale numero
dipende dall'oggetto stesso, inoltre tali metodi sono tra quelli chiamati
dall'oggetto istanziatore attraverso il meccanismo nome-reference ->
oggetto.

 oggetto.
Ogni oggetto potrebbe 
- essere inizializzato con la lista dei nomi mnemonici 
  degli altri oggetti che deve accedere
- utilizzare l'oggetto "master" (che e' l'unico a conoscere 
  l'associazione nome-istanza) per identificarli
- invocarne i metodi in base alle sue esigenze
Un'ultima osservazione: capisco che tu non voglia rivelare piu' di
tanto del tuo progetto, pero' alle volte una conoscenza di piu' alto
livello puo' aiutare a trovare soluzioni eleganti e generalizzate.
Soffermarsi su singoli dettagli implementativi puo' essere
controproducente
se l'obiettivo e' quello di identificare una soluzione di design robusta
e stabile. Cosi', solo un piccolo consiglio... ;)
Buon lavoro
Roberto
-- 
+----------------------------------+
| Roberto Bagnoli                  |
| Sistemi Informativi e Telematici |
| Comune di Modena                 |
| 
robe...@comune.modena.it
        |
+----------------------------------+

oggetto.
Ragione di più per usare un'interfaccia comune.
Di seguito riporto alcuni frammenti (solo uno spunto, eh) di codice: non 
sei (ovviamente) obbligato a considerarli, ma mi farebbe piacere se mi 
dicessi se mi sono almeno avvicinato...
// File: GiottoInterface.java
public interface GiottoInterface {
    public void method();
}
// File: GiottoUno.java
public class GiottoUno implements GiottoInterface {
    public GiottoUno() {
    }
 
    public void method() {
        System.out.println(this.toString());
    }
}
// File: GiottoDue.java
public class GiottoDue implements GiottoInterface {
    private GiottoStore store;
    private String ref;
 
    public GiottoDue(GiottoStore store, String ref) {
        this.store = store;
        this.ref = ref;
    }
 
    public void method() {
        GiottoInterface gi = store.get(ref);
        System.out.print(this.toString());
        System.out.print("  ===>  ");
        gi.method();        
    }
}
// File: GiottoStore.java
public class GiottoStore {
    private java.util.Map map;
 
    public GiottoStore() {
        map = new java.util.HashMap();
    }
 
    public void put(String name, GiottoInterface obj) {
        map.put(name, obj);
    }
 
    public GiottoInterface get(String name) {
        GiottoInterface g = (GiottoInterface)map.get(name);
        return g;
    }
 
    public static void main(String[] args) {
        GiottoStore store = new GiottoStore();
        GiottoUno g1 = new GiottoUno();
        store.put("uno", g1);
        GiottoDue g2 = new GiottoDue(store, "uno");
        store.put("due", g2);
        GiottoInterface gi;
        gi = store.get("uno");
        gi.method();
        gi = store.get("due");
        gi.method();
    }
}
HTH nonostante tutto.
-- 
Ciao
	Fabrizio C.


La tua soluzione potrebbe andarmi bene ma sarebbe, forse, troppo pesante
considerando che ho a che fare con circa 1000 oggetti da ricercare nella
mappa (meno ricerche faccio e mglio è).
Forse utilizzando una TreeMap al posto della Map si migliora la ricerca
nella classe istanziatrice ma nelle classi istanziate vengono chiamate dalle
2 alle 6 (cica) delle altre classi smili quindi, considerando che un utente
(siamo in client-server)  per ogni richietsta deve interrogare circa 20
classi (tra le 1000) devono essere effettualte circa ((6+2)/2)*20 + 20 = 100
ricerche nel TreeMap per ogni richiesta.
Bisognerebbe fare in modo che all'interno di ogni classe ci fossero già le
reference delle altre utilizzate ma questo non è facile perchè esistono n°
insiemi di quelle 1000 classi ed ognuna di esse deve avere la reference
delle altre appartenenti al suo insieme.
Il progetto può sembrare affrontato male ma, per chi non lo avesse ancora
capito, si tratta  di un gestore di form (in JSP) in cui ogni campo è un
oggetto che interroga gli altri campi per poter ricercare le info di
autoriempimento su più di un DB (molto grossi) e, pensa che ti ripensa, non
o trovato soluzioni migliori di questa.
Comunque grazie degli "spunti".

Comunque grazie degli "spunti".
Facci sapere gli sviluppi.
PS.
Potresti sistemare il tuo Outlook? La risposta con R: è molto 
fastidiosa.
-- 
Ciao
	Fabrizio C.

OK Grazie ancora per i consigli.
Dove posso trovare informazioni sull'implementazione della HashMap ?