[Java]Esportare i dati da Jtextfield

[Scarcrow]

Salve a tutti:D

Vi spiego la mia situazione, ho creato una finestra di dialogo con la joptionpane, dove inserire un valore intero, con il quale si apre una jdialog, che a seconda del intero precedentemente inserito, crea un tot di tab con all'interno un jpanel che contiene jtextfild e jcombobox, tutti uguali per ogni tab.

Ora il mio problema è come catturare i dati presenti nei campi di testo e nelle combobox provenienti da tutti i tab, e renderli disponibili per la sucessiva esportazione in un file di testo al termine delle sucessive operazioni.

[fero86]

:mbe:
http://java.sun.com/javase/6/docs/api/javax/swing/text/JTextComponent.html#getText()
http://java.sun.com/javase/6/docs/api/javax/swing/JComboBox.html#getSelectedItem()

[Scarcrow]

bè si...ma allora non mi sono spiegato bene se mi rispondi così, ti mostro la classe che ho creato per realizzare la jdialog con i tab


super(parent, "Movimentazione", true);
Container cnt = getContentPane();
cnt.setLayout(new BoxLayout(cnt, BoxLayout.Y_AXIS));
JTabbedPane jtab = new JTabbedPane();
JPanel[] panel = new JPanel[x];
for(int k = 0; k<x;k++){
panel[k] = new JPanel();

JLabel[] lbl = new JLabel[20];

JComboBox[] jcbox = new JComboBox[3];
String[] strMov = {"Codice Ditta Sogg. Obb.: ", ecc ecc};
String[] tipoString = {"A","C", "D", "E", "F", "G","R"};
String[] tipoRic = {"I", "C", "A","D"};
String[] tipoReg = {"M", "L","S","D","G","F","N","C"};
int nL = 0;
for (int j = 0; j< strMov.length;j++){
lbl[nL] = new JLabel(strMov[j]);
nL++;
}

txt[0] =new JFormattedTextField("nome");
txt[0].setVisible(false);
txt[1] = new JFormattedTextField(createFormatter("#############"));
txt[2] = new JFormattedTextField(createFormatter("########"));
jcbox[0] = new JComboBox(tipoString);
ecc
ecc
panel[k].add(txt[8]);
jtab.addTab("Mov"+(k+1), panel[k]);
cnt.add(jtab);


questo mi mostra come ho detto prima la finestra di dialogo con x tab, e ognuna di queste ha esattamente gli stessi campi. Il mio problema è prendere tali valori in tutte le tab!
spero di essere stato più chiaro
grazie

[PGI-Bis]

Una soluzione è astrarre il tipo di dato aggregato X che l'utente deve formare e definire un editor per quel tipo di dato dove con "editor" intendo semplicemente un componente interattivo, dotato del numero necessario di controlli, per il quale siano defniti un mutatore ed un accessore di tipo X.

Fatto ciò quando devi fornire al'utente la possibilità di creare il valore - composto - X, inserisci nell'interfaccia l'editor per X e quando vuoi recuperare il valore modificato usi l'accessore dell'editor.

Si tratta comunque di un problema di architettura e questa è solo una delle possibili soluzioni.

[Scarcrow]

Una soluzione è astrarre il tipo di dato aggregato X che l'utente deve formare e definire un editor per quel tipo di dato dove con "editor" intendo semplicemente un componente interattivo, dotato del numero necessario di controlli, per il quale siano defniti un mutatore ed un accessore di tipo X.

Fatto ciò quando devi fornire al'utente la possibilità di creare il valore - composto - X, inserisci nell'interfaccia l'editor per X e quando vuoi recuperare il valore modificato usi l'accessore dell'editor.

Si tratta comunque di un problema di architettura e questa è solo una delle possibili soluzioni.

non ho capito quello che vuoi dire:D

[PGI-Bis]

I componenti che visualizzi a seconda del valore scelto dall'utente nella prima finestra hanno una loro ragione d'essere: se visualizzi un certo gruppo di componenti anzichè un'altro sarà perchè quel gruppo esprime i valori che sono necessari affinchè il tuo programma possa produrre un certo "dato".

Dato può essere una stringa o dieci stringhe, o tre stringhe, due interi, ventimila enumerativi e tre byte - s'è c'è più di un'informazione in quel dato si parla di aggregato.

Bene, quello che fai quando dici all'utente "scegli un valore che poi ti faccio vedere io che componenti devi usare" è permettere all'utente di formare uno tra diversi tipi di dato aggregato.

Una soluzione al tuo problema di design sfrutta esattamente questa comunione trai diversi controlli dell'interfaccia: tutti quanti partecipano alla produzione di un unico valore - del tipo specificato nel dato aggregato.

Hai da una parte il tuo dato:

public class Dato {
private String nome, cognome, azienda, tricche e ballacche;
private int[] matrice;
private List<String> ecchessaramai;

...getter e setter (tecnicamente accessori e mutatori) a strafottere
}

e per questo dato crei UN editor, uno solo che ti fa da centro di controllo:

public class Editor {
private JComponent component;

public Dato get() {return component;}

public void set(Dato d) {...}

public JComponent getComponent() {...}

public void setListener o setObserver o quel che preferisci.
}

In editor dichiari tutti i controlli che ti servono, direttamente o indirettamente,per creare o modificare un Dato. Questi controlli li aggiungi a component, direttamente o tramite altri contenitori - puoi anche non esporre il componente principale dell'editor e usare una o più finestre. Nel metodo get crei un'istanza di Dato, la riempi con i valori dei controlli gestiti dall'editor e larestituisci. Nel set fai il contrario.

Il listener o l'observer o quel che preferisci è il tramite per notificare al resto del programma che l'editor ha prodotto un valore.