Imparare a creare una semplice finestra vuota usando Java Swing. E’ il mattone fondamentale su cui costruire interfacce più complesse.
Swing è una libreria (parte delle Java Foundation Classes – JFC) che fornisce un insieme ricco di componenti per creare interfacce grafiche utente. Un aspetto chiave di Swing è che i suoi componenti sono “lightweight”, cioè disegnati direttamente da Java e non dipendono pesantemente dai componenti nativi del sistema operativo. Questo li rende più flessibili e portabili.
Creare la Classe Java
Come ogni programma Java, iniziamo creando una classe. Chiamiamola MiaPrimaFinestra. All’interno di questa classe, avremo bisogno del metodo main, il punto di ingresso della nostra applicazione.
// File: MiaPrimaFinestra.java public class MiaPrimaFinestra { public static void main(String[] args) { // Qui scriveremo il codice per creare la finestra System.out.println("Avvio creazione finestra..."); } }
Importare le Classi Necessarie
Per usare Swing, dobbiamo dire a Java dove trovare le classi che ci servono. La classe principale per una finestra è JFrame. Si trova nel package javax.swing. Aggiungiamo quindi l’istruzione import all’inizio del nostro file.
// File: MiaPrimaFinestra.java import javax.swing.JFrame; // Importiamo la classe per la finestra public class MiaPrimaFinestra { public static void main(String[] args) { // Qui scriveremo il codice per creare la finestra System.out.println("Avvio creazione finestra..."); } }
Spiegazione: javax.swing è il package che contiene la maggior parte delle classi Swing. JFrame è la classe che rappresenta la finestra principale della nostra applicazione.
Creare l’Oggetto Finestra (JFrame)
Ora, all’interno del metodo main, creiamo un’istanza (un oggetto) della classe JFrame. Questo oggetto è la nostra finestra in memoria.
// File: MiaPrimaFinestra.java import javax.swing.JFrame; public class MiaPrimaFinestra { public static void main(String[] args) { System.out.println("Avvio creazione finestra..."); // 1. Creazione dell'oggetto JFrame JFrame finestra = new JFrame(); // 'finestra' è la nostra variabile che contiene l'oggetto finestra System.out.println("Oggetto JFrame creato."); } }
Spiegazione: JFrame finestra = new JFrame(); usa l’operatore new per invocare il costruttore di JFrame, creando un nuovo oggetto finestra e assegnandolo alla variabile finestra.
Impostare il Titolo della Finestra
Una finestra senza titolo è poco informativa. Usiamo il metodo setTitle() dell’oggetto JFrame per darle un nome.
// File: MiaPrimaFinestra.java import javax.swing.JFrame; public class MiaPrimaFinestra { public static void main(String[] args) { System.out.println("Avvio creazione finestra..."); JFrame finestra = new JFrame(); System.out.println("Oggetto JFrame creato."); // 2. Impostazione del titolo finestra.setTitle("La Mia Prima Finestra Swing"); System.out.println("Titolo impostato."); } }
Spiegazione: finestra.setTitle(…) chiama il metodo setTitle sull’oggetto finestra, passandogli una stringa che apparirà nella barra del titolo della finestra.
Impostare le Dimensioni della Finestra
La finestra, per ora, avrebbe dimensioni nulle o minime. Dobbiamo specificare larghezza e altezza in pixel usando il metodo setSize().
// File: MiaPrimaFinestra.java import javax.swing.JFrame; public class MiaPrimaFinestra { public static void main(String[] args) { System.out.println("Avvio creazione finestra..."); JFrame finestra = new JFrame(); System.out.println("Oggetto JFrame creato."); finestra.setTitle("La Mia Prima Finestra Swing"); System.out.println("Titolo impostato."); // 3. Impostazione delle dimensioni (larghezza, altezza in pixel) finestra.setSize(400, 300); // Una finestra 400x300 pixel System.out.println("Dimensioni impostate."); } }
Spiegazione: finestra.setSize(400, 300) imposta la larghezza della finestra a 400 pixel e l’altezza a 300 pixel.
Definire l’Operazione di Chiusura
Cosa succede quando l’utente clicca sulla “X” per chiudere la finestra? Dobbiamo specificarlo. Se non lo facciamo, la finestra potrebbe chiudersi, ma il programma Java rimarrebbe in esecuzione in background! L’opzione più comune è terminare l’applicazione.
// File: MiaPrimaFinestra.java import javax.swing.JFrame; public class MiaPrimaFinestra { public static void main(String[] args) { System.out.println("Avvio creazione finestra..."); JFrame finestra = new JFrame(); System.out.println("Oggetto JFrame creato."); finestra.setTitle("La Mia Prima Finestra Swing"); System.out.println("Titolo impostato."); finestra.setSize(400, 300); System.out.println("Dimensioni impostate."); // 4. Impostazione dell'operazione di chiusura // Fa sì che l'applicazione termini quando si chiude la finestra finestra.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); System.out.println("Operazione di chiusura impostata."); } }
Spiegazione: finestra.setDefaultCloseOperation(…) imposta il comportamento alla chiusura. JFrame.EXIT_ON_CLOSE è una costante statica della classe JFrame che indica di terminare l’intera applicazione (JVM) quando la finestra viene chiusa. È fondamentale per evitare che i programmi restino appesi.
Rendere Visibile la Finestra
Abbiamo configurato la nostra finestra, ma è ancora invisibile. L’ultimo passo fondamentale è renderla visibile sullo schermo.
// File: MiaPrimaFinestra.java import javax.swing.JFrame; public class MiaPrimaFinestra { public static void main(String[] args) { System.out.println("Avvio creazione finestra..."); JFrame finestra = new JFrame(); System.out.println("Oggetto JFrame creato."); finestra.setTitle("La Mia Prima Finestra Swing"); System.out.println("Titolo impostato."); finestra.setSize(400, 300); System.out.println("Dimensioni impostate."); finestra.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); System.out.println("Operazione di chiusura impostata."); // 5. Rendere la finestra visibile finestra.setVisible(true); // Importantissimo! System.out.println("Finestra resa visibile. L'applicazione è ora in attesa."); } }
Spiegazione: finestra.setVisible(true) dice al sistema di disegnare la finestra e mostrarla all’utente. Senza questa riga, il programma creerebbe la finestra in memoria ma non la vedreste mai.
Gestire il Threading di Swing (EDT)
Le operazioni sull’interfaccia grafica Swing non dovrebbero essere eseguite direttamente nel thread main. Swing ha un thread dedicato chiamato Event Dispatch Thread (EDT). Tutte le interazioni con i componenti Swing (creazione, modifica, aggiornamento) dovrebbero avvenire su questo thread per garantire la sicurezza e la reattività dell’interfaccia.
Il modo corretto per avviare un’applicazione Swing è usare SwingUtilities.invokeLater() o EventQueue.invokeLater(). Questi metodi accettano un oggetto Runnable (che contiene il codice per creare e mostrare la GUI) e pianificano la sua esecuzione sull’EDT.
Modifichiamo il nostro main per seguire questa buona pratica:
// File: MiaPrimaFinestra.java import javax.swing.JFrame; import javax.swing.SwingUtilities; // Importiamo SwingUtilities public class MiaPrimaFinestra { public static void main(String[] args) { // Eseguiamo la creazione della GUI nell'Event Dispatch Thread (EDT) SwingUtilities.invokeLater(new Runnable() { public void run() { // Tutto il codice di creazione e configurazione della finestra va qui dentro System.out.println("Esecuzione su EDT: Avvio creazione finestra..."); // 1. Creazione dell'oggetto JFrame JFrame finestra = new JFrame(); System.out.println("Esecuzione su EDT: Oggetto JFrame creato."); // 2. Impostazione del titolo finestra.setTitle("La Mia Prima Finestra Swing (EDT)"); System.out.println("Esecuzione su EDT: Titolo impostato."); // 3. Impostazione delle dimensioni (larghezza, altezza in pixel) finestra.setSize(400, 300); System.out.println("Esecuzione su EDT: Dimensioni impostate."); // 4. Impostazione dell'operazione di chiusura finestra.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); System.out.println("Esecuzione su EDT: Operazione di chiusura impostata."); // 5. Rendere la finestra visibile finestra.setVisible(true); System.out.println("Esecuzione su EDT: Finestra resa visibile."); } }); // Il thread main termina qui, ma l'EDT continua a gestire la finestra System.out.println("Metodo main terminato, l'applicazione attende sull'EDT."); } }
Spiegazione: Abbiamo racchiuso tutta la logica di creazione e visualizzazione della JFrame all’interno del metodo run() di un Runnable anonimo, passato a SwingUtilities.invokeLater(). Questo garantisce che il codice Swing venga eseguito nel modo corretto e sicuro sull’EDT.
Codice Completo Finale
import javax.swing.JFrame; import javax.swing.SwingUtilities; public class MiaPrimaFinestra { public static void main(String[] args) { // Utilizziamo invokeLater per assicurare che la creazione // e la manipolazione dei componenti Swing avvenga // sull'Event Dispatch Thread (EDT), come richiesto da Swing. SwingUtilities.invokeLater(new Runnable() { @Override public void run() { // Chiamiamo un metodo separato per creare e mostrare la GUI // Questo rende il codice più organizzato. creaEmostraGUI(); } }); } private static void creaEmostraGUI() { // 1. Creare la finestra (JFrame) // Possiamo passare il titolo direttamente al costruttore JFrame finestra = new JFrame("La Mia Prima Finestra Swing (EDT)"); // 2. Impostare l'operazione di default alla chiusura // Questo è FONDAMENTALE per terminare l'applicazione quando // la finestra viene chiusa dall'utente. finestra.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 3. Impostare le dimensioni della finestra // (larghezza, altezza) in pixel finestra.setSize(400, 300); // 4. (Opzionale ma comune) Centrare la finestra sullo schermo // Passando 'null', la finestra viene centrata rispetto allo schermo. finestra.setLocationRelativeTo(null); // 5. Rendere la finestra visibile // Senza questa chiamata, la finestra esiste ma non viene mostrata. finestra.setVisible(true); System.out.println("Finestra creata e visualizzata correttamente sull'EDT."); } }
Come Eseguire il Codice
Salvate il codice come MiaPrimaFinestra.java.
Da Riga di Comando:
- Compilate: javac MiaPrimaFinestra.java
- Eseguite: java MiaPrimaFinestra
Da un IDE:
- Create un nuovo progetto Java.
- Create una nuova classe MiaPrimaFinestra e incollate il codice.
- Eseguite il progetto (solitamente cliccando col destro sul file o sul progetto e scegliendo “Run” o “Run As Java Application”).
Dovreste vedere apparire una finestra vuota con il titolo che avete impostato, di dimensioni 400×300 pixel. Cliccando sulla “X” di chiusura, il programma dovrebbe terminare correttamente.
Riepilogo e Prossimi Passi
Oggi abbiamo imparato i passi essenziali per creare una finestra base con Swing:
- Importare JFrame.
- Creare un’istanza di JFrame.
- Impostare titolo, dimensioni e operazione di chiusura (EXIT_ON_CLOSE!).
- Rendere la finestra visibile (setVisible(true)).
- Utilizzare SwingUtilities.invokeLater per eseguire la creazione della GUI sull’EDT.
Questa è solo la base! I prossimi passi naturali sono:
- Aggiungere componenti alla finestra (etichette JLabel, pulsanti JButton, campi di testo JTextField).
- Comprendere i Layout Manager (come FlowLayout, BorderLayout, GridLayout) per organizzare i componenti all’interno della finestra.
- Gestire gli eventi (ad esempio, cosa succede quando si clicca un pulsante).
Spero che questa prima lezione vi sia stata utile. Non esitate a fare domande e/o lasciare un commento e, soprattutto, sperimentate modificando il codice! Buon lavoro!
