Newsgroup: it.comp.java
Titolo: QUESTIONE DI STILE

Ho un frame che conterrà due pannelli.
Entrambi i pannelli modificano delle variabili contenute nel frame.
Qual'è il miglior stile di implementazione?
Creare un frame e all'interno della classe frame creare i due pannelli
facendo diventare così tale classe una classe enorme e poco leggibile
o creare una classe per il frame, una classe per il pannello di un certo
tipo e un'altra classe per un'altro pannello. In questa maniera il codice
diventa molto leggibile ma i pannelli non possono accedere alle variabili
del frame. Ho pensato di passare ai metodi costruttori dei pannelli le
variabili del frame che il pannello dovrà modificare.
E' una tecnica sporca? Cosa mi consigliate?

 
personalmente ti consiglio di non passare le variabili ai 2 frame 
secondari (diciamo B e c), ma di implementare sul frame principale (A)
dei metodi pubblici per aggiornare le variabili e di passare a B e C il 
riferimento di A, in modo da poter invocare suddetti metodi...
mi pare che cosi' sia piu' corretto dal punto di vista dell'OOP.
cmq e' solo il mio consiglio
Byez
-- 
             {2Nd+BESt}
-----------------------------------
never underestimate human stupidity



Non so se ho capito molto bene quello che hai scritto.
Dimmi se mi sbaglio. Ho il frame A e i pannelli B e C.
Il frame A dovrà contenere sia B sia C.
Tu mi consigli di creare B dandogli come parametro A e la stessa cosa per
C. Alla fine forse è come ho detto io, anche se ovviamente anzicchè
passare delle varibili passo un oggetto che mi permette di avere accesso a
queste variabili. Ovviamente è un medo più corretto dal punto di
vista OOP rispetto a quello che ho presentato io.......ma mi chiedo se
questo è un buon stile di programmazione e se si può ottennere qualcosa
più OOP. 

 più OOP. 
non vorrei sbagliare ma e' l'approccio corretto nel senso che gli 
oggetti interagiscono fra loro mediante le interfaccie, utilizzando 
anche l'incapsulation, ovvero non accedi alla variabile...
mi pare che chiamare l'interazione fra oggetti mediante i metodi sia 
"message passing" ma nn vorrei sbagliarmi
cmq casomai aspetta altre risposte,
c'e' gente in gamba qui, fidati


 Cosa mi consigliate?
Passa un riferimento al frame ai pannelli e utilizza i getter e i 
setter. Si chiamano così quei metodi che permettono di leggere ed 
impostare le variabili d'istanza di una classe senza accedervi 
direttamente, nell'ottica dell'incapsulamento dei dati.
Questa è una metodologia piuttosto generale, auspicabile in tutte le 
classi. In sostanza dichiari le variabili di classi come private, e poi 
scrivi dei metodi getVar e setVar che, rispettivamente, leggono ed 
impostano quella variabile (tra l'altro questo è un concetto base nella 
costruzione di classi Bean). In questo modo nessuno modificherà 
direttamente le tue var, e tu puoi decidere quali accessi permettere e 
quali no.
Nel tuo caso io farei:
/* per i costruttori dei pannelli */
public Pannello1 (Frame f)
public Pannello2 (Frame f)
In questo modo permetti ai pannelli di accedere alla finestra, 
ovviamente f lo memorizzerai in una var d'istanza (magari privata 
anch'essa ;-) )
/* per le variabili da modificare, nel frame */
private int var1;
public int getVar1 () {
	return this.var1;
}
public void setVar1 (int v) {
	this.var1 = v;
}
In questo modo var1 è privata, tuttavia altri metodi possono utilizzarla
/* per modificare var1 in f da un pannello */
this.f.setVar1(v);
semplicemente
Così almeno è come uso fare io
-- 
Ave!
Caesar.
Eatvr quo nos deorvm ostenta vocant. Alea iacta est!
Caivs Ivlivs Caesar, Imperator Mvndi
Caesar...@Fastwebnet.It



Grazie per la risposta. Si ho fatto la domanda molto velocemente,
ovviamente anche io sono giunto alle tue conclusione. Però quando ho
postato la mia domanda forse l'ho fatto per aver il parere di qualche
persona esperta nella programazione delle interfaccie grafiche. 
Infatti mi sono sempre limitato a fare applicazioni gui  molto semplici,
di quelle che si fanno quando si inizia a programmare con swing...dove al
massimo ci sono pochi pannelli e molto semplici.  Nei libri che ho
letto che introducevano a java(tra cui quelli di horstmann e cornell) ci
sono esempi, che anche in applicazioni molto banali che, mi hanno un pò
messo a disagio a me che sono stato "formato ad oggetti" (ad esempio a
volte i pannelli erano creati e "definiti,specificando tutte le
caratteristiche(come label, pulsanti, combobox..." nello stesso frame.
Non ho mai visto un pannello che prendeva come parametro in ingresso un
Frame e mi sono chiesto il perchè, se farlo era o no una buona norma di
programmazione......alla fine ho fatto proprio come hai detto tu, ma mi
era rimasto sempre questo dubbio. 
Se conosci qualche programma open source da poter studiare o risorse che
facciano vedere come utilizzare i componenti awt e swing in programmi non
banali fammelo sapere...sarei molto curioso di vedere le soluzioni
adottati a certi dubbi che mi sorgono quando programmo.

 Qual'è il miglior stile di implementazione?
Quando penso ad un oggetto, penso ad un'entità a se' stante, che deve
conoscere il meno possibile degli altri oggetti con cui dovrà interagire,
per garantire il massimo livello di scalabilità e possibilità di
generalizzazione.
Con questa premessa, in ogni programma realizzo uno strato che si occupa di
demandare il lavoro ai diversi oggetti componenti del programma in base
all'input dell'utente e degli oggetti stessi; in questo modo non è
necessario che gli oggetti conoscano necessariamente la struttura degli
altri oggetti, per poter funzionare.
Più in particolare, non sono i pannelli che devono avere la possibilità di
modificare le variabili contenute nel frame (altrimenti i pannelli
dovrebbero conoscere la struttura della classe del frame, e questo non è 
bello), ma dovrebbero segnalare al frame che e' avvenuto qualche
cambiamento (segnalato tramite ovviamente un metodo) e che frame dovrebbe
agire di conseguenza (modificando delle variabili che lui ovviamente
conosce, perchè fanno parte della sua struttura).
Io per risolvere questo problema utilizzo il design pattern "Observer", che
praticamente evita di doversi ricordare il nome del metodo che il pannello
deve chiamare nel caso specifico e soprattutto dell'oggetto chiamante gli
passa solo la parte relativa all'interfaccia.
E cioè:
-------------------------------------------
class pannello extends JPanel
{
        Vector arrOggettiEvento=new Vector();
 
        public void addEventoListener(IEventoListener objInput)
        {
                arrOggettiEventi.add(objInput);
        }
        public void eventoScattato()
        {
                for (int i=0;i<arrOggettiEvento.size();i++)
                {
                        arrOggettiEventi.update();
                }
        }
}
interface IEventoListener
{
        public void update()
}
class frame implements IEventoListener
{
        frame()
        {
                pannello p=new pannello();
                p.addEventoListener(this);
        }
        public void update()
        {
                System.out.println("Scattato l'evento nel pannello!");
        }
}
-----------------------------------------------------------
-- 
Ciao,
 Fabrizio
=== 
http://www.negusweb.it
 ===

On Thu, 19 May 2005 23:59:34 +0200, Negus wrote:
Anche io ho la tua stessa concezione di oggetto e di programmazione ad
oggetti. Purtroppo mi sono trovo in difficolta nella creazione di gui dove
spesso annidavo varie classi e violavo alcuni principi della
programmazione ad oggetti. Grazie della risposta, molto interessante...mi
hai aperto nuove strade :-)