A questo punto siamo in grado di creare le nostre classi in maniera appropriata, con tutti gli attributi e i metodi che ci servono, ma per organizzare tutto a dovere dobbiamo ancora fare qualche precisazione.
Adesso sappiamo che le classi possono essere organizzate in strutture gerarchiche, grazie ai meccanismi propri dell’OOP quali l’ereditarietà, ma questo non è l’unico modo possibile.
Se diamo un’occhiata alla documentazione fornita con il Sun JDK, potremo notare che Java ci offre una nutrita libreria di classi predefinite, che implementano buona parte delle funzionalità di base necessarie e che sono più che sufficienti per le normali esigenze di programmazione, anche se per programmi più complessi può rendersi necessaria la creazione di una famiglia di nuove classi interagenti tra loro.

Java organizza classi e interfacce in package.
Possiamo considerare un package come un contenitore che raccoglie classi, interfacce ed altri package.
Le librerie di classi di Java, disponibili in ogni implementazione, sono contenute in un package denominato java, che a sua volta contiene package minori che definiscono sottoinsiemi specifici delle funzionalità del linguaggio, come la gestione dei file, le comunicazioni di rete e così via.
Con Java 2 sono state introdotti nuovi package, come javax.swing per GUI (Graphical User Interface) avanzate.
A priori le classi definite dall’utente hanno accesso solo alle classi contenute in java.lang, che contiene le funzionalità di base, mentre per utilizzare le classi di altri package occorre richiamarli esplicitamente per nome o importarli nel file sorgente.
Supponiamo di voler utilizzare la classe “Date”, contenuta nel package java.util, per creare un metodo che stampi a video la data odierna.

Possiamo utilizzare indistintamente:

class miaData {
    public static void stampa() {
      java.util.Date d = new java.util.Date();
      String s = d.toString();
           
      System.out.println(s);
    }
}

oppure :

import java.util.Date;

class miaData {
    public static void stampa() {
      Date d = new Date();
      String s = d.toString();
     
      System.out.println(s);
    }
}

Nel primo caso abbiamo richiamato esplicitamente la classe “Date” includendo il nome del package che la contiene all’interno del codice, nel secondo caso invece abbiamo importato la classe direttamente nel file sorgente, mediante l’istruzione import.
La seconda soluzione ci permette di utilizzare istruzioni più compatte per riferirci alla classe (si noti la differenza nelle due dichiarazioni della variabile d), ed è quella che viene comunemente usata.
Quando si utilizzano più classi dello stesso package, si utilizza il nome del package, seguito da un punto e un asterisco.
Se ad es. dovessimo importare più classi dal package java.util, potremmo utilizzare l’istruzione:

import java.util.*;

All’interno di un codice sorgente si possono importare tutti i package che si vogliono, mediante più istruzioni import consecutive.

La notazione con asterisco non comporta, come si potrebbe pensare, l’importazione di tutte le classi e le interfacce del package, ma Java si occuperà di recuperare automaticamente da esso tutte le classi utilizzate nel codice sorgente.
Notiamo che in entrambi i codici di esempio precedenti, abbiamo dichiarato una variabile s di tipo “String” senza importare o riferire alcun package, come del resto abbiamo fatto negli esempi delle lezioni precedenti: ciò è possibile perché “String” è una classe del package java.lang.
Più avanti vedremo come definire i nostri package e come organizzare al loro interno le classi da noi create.
Per quanto riguarda la creazione di nuove classi, è opportuno fare una precisazione.
In Java ogni cosa è un oggetto, con l’unica eccezione dei tipi primitivi (anche se di questi, come abbiamo visto, esistono gli oggetti corrispondenti), quindi è logico pensare che ogni classe venga considerata come sottoclasse di un unico progenitore, la classe “Object”, che è la radice di tutta la gerarchia di classi (per indicare questa caratteristica parla di single root hierarchy, cioè gerarchia a radice singola).

Quando viene creata una nuova classe che non estende esplicitamente nessuna classe padre, ad es.:

class nuovaClasse {
    ...   
}

automaticamente viene definita come sottoclasse della classe “Object”, come se la definizione fosse la seguente:

class nuovaClasse extends java.lang.Object {
    ...
}

Con la prossima lezione inizieremo un nuovo capitolo, in cui vedremo come realizzare applicazioni Java.

Torna all'indice Generale del corso di Corso di Java di Software Planet