Teoria di Java - Cosa sono le classi Java?

Chiunque inizi ad affacciarsi al linguaggio di programmazione Java entra immediatamente in contatto con la nozione di classe.
Una prima definizione che si può incontrare nella manualistica è che una classe è "un'astrazione indicante un insieme di oggetti che condividono le stesse caratteristiche e le stesse funzionalità" (Claudio De Sio Cesari - Manuale di Java 6; Hoepli Milano).
La frase può apparire difficile, ma non lo è se la scomponiamo.
Innanzi tutto, capiamo che la classe è un elemento astratto (che quindi non ha effetti, riflessi e non agisce o interagisce con la realtà).
Usiamo un elemento molto di moda: un mutuo con una banca o con una finanziaria.
La classe (che potremmo chiamare Mutuo) altro non è che il concetto di mutuo (con la banca ad esempio). Il concetto di mutuo non interagisce con la realtà, né può esserne influenzato, in quanto è - appunto - solamente un concetto.
Nella realtà - ai fini di determinare eventi concreti o di utilizzare il mutuo - la classe (il concetto) non ci è quindi di nessun aiuto.
La classe ci serve solamente come schema, visto che il contratto di mutuo ha un numero n di rate, le quali sono pari ad x euro al mese, ha una certa data di scadenza e, anche, un numero di contratto e una data di stipulazione.
E ogni contratto di mutuo ha quelle caratteristiche, uno diverso dall'altro, ognuno ha la propria data, il proprio numero di rate e i propri importi.
La classe delinea solo lo schema delle caratteristiche (oltre ad altre cose, che per ora lasciamo da parte), stabilendo gli elementi che caratterizzano quel concetto astratto.
La classe diventa rilevante per la realtà, e quindi utilizzabile in concreto oppure modificabile realmente, quando trasformiamo quel concetto in un oggetto.
Se volessimo riferisci al nostro contratto di mutuo, dovremmo quindi creare (usiamo questo termine) un oggetto di quella classe. A quel punto andremo a caratterizzare quell'oggetto (che non è più classe in quanto è diventato concreto) con i propri specifici parametri (attributi): 120 rate, 1.000 euro mensili di rata, scadenza al 30.11.2024, n. di contratto 123456, data di stipulazione 24.11.2014.
Quindi avremo un oggetto (che potremmo chiamare mioContratto) ad esempio.
E lo creiamo, in linguaggio tecnico, instanziando la classe (creando un'istanza della classe):
Mutuo mioContratto = new Mutuo();
Con questa istruzione (molto semplificata trattandosi di far capire solo il concetto), creiamo un oggetto di nome mioContratto che appartiene alla classe Mutuo.
Tradotto, mi perdonino i puristi di questo tentativo estremo, è qualcosa di questo tipo: l'elemento di tipo mutuo (cioè di classe Mutuo) col nome mioContratto è (=) un nuovo elemento di tipo mutuo (new Mutuo).
Tale nuovo elemento porterà con se lo schema di qualsiasi mutuo, e potrà essere caratterizzato con i paramenti suoi propri (numeri di rate, durata, ecc..), potrà interagire con la realtà ed esserne influenzato o potrà essere interrogato dall'esterno. In buona sostanza sarà reale.

Creare una finestra con Java - JFrame con Swing

Creare una finestra con Java è un'operazione piuttosto semplice.

A tal fine dobbiamo utilizzare la classe JFrame, creandone un'istanza, fornendo qualche impostazione e rendendola visibile.

Ma andiamo con ordine.

1) Istanziare un oggetto della classe JFrame:
     JFrame finestra = new JFrame("Titolo della finestra");

Come parametro (al costruttore dell'oggetto creato) passiamo una stringa con il titolo della finestra (potrete indicare ad esempio il nome della vostra applicazione).

2) Impostare la posizione della finestra sullo schermo:
    finestra.setBounds(10, 20, 500, 400);

Con il metodo setBounds della classe JFrame, impostiamo quattro numeri interi, che corrispondono alla distanza - in pixel - dal bordo sinistro dello schermo (nel nostro caso 10 pixel), alla distanza dal bordo superiore (nel nostro caso 20 pixel), alla larghezza della finestra (noi abbiamo indicato 500 pixel) e all'altezza della finestra (400 pixel). La nostra finestra avrà quindi una dimensione di 500 pixel per 400 pixel.

3) Rendiamo visibile la finestra che abbiamo creato:
    finestra.setVisible(true);

La finestra che abbiamo creato al punto 1) non è visibile sul nostro monitor prima che ciò venga ordinato dal programmatore. Con il metodo setVisible (con parametro true) rendiamo la finestra visibile (vale anche il contrario, cioè che passando false quale parametro faremo sparire una finestra che prima avevamo reso visibile).

Queste le semplici operazioni per creare la vostra prima finestra. Noterete che anche cliccando il pulsante di chiusura della finestra, l'applicazione non verrà terminata (ciò perché potreste avere applicazioni con più finestre che potrebbero voler continuare la propria esecuzione anche se una delle finestre viene chiusa).
Prossimamente spiegherò come determinare la chiusura dell'intera applicazione quando viene chiusa una finestra.
Di seguito l'intero codice della classe per la creazione della finestra (ricordate di importare la classe JFrame del framework Swing, già compreso nella normale versione Java (import javax.swing.JFrame;):

import javax.swing.JFrame;

package finestra;

public class Finestra 
{
    public static void main(String[] args) 
    {
        JFrame finestra = new JFrame("Titolo della finestra");
        finestra.setBounds(10, 20, 500, 400);
        finestra.setVisible(true);
    }
}