[JAVA] Costruire applicazione Java client a più finestre

[Luca_19]

Ciao a a tutti,

mi sto cimentando nella costruzione di un applicazione java client usando le librerie java.awt. Credo di aver capito i concetti di base, ma non riesco a capire come strutturare un'applicazione che prevede più finestre e la possibilità di passare da una finestra all'altra. Vorrei costruire un programma che permette di fare un sondaggio:

1a finestra: descrizione del sondaggio + tasto NEXT (che apre la 2a finestra e nasconde la 1a)
2a finestra: prima domanda + tasto NEXT (che apre la 3a finestra e nasconde la 2a)
3a finestra: seconda domanda + tasto NEXT .... etc
Nma finestra: Riepilogo + tasto per tornare alla 1a finestra.

Nel metodo main della classe java principale potrei istanziare nuove finestre (definite con nuove classi), ma mi sfugge come mantenere il controllo di tutta l'applicazione. ES: come faccio, quando arrivo al tasto NEXT dell'ultima finestra, a riattivare la 1a finestra? C'è anche da considerare che devo mantenere la memoria delle risposte che vengono date alle domande.

Qualsiasi spunto/suggerimento è gradito!

[Patrick Jane]

Originariamente inviato da Luca_19
Nel metodo main della classe java principale potrei istanziare nuove finestre (definite con nuove classi), ma mi sfugge come mantenere il controllo di tutta l'applicazione. ES: come faccio, quando arrivo al tasto NEXT dell'ultima finestra, a riattivare la 1a finestra? C'è anche da considerare che devo mantenere la memoria delle risposte che vengono date alle domande.

Qualsiasi spunto/suggerimento è gradito!

Non ho aggiunto quanto vorresti realizzare tu, per questioni di tempo e per non consegnarti il codice bello e pronto. :P

Inizio con il rispondere alle righe quotate qui sopra.
Quello sarebbe un errore! Il metodo main() viene utilizzato per lanciare un applicazione, al suo interno, soprattutto quando si tratta di Swing (non utilizzare AWT, è obsoleto ormai... usa Swing, una sua estensione), compare solamente il codice che crea un nuovo thread e chiama un altro metodo che si occuperà di creare il frame principale.

Il codice che dici tu, deve comparire all'interno del costruttore, e comunque essere una variabile di istanza se ti serve fuori da quella classe!

Ecco un esempio scritto su 2 piedi:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

class Finestra1 extends JFrame implements ActionListener {
  // Il frame precedente lo memorizzi qui
  private EsempioFinestre ef;
  private JButton back;
  
  Finestra1(EsempioFinestre ef) {
    super("Seconda Finestra");
    this.ef = ef;
    
    
    JPanel pannello = new JPanel();
    back = new JButton("Back");
    pannello.add(back);
    add(pannello);
    
    // Ascolto l'eventuale pressione di back
    back.addActionListener(this);
    
  }
  
  // Quando viene premuto...
  public void actionPerformed(ActionEvent ae) {
    // Rendo visibile il frame precedente
    ef.setVisible(true);
    // Chiudo l'attuale
    dispose();
  }
}

// Finestra principale
class EsempioFinestre extends JFrame implements ActionListener {
  // Finestra che andremo a creare
  private Finestra1 f1;
  // Questo ci permette di aprire la nuova finestra
  private JButton next;
  
  // Costruttore
  EsempioFinestre() {
    super("Prima Finestra");
    
    // Posiziono il bottone ed il pannello che lo contiene sul frame
    JPanel pannello = new JPanel();
    next = new JButton("Next");
    pannello.add(next);
    add(pannello);
    
    // Ascolta la pressione sul bottone
    next.addActionListener(this);
    
    // Questa è la chiusura del frame, se premi X insomma
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
  
  // Quando un evento viene generato
  public void actionPerformed(ActionEvent ae) {
    // Creo il frame secondario
    f1 = new Finestra1(this);
    // Setto la dimensione
    f1.setSize(300,300);
    f1.setVisible(true);
    
    // Questo è il nostro frame, quello attuale
    // quindi lo nascondo
    setVisible(false);
  }
  
  
  // Lancio l'applicazione rendendo visibile la finestra principale
  public static void makeGUI() {
    EsempioFinestre ef = new EsempioFinestre();
    ef.setSize(400,400);
    ef.setVisible(true);
  }
  
  // Creo il nuoto thread
  public static void main(String[] args) {
    try {
      SwingUtilities.invokeAndWait(new Runnable() {
        public void run() {
          makeGUI();
        }
      });
    } catch(Exception e) {}
  }
}

Il codice è commentato, ma se dovessi avere problemi, chiedi

[Dark867]

Un approccio alternativo è creare più pannelli, uno x finestra di sondaggio e cambiare il content pane del frame principale ogni volta ke viene premuto il tasto next, in questo modo

frame.setContentPane(nuovoPannello);
frame.validate();

[Luca_19]

Ringrazio entrambi! provo entrambe le alternative!

[Luca_19]

Ciao Patrick,
dando un'occhiata al tuo codice, in sostanza:

1) creo n classi separate per n finestre distinte

2) per mantenere una navigabilità tra finestre passo sempre il riferimento della finestra in cui mi trovo nel costrtture della nuova finestra che sto creando

3) ho visto che per implementare l'ActionListener è stato scritto

class EsempioFinestre extends JFrame implements ActionListener {

io stavo invece procedendo creando una classe interna alla classe principale e istanziando un nuovo elemento di tipo ActionListener nel costrutture della classe principale. Non so se sono entrambe alternative valide.

[Patrick Jane]

Originariamente inviato da Luca_19
Ciao Patrick,
dando un'occhiata al tuo codice, in sostanza:

1) creo n classi separate per n finestre distinte

2) per mantenere una navigabilità tra finestre passo sempre il riferimento della finestra in cui mi trovo nel costrtture della nuova finestra che sto creando

3) ho visto che per implementare l'ActionListener è stato scritto

class EsempioFinestre extends JFrame implements ActionListener {

io stavo invece procedendo creando una classe interna alla classe principale e istanziando un nuovo elemento di tipo ActionListener nel costrutture della classe principale. Non so se sono entrambe alternative valide.

Ciao,

1) Si, ogni finestra deve estendere JFrame, quindi crea N classi (sinceramente lo trovo più comodo così);

2) Esatto; se mi trovo in A ed apro B, devo passare a B l'oggetto A, così da nascondere A. Quando chiudo B, distruggo B e rendo visibile A

3)

Puoi scegliere ciò che preferisci. Io ho evitato di fare:

bottone.addActionListener(new ActionListener() {
  public void actionPerformed(ActionEvent ae) {
    // Codice
  }
});

per evitare di mandarti in confusione, dato che avrei dovuto dichiarare come final la variabile (oggetto, precisamente) che gestisce il frame.

Ovviamente puoi adottare anche il tuo modo. Io lo uso nei casi proprio di necessità, cerco di evitare solo perchè non mi trovo molto comodo.


Aggiungo a quanto detto da Dark867, che potresti anche creare dei pannelli e mostrarli all'occorrenza, sfruttando però CardLayout.
In pratica, hai ad esempio dei bottoni, ciascuno di essi "dice" (tramite un metodo chiamato show() di CardLayout) di mostrare un pannello al posto di un altro.


Se hai domande, chiedi pure