Differenze tra le versioni di "Java/Classi e oggetti"

In ogni caso non è possibile dichiarare private o protected una classe altrimenti non potrebbe essere estesa e questo non è possibile nella O.O.P..
'''L'interfaccia pubblica''' è costituita dall'insieme dei membri e istanze pubbliche, nel nostro esempio (Nomedellaclasse) tutte le istanze sono pubbliche. Se invece di “public” vi fosse “private” allora la classe avrebbe anche un''''interfaccia privata''' ed i membri “private” sono raggiungibili solo all'interno della classe o da classi annidate o da metodi “getter” e “setting” se presenti. Vedere[[Java/Modificatori| il capitolo sui modificatori]]. Le classi si passano informazioni e dati solo tramite l'interfaccia pubblica.
 
== 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 altrettanta facilità.<br/>
Il programmatore può assegnare una classe ad un suo package usando la parola chiave <tt>package</tt> seguita da un nome attribuitogli, caratterizzante l'insieme delle classi; con questa sintassi:
<source lang=java>package nomedelpackage;</source>
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:
<source lang=java>package saluti;</source>
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, la cartella "saluti" dovrà essere presente, perché è qui che vogliamo conservare il file insieme ad altri dello stesso argomento e crearci la nostra collezione di classi.
 
Dovrà esserci la directory saluti e dunque si pongono degli interrogativi: dove è montata la cartella saluti? A che livello del file System? Ricordiamoci che dopo deve essere anche ritovata e occorre sapere non solo il suo nome ma anche dov'è.
 
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. Questo percorso si chiama "CLASSPATH". "CLASSPATH" è anche il nome della variabile di sistema che va settata con il valore del percorso. Del CLASSPATH ne parliamo dopo.
 
La JVM per riutilizzare e ritrovare le classi, pur conoscendone il nome, 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. È necessario perciò che la prima parte dell'indirizzo deve essere già esistente sul disco fisso e ciò deve essere specificato anche al compilatore.
 
Ora poniamo che sia "/home/giovanni/mieclassi/", questo indirizzo lo dobbiamo specificare quando compiliamo le classi da archiviare, ed è questo il "CLASSPATH".
 
Si realizza con l'opzione "-d" di "javac" seguito dal CLASSPATH, in questo modo:
 
ripeto che l'indirizzo /home/giovanni/mieclassi/ deve già esistere realmente sul file system
 
<source lang=java>
javac -d /home/giovanni/mieclassi/ HelloWorld.java
</source>
 
Il compilatore leggerà nell'istruzione "package" il nome "saluti", creerà la directory e la accoderà. Automaticamente ci sarà /home/giovanni/mieclassi/saluti e lì metterà HelloWorld.class.
In questo caso è il compilatore che ha creato la cartella "saluti".
Non dobbiamo fare altro. Avremo archiviato la classe HelloWorld nel package saluti.
 
Questo indirizzo CLASSPATH dovrà essere lo stesso anche al momento della lettura delle classi, cosicché quando compiliamo un sorgente sia archiviando le classi e sia riusandole in lettura la JVM si riferirà alla medesima locazione di storage delle classi.
 
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 cambia 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.
 
Facciamo, per esempio, delle classi di saluto simili ad HelloWorld, in molte lingue, per tirarle fuori al bisogno, secondo la lingua parlata dagli utenti del programma.
 
Faremo questi file, notare il nome del package che ora sono con una directory e e una sottodirectory separate dal punto:
<source lang=java>
package saluti.inghilterra;
public class HelloWorld {
public void faisaluto () {
System.out.println("Hello, world!");
}
}
</source>
e
<source lang=java>
package saluti.francia;
public class HelloWorld {
public void faisaluto () {
System.out.println("Bonjour, monde!");
}
}
</source>
e
<source lang=java>
package saluti.italia;
public class HelloWorld {
public void faisaluto () {
System.out.println("Ciao, mondo!");
}
}
</source>
Se compilo ognuno di questi file con l'opzione "-d" del comando "javac", il compilatore
appronterà sul disco la directory “saluti” con all'interno le cartelle “inghilterra”, “francia”, “italia”, tutte e tre queste cartelle sono allo stesso livello: sottodirectory di saluti.
 
Per comodità possiamo anche compilarle tutte in un colpo solo, a condizione che nella dir corrente vi sono solo questi tre file, con il comando
javac -d /home/giovanni/mieclassi/ *.java
Grazie al segno "*" asterisco, tutte e tre Le classi Helloworld saranno compilate e stoccate nei rispettivi packages.
 
Non cambia niente per la prima parte dell'indirizzo, il classpath, di cui parlavamo sopra che rimane invariato.
 
Un'altra cartella ancora.
 
Se archivio con un package così “packages saluti.italia.dialetto” allora ci sarà 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, anche se con nomi uguali “Helloworld.class”, sono stati messi, comunque, in directory separate e i file dal nome diverso nella medesima directory. Tutti sono comunque individuabili e riprendibili.
 
L' istruzione <source lang=java>package nomedelpackage;</source> è 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 automaticamente dalla JVM.
 
Vediamo come riusare le nostre classi.
 
== Importare le classi ==