MokaByte Numero 29  -  Aprile 1999
Le keywords di Java
II parte
di 
Donato
Cappetta
Un riepilogo delle caratteristiche del linguaggio Java: 
tutte le keyword (parole chiave riservate)
 del linguaggio, brevi descrizione ed in alcuni casi 
 qualche frammento di codice


 
Prosegue  la rassegna iniziata il mese scroso sulle patle chiave del linguaggio Java
Indice delle Keyword del linguaggio Java
abstract (*) double (*) int (*) static
boolean (*) else (*) interface super
break (*) extends (*) long switch
byte (*) final (*) native synchronized
case (*) finally (*) new this
catch (*) float (*) null throw
char (*) for (*) package throws
class (*) goto (*) private transient
const (*) if (*) protected try
continue (*) implements (*) public void
default (*) import (*)  return volatile
do (*) instanceof  short while

 

(*) ne abbiamo parlato nella  prima parte dell'articolo apparsa il mese scorso
Parole chiave riservate
 

interface

Le interfacce (interface) servono a definire  un modello di comportamento che le classi devono implementare. 
Diversamente dalla gerarchia delle classi che è ad ereditarietà singola, la gerarchia delle interfacce è ad ereditarietà multipla.
Le interfacce possono ereditare da più "interfacce madri", esse passano alle loro "interfacce figlie" solo descrizioni di metodi (comportamenti) ma non implementazioni e né variabili istanza.
Le interfacce, per default, non ereditano da  Object che è una classe, e non esiste una "superinterfaccia madre" (diversamente dalla gerarchia delle classi dove Object è la superclasse di tutte le Classi).
Tutti i metodi definiti in un'interfaccia sono implicitamente public e abstract e non possono essere private. Le variabili sono implicitamente publicstatic e final.
L'ereditarietà tra le interfacce la si ottiene con la keyword extends.
Una classe implementa una o più interfacce mediante la keyword implements. Se una classe non implementa tutti i metodi contenuti nell'interfaccia allora sarà una classe astratta.
Vedere anche: implements, extends,class
 
Esempio:
public interface MiaInterfaccia {
    public static final int i = 10;
    int j = 0;    //diventa public static final

    public abstract int MioMetodo();
    int MioSecondoMetodo();    //diventa public abstract
}

Esempio2:
public interface MiaInterfaccia2 extends MiaInterfaccia, TuaInterfaccia {
    public static final float x = 100;
    public abstract float AltroMetodo();
}


 

long

Tipo di dato primitivo che rappresenta valori compresi fra –9223372036854775808 a 9223372036854775807 inclusi.
Vedere anche: short, byte, int, char
 

native

 "metodi native" sono metodi dichiarati in Java ma implementati tramite un linguaggio diverso, solitamente in C, e compilati in una libreria dinamica (DLL).
Vengono utilizzati, generalmente,  per motivi di efficienza o per accedere a particolari risorse non direttamente accessibili da Java.
Vedere anche: static
Esempio:
public class MiaClasse {
    ...
    public
native ApriFile();
}

new

Per creare un nuovo oggetto si utilizza new seguita dal nome della classe di cui si vuole creare un'istanza. new  crea un'istanza della classe e alloca la memoria per quell'istanza. La creazione dell'istanza avviene richiamando il costruttore di quella classe.
Non è possibile creare istanze direttamente da classi astratte o interfacce benché esse rappresentano tipi di dati.
 
Esempio 1:
Date d = new Date();
String s = new String("s");
    ...
Esempio 2:
 ClasseAstratta ca = new ClasseConcretaCheEreditaDaClasseAstratta();
 MiaInterfaccia mi = new ClasseConcretaCheImplementaMiaInterfaccia();
Esempi Errati:
 ERRATO --> ClasseAstratta ca = new ClasseAstratta();  <-- ERRATO
 ERRATO --> MiaInterfaccia ma = new MiaInterfaccia();  <-- ERRATO

null

La keyword null rappresenta l'assenza di un "reference". Può essere considerato come un valore polimorfo "sottotipo" del tipo reference.
Se si prova ad accedere ad un oggetto che ha valore null (run-time) viene generata l'eccezione NullPointerException.
 

package

I package rappresentano lo strumento impiegato da Java per organizzare e raggruppare  classi e interfacce "simili". In pratica i package consentono di organizzare librerie di classi e interfacce.
Per creare un package si una la keyword package seguita dal nomePackage.
Se l'istruzione package appare nel  file.java essa deve trovarsi all'inizio del fine prima di ogni altra istruzione (eccetto commenti e righe vuote).
Un package, a sua volta puo' contenere altri package (sottopackage).  L'organizzazione  è di tipo gerarchico (ad albero) ed è ottenuta usando la notazione '.' (punto). 
A livello di organizzazione su disco i package devono riflettere la stessa struttura gerarchica mediante directory e sottodirectory. Piu' package possono essere archiviati in un unico file (file.zip o file.jar). 
Il path che indica a Java (compilatore o interprete) dove sono archiviati i package deve essere settato nella variabile di ambiente CLASSPATH oppure impostato mediante delle opzioni fornite, in genere, dalla riga dei comandi. 
Per utilizzare un package si usa la keyword import.
E' consuetudine mettere come prefisso ai nomi dei package il nome del dominio dell'organizzazione che creato il package. Poichè viene già garantita l'univocità dei nomi di dominio si risolve il problema del conflitto dei nomi tra le classi.
 
Esempio:
package primoPackage;
public class MiaClasse {
...
}
Esempio2:
package primoPackage.secondoPackage;
public class tuaClasse {
...
}
Esempio3:
package it.azienda.primoPackage;
public class primaClasse {
...
}

 

private

Il modificatore private controlla la visibilità di metodi e variabili definiti in una classe, rispetto alle altre classi.
Esso offre il più alto livello di protezione possibile (minore visibilità).
I metodi e le variabili private non possono essere viste da nessuna altra classe diversa da quella in cui sono definiti.
In genere qualsiasi variabile che rappresenta lo stato interno della classe o qualsiasi implementazione che non deve essere accessibile ad altre classi o sottoclassi viene definita private.
Vedere anche: public, protected
Esempio:
public class MiaClasse {
    private int i;
    private int somma (int j) {...
    }
    public int getI() {...
    }
...
}

 

protected

Il modificatore protected controlla la visibilità di metodi e variabili definiti in una classe, rispetto alle altre classi.
Esso offre un livello di protezione intermedio tra private e public.
Protected è una relazione tra una classe e le sue sottoclassi (presenti e future).
I metodi e le variabili definiti protected, in una classe, sono accessibili dalle sottoclassi, e dalle classi che fanno parte dello stesso package. 
Accanto al modificatore protected esiste anche il modificatore private protected che consente l'accesso solo alle sottoclassi. 
Vedere anche: public, private
 

public

Il modificatore public controlla la visibilità di metodi e variabili definiti in una classe, rispetto alle altre classi.
Esso offre il più alto livello di visibilità. I metodi e le variabili definiti public, in una classe, sono accessibili da tutte le altre classi. Accanto al modificatore public esiste anche un modificatore di "default"  (senza modificatore) che permette la visibilità tra classi e sottoclassi dello stesso package. 
Il modificatore di "default" può essere visto come il modificatore public ma ristretto allo stesso package. 
Vedere anche: protected, private
 

return

Interrompe l'esecuzione del metodo corrente e restituisce il controllo allo statements chiamante.
 

short

Tipo di dato primitivo che rappresenta valori compresi tra –32768 a  32767,  inclusi.
Vedere anche: byte, int, long, char
 

static

Dichiara una variabli o un metodo "di classe".
Il modificatore static, può essere utile nei  casi in cui bisogna  avere una variabile di una classe condivisa e  visibile (utilizzabile) da tutte le proprie istanze. 
Quando si utilizza una variabile all'interno di una classe ogni istanza della classe (oggetto) riceve una copia della variabile, con static, invece, esiste una sola copia "globale" a tutte le istanze di una determinata classe. 
I metodi di classe sono analoghi alle variabili di classe ed è possibile accedervi usando direttamente la sintassi: 
NomeClasse.NomeMetodoStatico senza creare un'istanza della classe.  In pratica, le variabile (o i metodi) definiti static sono un l'equivalente delle variabili globali (o delle funzioni) esistenti negli altri linguaggi di programmazione. I metodi static sono final per default.
static viene utilizzato, anche, per caricare una libreria dinamica (DLL) la prima volta che viene istanziata una classe.
Esempio:
public class Istanza {
    private static int i = 0;
    private static void incrementa() {
        i++;
    }
    ...
    public Istanza() {
        Istanza.incrementa();
    }
    ...
}

Esempio di utilizzo per caricare una DLL:
public class MiaClasse {
    ...
    static { 
       System.loadLibrary("miaDLL");
    }
}


 

super

La keyword super fa riferimento all'istanza superiore nella gerarchia delle  classi.
Se ho ridefinito un metodo (overriding) ma voglio richiamare lo stesso della superclasse allora usosuper.nomeMetodo().
Se nel costruttore di una classe voglio richiamare il costruttore della superclasse allora uso, nella prima riga del costruttore, super().
Nel caso utilizzo super nel distruttore (finalize) di una classe allora va invocato nell'ultima riga.
Vedere anche: this
 

switch

L'istruzione switch permette di eseguire porzioni diverse di codice in base al risultato di un confronto.
Il confronto avviene tra il  valore fornito e quelli indicati nelle varie clausole case. E' necessario inserire la keyword break per interrompere il confronto. 
E' opzionale l'istruzione default che viene eseguita se nessun case soddisfa il confronto o se non vi sono break. I valori di confronto dell'istruzione switch devono essere di tipo primitivo convertibili a int (byte, char, int, short).
Vedere anche: if
 
Esempio:
switch (test) {
case valUno:
    ...
    break;
case valDue:
    ...
    break;
default: valDefault;
}
Esempio2:
switch (i) {
case 2:
case 4:
case 6:
case 8:
    System.out.println("Pari");
    break;
default: System.out.println("Dispari");;
}

 

synchronized

La keyword synchronized  è legata, generalmente, al multithreading del linguaggio Java. Essa indica alla Java Virtual Machine di proteggere un blocco di codice da eventuali accessi simultanei in modo che soltanto un thread ha la possibilità di eseguire quel blocco di codice e gli altri thread devono aspettare.
La keyword può essere utilizzata per controllare l'accesso ad un blocco di codice, una variabile, un metodo o un'intera classe.
Vedere anche: volatile
Esempio:
public synchronized void add() {
    i++;
}

Esempio2:
synchronized (i) {
    j = i;
}


 

throw

La keyword è associata alla tecnica di gestione delle condizioni di errore o di eccezioni usata dal linguaggio Java. Essa consente, all'interno di uno statement, di  generare o rilanciare un'eccezione. 
Le eccezioni che possono essere generate da un metodo devono essere elencate nella clausola throws del metodo stesso.
Un'eccezione è un oggetto che rappresenta un'istanza della classe Throwable (o una sua sottoclasse).
Vedere anche: try
Esempio:
public void metodoConEccezione() throws MiaEccezione {
     ...
  if (condizioneDiErrore) {
    throw new MiaEccezione();
    }
}

Esempio2:
public void metodoConEccezione2() throws MiaEccezione {
    try {
        metodoConEccezione();
    catch (MiaEccezione me) {
    throw me;
    }
}


 

throws

La keyword è associata alla tecnica di gestione delle condizioni di errore o di eccezioni usata dal linguaggio Java. Essa dichiara che un metodo può generare un'eccezione. Essa "avvisa" il compilatore (ma anche il programmatore) che vanno gestite delle  possibile condizione di errore, elencate nella clausola throws.
Un'eccezione è un oggetto che rappresenta un'istanza della classe Throwable (o una sua sottoclasse).
Vedere anche: try , throw
 
Esempio:
public void metodoConEccezione() throws MiaPrimaEccezione, MiaSecondaEccezione {
    istruzioneEccezionale;
}

 
 

transient

Il modificatore e legato alla "persistenza" (serializzazione) degli oggetti del linguaggio Java  e consente di dichiarare una variabile non "persistente". 
Indica che la variabile non è parte persistente dello stato di un oggetto. Di conseguenza, durante il salvataggio  di un oggetto il valore delle variabili transient non viene salvato cioè lo stato di queste  variabili non viene conservato.
Una variabile transient non può essere final o static.
 
 

try

La keyword è associata alla tecnica di gestione delle condizioni di errore o di eccezioni usata dal linguaggio Java. Essa avvisa la Java Virtual Machine di eseguire il blocco di codice racchiuso dalla clausola try e se si verificano delle condizioni di errore di utilizzare il "gestore" di eccezioni indicato nella clausola catch. E' possibile avere, alla fine dell'istruzione try tante clausole catch per quante eccezioni possono essere generate. 
Ad ogni try va sempre associato un gestore di eccezione mediante la clausola catch e/o finally. 
Un'eccezione è un oggetto che rappresenta un'istanza della classe Throwable (o una sua sottoclasse).
Vedere anche: throw, throws
Esempio:
try {
    UnMetodoEccezionale();
} catch (NullPointerException npe) {
    ...
} catch (IOException ioe) {
    ...
}

Esempio2:
try {
    UnMetodoEccezionale();
} catch (NullPointerException npe) {
    ...
} finally {
    istruzioneImportante;
}
 
 

void

Dichiara un metodo che non restituisce nessun tipo di dato
Esempio:
public void mioMetodo { 
    System.out.println("Salve mondo!"); 
} 
 
 

volatile

La keyword volatile è legata, generalmente, al multithreading del linguaggio Java. Essa indica alla Java Virtual Machine (JVM) che una variabile può essere modificata in modo "asincrona" da diversi thread. La JVM in questo modo ricarica e salva in memoria il valore della variabile ad ogni accesso alla variabile.
Una variabile volatile non può essere final.
Vedere anche: synchronized
 
Esempio:
class Test {
    static volatile int i = 0, j = 0;
    static void one() { i++; j++; }
    static void two() {
        System.out.println("i=" + i + " j=" + j);
    }
}
while
Il ciclo while esegue ripetutamente un'istruzione o un blocco fino a quando una "condizione" booleana diventa falsa. 
Vedere anche: do
 
Sintassi:
while (condizione){ 
    statement; 
} 

 

end

Ooops ... volevo dire che le keyword finiscono qui :-) . 
Per qualsiasi suggerimento,  se ne manca qualcuna o se avete degli esempi brevi ma completi di utilizzo di una keyword, scrivetemi,  saranno inseriti in una successiva versione di questa Rubrica.
 
 
 

RiferimentiBibliografici

"The Java ™ Language Specification" disponibile sul sito FTP di javasoft: ftp://ftp.javasoft.com/docs/specs
"Java - Guida Completa" di L. Lemay C.L. Perkins - Apogeo

  
 
MokaByte rivista web su Java

MokaByte ricerca nuovi collaboratori
Chi volesse mettersi in contatto con noi può farlo scrivendo a mokainfo@mokabyte.it