Newsgroup: it.comp.java
Titolo: multi-inizializzazione con ciclo for

ciao a tutti,
invece di scrivere esplicitamente l'inizializzazione su parecchi oggetti, ad 
esempio:
object1.setText("1");
refresh(object1);
object2.setText("2");
refresh(object1);
object3.setText("3");
refresh(object1);
object4.setText("4");
refresh(object1);
........
voglio farla con un ciclo for del genere:
        for(int i=0; i<=n; i++)
        {
            <objectI> = (String) ("object" + i);
            <objectI>.setText("" + i);
            refresh(<objectI>);
        }
come si fa a referenziare un oggetto in una maniera simile?
-- 
ciao
Vittorix

 come si fa a referenziare un oggetto in una maniera simile?
Metti gli oggetti in un array

Vittorix ha scritto:

REFLECTION

 REFLECTION
Risposta giusta a problema sbagliato ;)

 Metti gli oggetti in un array
non e' possibile, stanno in un frame.
-- 
ciao
Vittorix 

 REFLECTION
stabilito che quel pinnolone di Sergio e' ancora vivo, suggerimenti?
-- 
ciao
Vittorix 

 non e' possibile, stanno in un frame.
e allora?
Ciao Jack
-- 
Yoda of Borg am I! Assimilated shall you be! Futile resistance is, hmm?

 non e' possibile, stanno in un frame.
Uh ? Facciamo che metto giu' un paio di righe di codice.
   MyObj[] myArray = new MyObj[] {
     object1,
     object2,
     object3,
     ...
     object42
   }
   for (int i = 0; i < myArray; i++) {
     myArray[i].setText("" + i);
     refresh(myArray[i]);
   }
O una qualsiasi altra variazione sul tema, come per esempio al 
costruttore di object passare l'array nel quale l'oggetto stesso andra' 
a inserirsi - occhio ai memory leaks pero' (WeakReferences ?).

 come si fa a referenziare un oggetto in una maniera simile?
non si fa.
fra l'altro, siccome in java esistono gli array, non capisco perchè tu 
debba inventarti un surrogato mettendo l'indice nel nome della reference...

   }
grazie e scusa mi sono espresso male. questa maniera e' ovvia, ma non credo 
faccia al mio caso.
in questa maniera devo accedere agli oggetti sequenzialmente, ma gli oggetti 
non si chiamano {ogg1, ogg2, ..., oggn} bensi' si chiamano in modi diversi, 
stando in un frame ed essendo di natura diversi: (sono jLabels, jTextFields, 
jPanels, jCheckButtons, jTextAreas, jProgressBar ecc....) da questo 
l'esigenza di accedere via nome, alternativamente.
io volevo fare qualcosa che dipendesse dal nome. devo farci delle operazioni 
in questa maniera:
        for(int i=0; i<=n; i++)
        {
            if(jCheckBoxI.isSelected())
            {
                initializeBar(jProgressBarI);
                jTextAreaI.append("\nCalculating method" + I);
                refresh(jLabelI);
                <calcoli usando array aI>
                updateBar(jProgressBarI);
                refresh(jLabelI);
                ...........
                jTextAreaI.append("done\n");
            }
        }
capito ora la mia difficolta'? come la risolvo?
immagino che l'unica sia di metterli nell'array in sequenza (es: jLabel1, 
jTextField1, jPanel1, ...., jLabel2, jTextField2, jPanel2, ...., jLabeln, 
jTextFieldn, jPaneln) , di ricopiare ogni volta mediante ciclo for il gruppo 
degli oggetti necessari (jLabelI, jTextFieldI, jPanelI, ....) uno ad uno in 
oggetti temporaneamente creati.
ma francamente speravo in una programmazione piu' semplice ed efficiente 
accedendo direttamente ai nomi. idee?
-- 
ciao
Vittorix 

 reference...
copio/incollo da altro post in cui spiego meglio:
gli oggetti non si chiamano {ogg1, ogg2, ..., oggn} bensi' si chiamano in 
modi diversi, stando in un frame ed essendo di natura diversi: (sono 
jLabels, jTextFields, jPanels, jCheckButtons, jTextAreas, jProgressBar 
ecc....) da questo l'esigenza di accedere via nome, alternativamente.
io volevo fare qualcosa che dipendesse dal nome. devo farci delle operazioni 
in questa maniera:
        for(int i=0; i<=n; i++)
        {


 capito ora la mia difficolta'? come la risolvo?
La risolvi cambiando modo di pensare :) Quel che vuoi fare te e' 
sbagliato, non puoi basare la logica del tuo programma sul nome che uno 
sviluppatore da a un oggetto. Anche perche' il nome dell'oggetto per 
Java non ha significato, non e' legato all'oggetto stesso.
Rilancio l'idea dell'array, anzi, di un array di array: Alla posizione 
"I" avrai un array di tutte le componenti "I".
Ma e' piu' probabile che stai cercando la soluzione a un problema che 
non esiste: Che problema stai cercando di risolvere ?

 non esiste: Che problema stai cercando di risolvere ?
ho una tabella di calcoli da fare in circa 10 modi diversi e mostrare 
risultati, tempi e altro in un frame.
ogni calcolo e' associato a diversi componens (nel frame) che vanno 
modificati e aggiornati a video ogni volta che l'operazione e' completa. in 
maniera sequenziale non ho problemi, ma e' assurdo ripetere 10 volte lo 
stesso gruppo di istruzioni. cambia solo il metodo di calcolo.
mentre scrivevo questo forse mi e' venuta la soluzione adatta.
metto tutto in un array e passo tutti i components necessari a un metodo che 
ci pensa lui a gestirli.
-- 
ciao
Vittorix 

Vittorix ha scritto:

REFLECTION

 
Si, la reflection.

Vittorix ha scritto:

Mettiamola in questi termini, tu non sai programmare: pretendi di 
flettere la logica Java e degli algoritmi in genere al modo bislacco in 
cui tu hai pensato la tu a soluzione, tra l'altro errando alla grande.
In + pretenderesti di trovare una soluzione elgante e leggibile ad un 
problema mal posto, faragginoso e contorto per il solo motivo che così 
tu lo hai concepito.
Ora, la gente qui, a differenza di te, sa programmare e nonostante tu 
meriteresti di essere deriso ti propone diverse soluzioni, dalle + 
eleganti (array vari) a quelle che + cercano di adattarsi ao tuoi 
contorcimenti risolutivi (reflection).
Ma nel primo caso opponi obiezioni di legibilità (salvo poi dire di aver 
trovato la stessa soluzione che improvvisamente diventa leggibile) 
mentre nel secondo caso soccicandoti di andarti a legger eun po' di 
documentazione ti prendi delle confidenze con il sottoscritto e te ne 
esci con una battuta.
Io credo che il tuo atteggiamento sia il cancro dei gruppi di 
discussione e ti invito a rivedere il tuo modo di porti.

 in altri linguaggi si :)
Torna al Clipper e non ne parlare più, no?

 questo l'esigenza di accedere via nome, alternativamente.
Sono pur sempre sottoclassi di JComponents. Al momento della creazione,
perché non li inserisci in un' ArrayList<JComponent> ?

 cui tu hai pensato la tu a soluzione, tra l'altro errando alla grande.
Beh, Vittorix sarà uno sviluppatore sui generis, ma tu sei quello della
reflection...
Dalle mie parti sarebbe come sparare ad una mosca con un cannone.

 accedendo direttamente ai nomi. idee?
una buona idea potrebbe essere documentarsi un pochino (non
tantissimo) su awt e swing, non dico prima di lavorarci ma almeno
durante.  se l'avessi fatto, ti saresti accorto che questi componenti
li associ ad un container, e il container ti restituisce quando vuoi
il vettore dei sub-componenti, oppure ti da accesso per nome.
in alternativa come ti è stato ripetuto più volte la introspezione (o
reflection), visto che abbiamo capito finalmente che si tratta di
proprietà e non di reference generiche. questo sì, anche con java si
può fare.
insomma, le strade ci sono. certo, ad andare avanti a forza di
imbeccate su un newsgroup è dura...

 stesso gruppo di istruzioni. cambia solo il metodo di calcolo.
Credo che sia un buon compito per il pattern "Observer/Observable".
La classe che implementa i calcoli estende la classe "Observable".
Quando il suo stato cambia, devi chiamare il metodo "notifyObservers()" 
(Oppure notifyObservers(Object arg) se devi passare un oggetto agli 
osservatori) e automaticamente tutti gli osservatori "iscritti" vengono 
notificati del cambiamento.
Gli osservatori devono implementare l'interfaccia Observer che specifica 
in solo metodo: update(Observable o, Object arg).
Esempio concreto:
   class MioCalcolo extends Observable {
     ...
     public void faiCalcolo(...) {
       ...
       Risultato ris = ...
       // finito, notifichiamo gli osservatori del nuovo stato
       notifyObservers(ris);
     }
   }
OK, ora i tuoi componenti devono semplicemente implementare il metodo 
update per gestire la notifica:
   class MioBottone extends JButton implements Observer {
     void update(Observable o, Object arg) {
       // fa qualcosa con "o" ("MioCalcolo") e "arg" ("Risultato")
       ...
     }
   }
Ricordati di iscrivere MioBottone alla lista di quelli che ricevono la 
notifica da MioCalcolo:
   MioCalcolo mc = ...
   ...
   MioBottone mb = ...
   ...
   mc.addObserver(mb);

Manuel T ha scritto:

Dalle mie parti se uno vuole accedere usando i nomi da codice per 
accedere all'oggetto che essi designano si usa la reflection, poi che ci 
siano altri 100 modi per non essere costretti ad usarla non si discute.


Sergio. la tua decennale fama di cojote ti danneggia.
non conoscevo la Java Reflection, credevo la tua fosse una tua solita 
battuta.
ora ho fatto una ricerchina e sembra promettente.
perche' per farti prendere sul serio non ti cambi nick? :-P
-- 
ciao
Vittorix 

 può fare.
approfondisco il discorso reflection domani
-- 
ciao
Vittorix 


interessantissimo. domani mi ci metto a riflettere su e ti rispondo con piu' 
calma. grazie.
-- 
ciao
Vittorix 

 discussione e ti invito a rivedere il tuo modo di porti.
lol
-- 
ciao
Vittorix 

Manuel T wrote:

se li metto in un array poi come faccio a usarli a saltare col ciclo for a 
seconda che sia un tipo o un altro?
mica devo chiamare per tutti lo stesso metodo..
-- 
ciao
Vittorix 

 mica devo chiamare per tutti lo stesso metodo..
O usi l'operatore "instanceOf", dove determini se il componente è JLabel,
JButton ...
Oppure subclassi ogni componente di tuo interesse aggiungendo una etichetta
che puoi interrogare.
Visual basic ad esempio(che ormai detesto, ma una cosa buona c'era) forniva
un campo "tag" per ogni componente visuale, il cui scopo era libero.
Scomodare la reflection per questo è assolutamente folle.

 non conoscevo la Java Reflection[...] sembra promettente.
Non ti sfugga che è onerosa per la jvm...

Vittorix ha scritto:

Perchè dei pregiudizi tuoi o di quelli come te non me ne frega niente.