Java/Classi e oggetti

Vediamo uno dei componenti fondamentali dei programmi in java, la classe.

Classe

Una classe è contenitore, un insieme di elementi creato dal programmatore.
Classe ha un significato riconducibile alla parola "programma", la classe è la struttura stessa di un programma in java.

La classe ha lo scopo di delineare le proprietà e le caratteristiche degli elementi che vi fanno parte. Questi elementi possono poi essere creati realmente (istanziati) e diventano così “oggetti”: le istanze della classe sono gli oggetti. La classe è un po' come un progetto di qualcosa e l'oggetto è questo qualcosa realizzato concretamente. Gli elementi che compongono la classe possono essere i tipi primitivi i metodi i costruttori, oggetti di altre classi, cicli, classi stesse. Questi elementi sono tutti racchiusi in un contenitore (la classe) “class”. Vi è quindi la classe e gli oggetti: sono due cose diverse. Grazie all'esistenza delle classi possiamo creare gli oggetti. Gli oggetti sono allocati in memoria dalla JVM.

Per creare una classe devo usare la parola chiave class con questa sintassi:

public class Esempio {
/*
variabili e costanti...
metodi e costruttori...
cicli e controlli di flusso...
oggetti di classi e classi stesse...
*/
}

Si riporta l'esempio funzionante del capitolo "Primo programma" della classe HelloWorld:

public class HelloWorld {
    public static void main (String args[]) {
        System.out.println("Hello, world!");
    }
}

È convenzione che i nomi delle classi comincino con la maiuscola, ed è bene rispettare questa prassi, per la leggibilità del codice, anche se non è obbligatoria.

Interfaccia pubblica e privata della classe

Una classe è un tipo di dati astratto (TDA) scritto dal programmatore.

Esattamente come ci sono i tipi primitivi cosi ci sono i TDA del programmatore che si usano in maniera simile, tuttavia, mentre per i primitivi si parla di variabili, per i TDA si parla di oggetti. Inoltre, gli oggetti e i primitivi vengono allocati nella memoria in modalità e posizione diverse (rispettivamente nello heap e nello stack). Guardiamo come si dichiarano e inizializzano.

Per dichiarare un intero devo usare l'istruzione:

int a;

cioè devo dare un nome ad una variabile di tipo intero, quindi con "a" uso un valore intero che dovrò “inizializzare” (specificare).

Per dichiarare un oggetto devo usare invece:

NomeDellaClasse B;

cioè devo dare un nome ad un oggetto di tipo NomeDellaClasse, quindi con "B" qui uso un riferimento a un oggetto, che dovrò “inizializzare” (specificare).

Non è permesso compilare senza inizializzare gli oggetti dichiarati, si può subito dichiararli e inizializzarli poi in un secondo momento, ma bisogna comunque farlo:

int a = 10;

userò il valore 10 con il nome “a” realmente e pertanto questo sarà allocato in memoria,

Nomedellaclasse B = new Nomedellaclasse();

userò realmente la classe essendo concretizzata nel suo oggetto, con il nome “B”, pertanto questo è allocato in memoria.

Nel primo caso uso un valore, direttamente, nel secondo il riferimento ad un valore. Il riferimento al valore è solo un indirizzo della memoria che punta al valore reale ma non è direttamente questo.

Le caratteristiche di base della classe sono all'interno dell'oggetto B e tutte le altre sono ottenibili. Adesso posso ottenere ciò che questa classe consente di fare realmente usando il nome oggetto "B" con la notazione NomeOggetto.NomeClasse e una chiamata ad un suo elemento , ad esempio posso fare:

B.faifrase(); 

Ovvero chiamo un metodo che è scritto in Nomedellaclasse, e la JVM eseguirà realmente ciò che è scritto in questo metodo.

public class Nomedellaclasse {

    String soggetto= "egli ";
    String verbo= "fa ";
    String complemento= "qualcosa";

    public void faifrase(){
        System.out.println(soggetto + verbo + complemento);
    }
   
    public static void main(String [] Args){
    
        Nomedellaclasse B= new Nomedellaclasse();
        B.faifrase();
 
    }
}

Ottengo la scritta "egli fa qualcosa".

Ancora..., posso addirittura accedere ai singoli elementi e cambiarli:

B.soggetto= "lui ";

In questo modo

public class Nomedellaclasse {

    String soggetto= "egli ";
    String verbo= "fa ";
    String complemento= "qualcosa";

    public void faifrase(){
        System.out.println(soggetto + verbo + complemento);
    }
   
    public static void main(String [] Args){
    
        Nomedellaclasse B= new Nomedellaclasse();
        B.soggetto= "lui";
        B.faifrase();
 
    }
}

Avrò l'output "Lui fa qualcosa".

Vi sono già migliaia di classi preconfezionate già pronte e usabili dal programmatore per la stesura del codice sorgente. Queste classi sono documentate ampiamente ed in modo ordinato dalla Sun con il nome di API nella documentazione del JDK (Java Development Kit). Il programmatore non deve far altro che usare le classi già esistenti ed adattarle ai propri scopi con modalità predefinite come l'ereditarietà.

Mediante le classi è possibile e necessario incapsulare, ereditare, polimorfizzare il codice. Incapsulamento, ereditarietà, polimorfismo, sono le modalità della programmazione orientata agli oggetti (O.O.P.) che determina la differenza rispetto ai precedenti linguaggi procedurali e strutturati, rendendola più performante in quanto diviene modulare, scalabile, riusabile. Il programmatore partendo dalle classi standard dei packages può arrivare a specificare proprie classi personali più adatte per l'uso del software previsto. Le classi esistenti sono già ottimizzate e collaudate, consentendo un risparmio di lavoro notevole, è difficile se non impossibile farne a meno, ed è anche fortemente sconsigliato. Occorre verificare e confrontare le API sempre e comunque per scegliere le classi a cui aggangiarsi per la stesura del proprio software.

Il programmatore può scrivere le classi ereditando da altre classi, nidificandole, implementando le classi astratte e interfacce. Per tutte queste pratiche e per il loro uso, vedere il capitolo sull'ereditarietà.

Queste classi (API) sono davvero numerose e per ordinarle in modo che fossero facilmente usabili sono state raggruppate in insiemi specifici, i package.

Archiviare le classi

I package sono meri contenitori di classi esattamente come le directory lo sono per i files e tra l'altro vale la stessa regola: nello stesso package non vi possono essere due classi con lo stesso nome così come nella stessa directory non vi possono essere due file con lo stesso nome.

Il programmatore così come può creare sue classi così può ordinarle in suoi package. Ordinare proprie classi può servire a ritrovarle con facilità e a riusarle, vedremo poi come, con altrattanda facilità.
Il programmatore può assegnare una classe ad un suo package usando la parola chiave package seguita da un nome attribuitogli, caratterizzante l'insieme delle classi; con questa sintassi:

package nomedelpackage;

Questa istruzione deve essere la prima in assoluto del codice sorgente e inoltre il nome non deve cominciare con "java." poiché questo è riservato solo ai package standard della JDK. Il nome del package dovrebbe essere indicativo delle caratteristiche della collezione delle classi. Per archiviare la classe "HelloWorld". che abbiamo visto prima, in un package di nome "saluti" dobbiamo scrivere:

package saluti;

I package hanno un sistema di nomi strutturato.

Gli ambienti integrati di sviluppo “IDE” usano loro modalità di stoccaggio delle classi per cui occorre vedere la documentazione relativa, questi ambienti nell'automatizzare e facilitare il processo, e spesso questo è utile, purtroppo oscurano la procedura.

Compilando “a mano” la procedura diventa trasparente, più chiara, almeno per quanto riguarda la formazione di pacchetti di classi del programmatore.

I nomi del package devono avere una corrispondenza diretta nel filesystem: ad esempio, se si vuole archiviare il file helloWorld.class nella cartella “saluti” del file system, dovremo creare la cartella "saluti" perch* è qui che vogliamo conservare il file insieme ad altri dello stesso argomento e crearci la nostra collezione di classi.

La directory saluti si può creare con l'opzione "-d" di "javac", e sarà creata dallo stesso compilatore, oppure dovremo crearla noi. E qui si pongono degli interrogativi: dove montare la cartella saluti? A che livello del file System?

Entra in gioco un percorso parziale che comincia dalla root e si interrompe al livello superiore più vicino alla directory del package, il percorso a monte della cartella “saluti”: questo percorso è importante se vogliamo ritrovare poi le nostre classi.

Noi compiliamo, inserendo le classi nelle directory del package, con l'opzione -d di javac oppure "a manoni", e la JVM, per riutilizzarle e ritrovarle, pur conoscendole non sa dove sono montate. La JVM sa che la classe HelloWorld è nella cartella “saluti” ma non sa dove è questa, sà mezzo percorso, quello del package, l'ultima parte dell'indirizzo assoluto. La prima parte dell'indirizzo dobbiamo specificarlo. Ora poniamo che sia /home/giovanni/mieclassi/, e questo dovrà essere settato nel CLASSPATH, ora non serve perchè archiviamo le classi, occorrerà dopo per riutilizzarle e dopo ne parliamo.

Se si compila a riga di comando, per crearsi propri pacchetti di classi, compilare il file sorgente, opzionalmente, in questi modi:

1. Il file sorgente è nella dir corrente. Con l'opzione “-d” del comando javac. Così: javac -d /home/giovanni/mieclassi/ Helloworld.java.
   In questo modo è il compilatore che farà tutto: creerà le directory di storage delle classi, così come indicato nella parola chiave package del file sorgente HelloWorld, nel livello file system indicato dall'opzione “-d”. Il compilatore creerà in automatico /home/giovanni/mieclassi/saluti e lì metterà HelloWorld.class. Non dobbiamo fare altro.
2. Il file sorgente è nella dir corrente. Compilarlo normalmente e metterlo a manoni nella cartella package che deve essere creata. in questo modo; javac HelloWorld per primo, dopo prendere HelloWorld.class e spostarlo nella cartella saluti che dobbiamo creato appena prima. la cartella saluti sarà a sua volta in /home/giovanni/mieclassi/.
3. La dir del package è la directory corrente e all'interno vi è anche il file sorgente. Complilarlo con javac e quindi sarà creato il file HelloWorld.class in loco. La directory corrente deve essere la medesima della directory del package.

Il package può avere anche più directory. Nel caso produciamo molte classi esse infatti andranno stipate in cartelle diverse ed il nome della cartella, chiaramente, indicherà il contenuto.

Con più directory ambia di poco: metteremo un punto “.” tra una directory e l'altra sul codice dopo l'istruzione package. La jvm cambierà automaticamente il punto nel carattere separatore del sistema operativo usato e la classe dovrà essere archiviata nell'ultima sottodirectory.

Mettiamo che voglio fare delle classi di saluto simili ad HelloWorld ma in molte lingue e tirarle fuori, quando ne ho bisogno, secondo la nazionalità degli utenti del programma.

Faremo questi file:

package saluti.inghilterra;
public class HelloWorld {
    public void faisaluto () {
       System.out.println("Hello, world!");
   }
}

e

package saluti.francia;
public class HelloWorld {
   public void faisaluto ()  {
       System.out.println("Bonjour, monde!");
   }
}

e

package saluti.italia;
public class HelloWorld {
   public void faisaluto ()  {
       System.out.println("Ciao, mondo!");
   }
}

Sul disco preparerò la directory “saluti” con all'interno le cartelle “inghilterra”, “francia”, “italia”, tutte e tre queste cartelle sono allo stesso livello sottodirectory di saluti.

Non cambia niente per la prima parte dell'indirizzo di cui parlavamo sopra che rimane invariato.

Un'altra cartella ancora.

Se archivio con un package così “packages saluti.italia.dialetto” allora dovrà esserci la cartella dialetto come sottodirectory della cartella italia. All'interno di dialetto dovranno esserci i file corrispondenti dei saluti italiani in dialetto, ognuno con un diverso nome. I file con nomi uguali “Helloworld.class” sono stati messi in directory separate e i file dal nome diverso nella medesima directory. Tutti sono comunque individuabili e riprendibili.

L' istruzione

package nomedelpackage;

è facoltativa, è possibile non metterla: se queste non c'è, il compilatore inserisce la classe in un package di default.

I files del package di default saranno inseriti dalla JVM nella radice del percorso del CLASSPATH: da questo stesso posto verranno lette le classi compilate senza l'istruzione package.

Vediamo come riusare le nostre classi.

Importare le classi

Per riutilizzare le classi stoccate in precedenza è necessario ma solo per i package personali come quelli che abbiamo fatto sopra usare la variabile di sistema CLASSPATH.

La JVM per i package standard di java, ovvero le API del linguaggio java, è già a posto , se li trova automaticamente da sola, in quanto generalmente l'installazione del jDK, fatta normanlmente, include il percorso automaticamente. Quindi questo è valido per le installazioni tipiche. E' possibile per installazioni personalizzate inserire classpath anche per le API standard se queste fossero in directory scelte da noi.

Il Classpath serve, per dirgli dove sono solo i nostri package. il classpath si setta nelle variabili utente del sistema.

Per windows: Pannello di Controllo - Sistema - Avanzate - Variabili d'ambiente - Variabili utente

Per linux da shell: export CLASSPATH= /home/giovanni/mieclassi

Attenzione: nel capitolo installazione abbiamo parlato della variabile PATH che quì non c'entra niente, sono due cose molto diverse, alcuni le confondono. La variabile PATH fa riferimento agli eseguibili java come i programmi java, javac, jar, ed altri, mentre la CLASSPATH punta alle classi.

Per usare le classi dei package bisogna scrivere la parola chiave import.

Precisamente

import nomedelpackage;

Questa istruzione va inserita dopo "package", se presente (perchè è opzionale), e prima di "class".

Vogliamo riusare le classi che abbiamo già fatto. Per farlo dobbiamo dire all'interprete dove sono le classi e in contemporanea quali sono. Dove e quali...

Se volessimo richiamare le nostre classi, prima archiviate, dovremo fare

import saluti.*;

dove "saluti" sta ad indicare la directory e l'asterisco i nomi dei file (asterisco = vogliamo tutti i file). L'interprete inserirà, prima della directory "saluti", il percorso del classpath e così troverà lindirizzo assoluto delle classi archiviate, vedrà anche l'asterisco e quindi ad ogni chiamata andrà a prendere il file corrispondente. Se non mettessimo l'asterisco dovremo mettere il nome preciso del file.class. Invece e quasi sempre, abbiamo bisogno di riusare molte classi e perciò è comodo l'asterisco.

Spessissimo, avremo bisogno di accedere alle classi contenute nei packages del JDK. Nel JDK la sun fornisce una copiosa quantità di packages disponibili all'uso.

Alcuni package di base delle librerie standard java :

• java.lang è il package che contiene le classi di base del linguaggio
• java.util raccoglie classi d’utilità generale
• java.io contiene le classi per programmare l’input-output
• java.awt contiene classi per programmare interfacce grafiche
• java.net contiene classi per programmare connessioni
• java.applet contiene classi per programmare applet