Di seguito sono elencate e descritte le istruzioni (parole chiave) del linguaggio Java.
abstract
Esempio:
import java.io.*; // importazione delle classi di libreria per le funzioni di I/O
public abstract class Generale {
abstract void scrivi(); /* metodo solo dichiarato, senza corpo */
}
class Particolare extends Generale { /* Particolare eredita tutti i metodi di Generale */
void scrivi() { // sovrascrittura (override) del metodo astratto: si dota il metodo scrivi() di
// un corpo (body)
// uso del metodo println dalle librerie di classi di base
System.out.println("Questo metodo ha il suo modello astratto in una superclass");
}
}
boolean
boolean a = true; boolean b = false;
break
esterno: // label
for(i=0; i < 100; i++) {
for(j = 0; j < 10; j++) {
...
if(...) break esterno;
}
}
byte
case
catch
In abbinamento con l'istruzione try, catch serve per costruire individuatori (handler) di errori (exceptions) che si verificano durante l'esecuzione di un programma Java. Si vedano le istruzioni throw , try e finally.
char
class
package java.awt; /* la classe che viene definita appartiene all'insieme di classi awt */
/* in questo modulo sorgente si importano le classi seguenti; ovvero è come se esse fossero presenti in
questo stesso modulo sorgente */
import java.applet.AudioClip;
import java.io.*; // si importano tutte le classi (e interfacce) del gruppo "io";
public class LeggiFile extends InputStream implements FilenameFilter { /* la classe LeggiFile è una
sottoclasse di InputStream;
inoltre eredita i metodi
astratti del'interfaccia
FilenameFilte
<contenuto della classe: p.e. implementazione dei metodi astratti dichiarati in FilenameFilter>
}
Un modulo sorgente Java può contenere più classi (e interfacce). Il codice compilato in bytecodes di ogni classe (o interfaccia) deve però essere contenuto in un modulo distinto su file. Perciò, una volta compilato (tramite javac), un modulo sorgente si spezza in tanti moduli di codice macchina Java quanti sono le classi e le interfacce che lo stesso modulo sorgente contiene. In un modulo sorgente non possono essere dichiarate più di una classe (o interfaccia) di tipo public. Infatti, una classe di tipo public deve essere dichiarata in un modulo (file) sorgente che abbia lo stesso identico nome della classe. Parimenti, il modulo compilato in bytecodes di una classe di tipo public prenderà il nome della stessa classe.
Tutte le classi sono derivate da una unica classe radice che è Object. Tutte le classi, eccetto Object, possiedono perciò una classe superiore (superclass). Se una classe è dichiarata senza specificare esplicitamente una classe superiore (tramite l'istruzione extends), essa sarà sottoclasse diretta di Object.
continue
ciclo: for(i = 0; i <100; i++) {
for(j = 1; j < 1000; i++) {
if (a[i] [j] ==0) continue ciclo; // se a[i] [j] = 0, si esce dai due cicli
}
}
default
do
double
else
extends
class Secondaria extends Principale { ...
Nell'esempio di sopra, si dichiara la classe Secondaria imponendo che essa sia una sottoclasse della classe Principale. La classe Secondaria eredita tutti i metodi della classe superiore diretta Principale.
false
final
import java.lang.Math; // importazione della classe di libreria per le funzioni matematiche
final class Termine { // la classe Termine non può avere sottoclassi, ovvero non è possibile
// dichiarare: "class Termine2 extends Termine"
final double coeff = 2.45; // il valore di coeff non puo' essere modificato
final double funzione(double x, double y) {// il metodo funzione non puo' essere sovrascritto
double z;
y = Math.sin(x) * Math.cos(y); /* le funzioni cos e sin sono istanze della
classe di libreria java.lang.Math */
return z;
}
finally
try {
...
// codice con possibilità di errore
...
} catch(Exception e) {
System.out.println("Si e' verificato un errore");
} finally {
System.out.println("Questo messaggio verra' comunque scritto");
}
finally viene eseguita sempre, anche se il blocco try {...} contiene una istruzione di return, break, continue, o throw.
float
for
if
implements
class Particolare extends Generale implements Interfaccia1, Interfaccia2 {
A differenza dell'istruzione extends, che consente di specificare solo una classe superiore (superclass), l'istruzione interface permette di specificare più interfacce.
import
import java.net.socket;
Se invece, più in generale, si specifica:
import java.net.*;
si "importa" tutto il package java.net. Si può anche usare un metodo alternativo all'istruzione import per "importare" una classe:
acme.project.FooBar obj = new acme.project.FooBar();
instanceof
if (manometro instanceof StrumentiMisura) { /* verifica se manometro e' un oggetto di tipo
StrumentiMisura */
StrumentiMisura dev = (StrumentiMisura)manometro; /* cast di conversione analogo al C e al
C++ */
...
}
int
interface
public interface Storing { // dichiarazione di interfaccia
void freezeDry(Stream s); // dichiarazione di metodo astratto
void reconstitute(Stream s); // dichiarazione di metodo astratto
}
public class Image implements Storing, Painting { // classe che implementa l'interfacce Storing e
// Painting
...
void freezeDry(Stream s) { /* si da' corpo (si implementa) il primo metodo astratto
dell'intefaccia. */
... // qui ci puo' essere p.e. un algoritmo di compressione dei dati dello stream s
}
void reconstitute (Stream s) { /* si da' corpo al secondo metodo dell'interfaccia Storing */
... // qui ci puo' essere p.e. un algoritmo di decompressione dei dati dello stream s
}
}
Una interfaccia può a sua volta ereditare metodi astratti di altre interfacce, sempre tramite l'istruzione implements.
class StorageManager {
Stream stream;
...
void pickle(Storing obj) { // Storing e' il nome dell'interfaccia, che viene usata come
espressione sintattica di dichiaratore di tipo
obj.freezeDry(stream);
}
}
In questo caso la implementazione dei metodi astratti dell'interfaccia (nell'esempio Storing) deve essere fatta in qualche altra classe che implementa l'interfaccia stessa.
long
native
native double lunghezza();
I costruttori (constructors) non possono essere dichiarati nativi. I metodi nativi si comportano come i metodi non nativi. Per esempio, è possibile sovrascriverli (override).
new
import java.lang.Math;
class Mia { // classe con costruttori di se stessa
int a;
double b;
Mia( ) { // costruttore della classe Mia senza alcun parametro
a = 2;
b = Math.cos(2);
}
Mia(int x) { // costruttore della classe Mia con un parametro (int x)
a = x;
b = Math.sin(3);
}
Mia (int x, double y) { // costruttore della classe Mia con due parametri (int x, double y);
a = x;
b = y;
}
}
class Progetto { /* classe che fa istanzia la classe Mia in nuovi oggetti; si usano i diversi costruttori
della classe Mia */
int indice = 100;
public void calcola {
Mia oggettoMia1 = new Mia();
Mia oggettoMia2 = new Mia( indice);
Mia oggettoMia3 = new Mia(100, 2.33);
System.out.println(oggettoMia1.a);
}
}
null
package
package java.awt;
import java.awt.peer.ButtonPeer;
public class Button extends Components { ...
Un modulo sorgente privo dell'istruzione package verrà fatto appartenere ad un package di default senza nome.
../classes/java/awt/*.classes
Tramite apposite direttive è possibile cambiare il path superiore (../classes) ove l'interprete Java attinge durante l'esecuzione di un programma (per default l'interprete Java si trova in ../bin). Da notare che già in fase di compilazione vengono individuati gli errori derivati dalla mancata individuazione di una classe. Errori di questo genere sono comuni quando all'inizio del modulo sorgente viene omessa, per distrazione, l'istruzione di import relativa alla classe (o al package) a cui si fa riferimento. Ovviamente, non è necessario dare l'istruzione di import se si fa uso di classi ed interfacce tutte appartenenti allo stesso package.
private
protected
public
return
public double funzione(double x, double y) {
double z = Math.cos(x) * Math.tan (y);
return z;
}
short
static
super
Class QDialog extends Dialog {
public QDialog ( Frame f, String titolo, boolean modo) { /* costruttore di QDialog */
super(f, titolo, modo) /* si passano i parametri al costruttore della classe superiore, cioè
Dialog. Nota: l'istruzione super deve essere la prima nel costruttore
della sottoclasse (in questo caso QDialog) */
}
public boolean handleEvent(Event e) { /* metodo aggiunto */
if(e.id == Event.WINDOW_DESTROY) {
hide();
}
return false;
}
In questo modo, si aggiunge alla classe Dialog un metodo che gestisce l'evento di uscita dalla finestra. La nuova classe QDialog contiene questo nuovo metodo. Perciò un oggetto Dialog costruito con QDialog gestisce l'evento uscita dalla finestra.
Dialog d = new QDialog(mia_frame, "Finestra di dialogo", true); /* l'oggetto d di tipo Dialog gestisce l'uscita dalla finestra */
switch
synchronized
synchronized(<oggetto o classe da cui ricevere il "blocco">) {
<parte di codice con accesso sincronizzato>
}
Esempio di dichiarazione di metodo con accesso sincronizzato:
class Mia {
synchronized void mio(int i) {
// codice del metodo sincronizzato
}
Esempio di dichiarazione di una parte di codice che richiede accesso sincronizzato:
Class Mia {
InputStream mio_input;
synchronized(mio_ input) {
// codice sincronizzato con mio_input
}
this
class Mia {
void mio (AltraClasse oggetto) {
...
oggetto.metodo(this);
...
Ogni volta che un metodo fa riferimento alle proprie variabili e metodi istanziati, un this è implicito in fronte ad ognuna di essi:
class Mia {
int a, b, c;
...
void stampa() {
System.out.println(a + "\n"); // a == "this.a"
}
...
}
threadsafe
throw
transient
true
try
class MiaException extends Exception {
}
class Mia {
void metodo() {
if ( /* non si verifica l'errore */ ) {
...
} else { /* si verica l'errore*/
throw new MiaException();
}
}
}
Come già preannunciato, in un programma è possibile creare un gestore (handler) in grado di intercettare gli errori (exception) che si possono verificare. A tal uopo, è necessario circoscrivere il codice che può generare un certo errore (exception) con l'istruzione try{<codice con possibilità di errore>}. Dopo try{...} seguono una o più istruzioni di catch, una per ogni classe di exception che il programma può gestire a quel punto. Per esempio:
try {
p.a = 10;
} catch (NullPointerException e) {
println("p e' null");
} catch (Exception e) {
println("si e' verificato un altro errore");
} catch (Object obj) {
println("Oggetto richiamato a scopo di esempio");
}
La dichiarazione di catch è analoga alla dichiarazione di un metodo con un solo parametro come argomento e nessun tipo di ritorno (return type). Il parametro può essere una classe o anche una interfaccia. Quando si verifica un errore (exception), il ciclo composto dalle istruzioni try e catch ricerca il parametro che combacia con la classe dell'errore che si è verificato. Il parametro combacia con lo exception quando:
Nel ciclo try/catch, viene eseguita la prima istruzione di catch il cui parametro combacia con l'errore (exception) che si è verificato. Una volta eseguita l'istruzione di catch, l'esecuzione del programma riprende dopo l'intero ciclo try/catch (ovvero non vengono prese in considerazione le altre istruzioni di catch).
void
while