49333 Letture

Corso Java - Settima lezione: sviluppiamo la prima vera applicazione

In apertura del nostro settimo appuntamento dedicato alla programmazione Java è senza dubbio necessaria una premessa. Questo articolo è organizzato in maniera leggermente differente rispetto agli altri, dato che ho preferito inserire a questo punto del corso un argomento molto vasto (ci occuperemo di GUI) da affrontare quasi esclusivamente tranne la costruzione passo-passo di un'applicazione Java completa (benché per ovvi motivi semplici) di cui ovviamente è disponibile anche il codice sorgente. Da notare che in questa puntata ci occuperemo quasi esclusivamente dell'interfaccia grafica e di poche altre funzionalità, rimandando al lettore più intraprendente o alle prossime puntate la finalizzazione dell'applicazione. Questa impostazione ci permetterà di utilizzare in maniera fluida tutti i concetti fin qui appresi che sono, come già detto, la base della programmazione a oggetti.

Passo 1 - definizione di intenti


Come prima cosa quando ci si trova di fronte alla programmazione di un elemento software è necessario che sia chiaro cosa si vuole ottenere. Quello che ci proponiamo di ottenere è un semplice editor testuale (simile a note-pad di Microsoft tanto per intenderci, ma ancora più basilare). Per i nostri scopi non ci concentreremo granchè sull'implementazione di chissà quali funzionalità e programmeremo di fatto qualcosa di ancora più essenziale del note-pad stesso. La nostra attenzione è invece rivolta a capire come si utilizzano alcuni dei numerosissimi elementi grafici che Java ci mette a disposizione, lasciando al lettore più intraprendente, come già detto, il compito di sviluppare qualora lo desideri ulteriormente l'applicazione che verrà in ogni caso ripresa quando ci occuperemo di strema di I/O (input/output). Preme fare un paio di considerazioni:
1. Fino a qui non ci siamo occupati di come si gestisce il salvataggio/caricamento dati da file. Ce ne occuperemo in uno dei prossimi appuntamenti in maniera più approfondita, per ora è sufficiente cominciare a prendere contatto con questa realtà così come sarà presentata nel codice sorgente di questa esercitazione.
2. L'applicazione sarà prodotta e liberamente scaricabile come elemento stand-alone, la cui esecuzione sarà possibile sia tramite l'ambiente di sviluppo che direttamente dal sistema tramite file batch (per soli sistemi windows). Data la moltitudine di situazione differenti che potrebbero verificarsi, se dovessero esserci problemi rimandiamo al forum di discussione del sito per non appesantire ulteriormente questo spazio.
Per la stesura di questo semplice programmino utilizzeremo una minima parte dei metodi e delle classi che Java mette a disposizione. Per una conoscenza più approfondita rimandiamo come al solito alla documentazione ufficiale (e annesso tutorial) con riguardo particolare al package javax.swing.

Passo 2 - definizione della struttura

La nostra applicazione per essere eseguita ha ovviamente bisogno di essere implementata tramite classi. Il nostro progetto, benché non troppo complicato né elaborato, è sufficientemente esteso per dar luogo ad alcune riflessioni e per essere strutturato in maniera modulare. Prima di tutto, decidiamo di alleggerire il più possibile la classe che contiene il metodo main, e il metodo stesso. Questa è una operazione che si fa di frequente in Java, e permette di delegare la costruzione dell'interfaccia grafica ad altre classi. Cominciamo cioè col definire
- Una classe Jeditor contenente il metodo main
- Una classe JeditorGui che sarà in effetti la finestra principale del programma

La classe Jeditor si deve occupare di creare una nuova istanza di JeditorGui e visualizzarla sullo schermo.
Successivamente decidiamo che implementeremo anche
- Una classe JeditorAbout per la gestione (a titolo d'esempio ovviamente) della finestra About del programma.

Passo 3 - iniziamo a scrivere codice

E' evidente che il cuore dell'applicazione è la classe JeditorGui e abbiamo detto che questa deve essere la finestra principale della nostra applicazione. La classe Java che meglio implementa per i nostri scopi il concetto di finestra è la classe JFrame del package javax.swing. Questa non è l'unica classe che potremmo usare, dato che ad esempio esiste l'omologo Frame del package java.AWT (notate che questa è una caratteristica abbastanza comune, che si riscontra anche in altri componenti: l'aggiunta della J prima del nome serve a sottolineare che si tratta di classi del nuovo package swing, che è appunto scritto interamente in Java) oppure la classe JDialog (e la precedente Dialog, che vedremo più avanti in questa lezione) ma la JFrame è esattamente la classe che fa al caso nostro poiché implementa la finestra di programma che sia anche riducibile a icona e la cui dimensione sia modificabile. In parole povere, se state leggendo queste pagine tramite un qualunque browser visuale JFrame implementa lo stesso tipo di finestra del browser che state usando!
Stabilito che JFrame è la classe che fa al caso nostro, decidiamo per sfruttare al meglio le proprietà del linguaggio e per ottenere un programma più pulito di fare in modo che JeditorGui erediti da JFrame: questo ci permetterà di gestire gli elementi da inserire nella finestra in maniera molto semplice. Come primo step otteniamo:

import javax.swing.*;

public class JeditorGui extends JFrame{

        public JeditorGui(){
        }
}


dove abbiamo predisposto il costruttore della classe perché in seguito ci tornerà molto comodo usarlo. Notate come abbiamo importato tutte le classi del package javax.swing e non solo JFrame. La scelta è dovuta al fatto che dato che stiamo scrivendo una classe che implementa una interfaccia grafica è scontato che di qui in avanti utilizzeremo altri elementi grafici! Nel corso di queste pagine non mi soffermerò sugli elementi AWT che sono per molti aspetti obsoleti (ma non per tutti, ad esempio non lo sono se volete trasferire un elemento Java su un cellulare compatibile) quindi utilizzeremo in larga misura le possibilità di swing. Continuiamo lo sviluppo di questa classe definendo alcune semplici proprietà, ad esempio la posizione, il titolo e le misure della nostra finestra.


public JeditorGui(){
        super("Editor Java per IlSoftware.it");
        setSize(600,400);
        setLocation(200,200);
        }


La prima riga sfrutta una interessante proprietà dell'ereditarietà in Java, cioè la possibilità all'interno della classe figlio di usare il costruttore del padre ma solo ed esclusivamente nella prima riga del costruttore. Uno dei (tanti) costruttori di JFrame accetta in ingresso una stringa che è proprio il parametro che definisce il titolo della finestra, quindi sfruttiamo volentieri questa proprietà e andiamo oltre. Anche setSize e setLocation della classe JFrame (che a sua volta li eredità) e possiamo quindi utilizzarli su un oggetto di tipo JeditorGui senza nessuna difficoltà. Per quanto riguarda setLocation() è necessaria una piccola precisazione sul modello di coordinate usato da Java: l'angolo in alto a sinistra nello schermo corrisponde a O (0,0), il semiasse positivo delle x si trova alla destra di O e quello positivo delle y in basso rispetto ad O. Una figura in questo è probabilmente molto più esplicativa di molte parole:


L'area gialla nella figura rappresenta la nostra finestra e la parte grigia ovviamente lo schermo. Notate come con setLocation() abbiamo indicato la posizione dello spigolo in alto a sinistra (le misure sono espresse in pixel).
Nel frattempo, cosa deve succedere nel main? Nel metodo main della classe Jeditor banalmente dovremmo avere qualcosa di questo tipo


JeditorGui editor = new JeditorGui();
editor.setVisible(true);


cioè la creazione di una nuova istanza di un oggetto di tipo Jeditor e la chiamata a setVisible (che prende in ingresso un booleano) per rendere la nostra finestra visibile sullo schermo (NB per chi ha già programmato Java: l'utilizzo di show() è divenuto deprecated, pertanto è più corretto usare setVisible come nell'esempio). Se avviate il programma la finestra dovrebbe venire correttamente visualizzata.


Corso Java - Settima lezione: sviluppiamo la prima vera applicazione - IlSoftware.it