Le keywords di Java - MokaByte n. 28

Questa prima parte presenta un riepilogo delle parole chiave riservate del linguaggio Java, accompagnandole con brevi descrizioni e, quando utile, con frammenti di codice.

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 parleremo nella seconda parte dell'articolo.

Parole chiave riservate... ma non troppo

Nella versione 1.0 beta di "The Java™ Language Specification" (Specifiche sul linguaggio Java) erano riservate anche le keyword: cast, future, generic, inner, operator, outer, rest e var, ma di esse non veniva fornita nessuna documentazione, probabilmente erano previste per un utilizzo futuro.

Successivamente, nella versione finale delle specifiche, queste keyword sono state eliminate e quindi non sono parole riservate.

abstract

Il modificatore abstract può essere applicato nella dichiarazione di classi e di metodi.

Classi astratte: l'utilizzo di abstract nella dichiarazione di una classe è utile quando in una gerarchia di classi si individua una superclasse che opera come riferimento per tutte le altre classi, e si pensa di utilizzare soltanto le sue sottoclassi.

Le classi astratte non possono essere istanziate, ma possono contenere tutto quanto può contenere una classe normale ed in più metodi astratti, cioè metodi dichiarati privi di implementazione.

Una sottoclasse che eredita da una classe astratta deve implementare tutti i metodi dichiarati abstract altrimenti sarà anche essa classe astratta.

Una classe dichiarata con abstract è definita astratta.

Metodi astratti: un metodo astratto è un metodo privo di implementazione. In pratica viene definito solo il suo prototipo, è compito della sottoclasse implementare correttamente il metodo. Solo le classi astratte e le interfacce possono contenere metodi astratti.

Vedere anche: class.

Esempio:

public abstract class ClasseAstratta {
  int i = 1;
  // ...
  public abstract int metodoDaImplementare();
  public void metodoConcreto() {
    i++;
  }
}

boolean

Il booleano è un tipo di dato che ha due valori rappresentati dai letterali: true e false. Essi possono essere utilizzati ovunque si effettua un confronto o dove occorra un valore booleano. true e false sono gli unici valori boolean ammessi.

Esempio:

// ...
boolean a = true;
boolean b = false;
boolean c = x < y;
if (c)
// ...

break

L'istruzione break trasferisce il controllo fuori dal corrente statement.

Generalmente viene utilizzata all'interno di cicli while, do e for (e istruzioni switch) per interrompere l'esecuzione del ciclo.

Può essere utilizzata con etichetta (label) che indica dove riprendere l'elaborazione.

Vedere anche: continue.

Esempio:

// ...
inizio: // etichetta
// ...
break inizio;

byte

Tipo di dato primitivo che rappresenta valori compresi fra -128 e +127 inclusi.

Vedere anche: short, int, long, char.

case

Vedere: switch.

catch

Vedere: try.

char

Tipo di dato primitivo che rappresenta i valori dei caratteri Unicode compresi fra \u0000 e \uFFFF inclusi (da 0 a 65535).

class

La parola chiave class seguita dal nome della classe consente di definire una classe.

Una classe è un modello per diversi oggetti con caratteristiche simili. Una classe incorpora le caratteristiche di una famiglia particolare di oggetti.

Il termine "istanza di una classe" è sinonimo di oggetto effettivo. Mentre una classe è una rappresentazione generale di un oggetto, un'istanza ne è la rappresentazione concreta.

Se non diversamente specificato dalla keyword extends, le classi Java, per default, ereditano dalla superclasse java.lang.Object.

Java è un linguaggio ad "ereditarietà di classe" singola.

Vedere anche: extends, implements, interface.

Esempio 1:

class NomeClasse { // per default diventa extends Object
  // ...
}

Esempio 2:

public class NomeClasse extends SuperClasse {
  // ...
}

const

Il linguaggio Java comprende const come keyword ma non è attualmente utilizzata.

La definizione di costanti avviene mediante la parola chiave final che ha un significato più generale in quanto è applicabile anche a classi e metodi oltre che a variabili.

Vedere: final.

continue

L'istruzione continue trasferisce il controllo alla nuova iterazione.

Generalmente viene utilizzata all'interno di cicli while, do e for per interrompere l'iterazione corrente ed iniziarne una nuova. Può essere utilizzata con etichetta (label) che indica dove riprendere l'elaborazione.

Vedere anche: break.

default

Vedere: switch.

do...while

È una forma di ciclo, simile a while, che esegue ripetutamente un'istruzione o un blocco fino a quando una condizione diventa falsa.

Il controllo sulla condizione viene fatto alla fine del blocco.

Vedere anche: while.

Sintassi:

do {
  statement;
} while (condizione);

double

Tipo di dato primitivo che rappresenta numeri in virgola mobile (numeri reali) in doppia precisione (64 bit).

Il più grande double positivo rappresentabile è: 1.79769313486231570e+308, mentre il più piccolo positivo non-zero è: 4.94065645841246544e-324.

I numeri Java in virgola mobile sono stati definiti secondo lo standard IEEE 754.

Vedere anche: float.

else

Vedere: if.

extends

Dichiara che una classe (sottoclasse) eredita da un'altra classe (superclasse). Con extends, una sottoclasse eredita tutti gli attributi e i metodi della sua superclasse. La keyword extends, oltre ad essere utilizzata per l'ereditarietà di classe (subclassing), viene utilizzata anche per l'ereditarietà di interfaccia (subtyping); inoltre, mentre l'ereditarietà di classe è singola, quella di interfaccia è multipla.

Vedere anche: implements, class.

Esempio 1:

public class MyApplet extends java.applet.Applet {
  // ...
}

Esempio 2:

public class Classe2 extends Classe1 {
  // ...
}

Esempio 3:

public interface MyInterface extends Interface2, Interface1 {
  // ...
}

final

Il modificatore final è molto versatile, presenta le seguenti caratteristiche:

1. Quando è applicato ad una variabile indica che si tratta di una costante. 2. Quando è applicato ad un metodo indica che questo non può essere ridefinito (overriding) nelle sottoclassi. 3. Quando è applicato ad una classe indica che non è possibile creare delle sottoclassi.

In genere, l'utilizzo di final nella dichiarazione di metodi (o di classi) serve ad aumentare l'efficienza del programma in fase di esecuzione in quanto non vi è "late binding".

Esempio 1:

public final class ClasseFinal {
  // ...
}

Esempio 2:

public class MyClasse {
  final int Costante = 123;
  // ...
}

Esempio 3:

public class MyClasse {
  int i;
  public final void stopOverriding() {
    // ...
  }
}

finally

Viene utilizzata durante la gestione delle eccezioni, quindi assieme alla keyword try e consente di eseguire assolutamente una certa azione. Serve a ripristinare una situazione dopo il verificarsi di eccezioni o errori.

Può essere utilizzata, sempre abbinata a try, anche dopo istruzioni del tipo: return, break e continue.

Può essere utilizzata con o senza la clausola catch.

Vedere anche: try.

Esempio:

// ...
if (file.Apri()) {
  try {
    metodoEccezionale(); // può generare un'eccezione
  } finally {
    file.Chiudi();
  }
}

float

Tipo di dato primitivo che rappresenta numeri in virgola mobile (numeri reali) in singola precisione (32 bit).

Il più grande float positivo rappresentabile è: 3.40282347e+38f, mentre il più piccolo positivo non-zero è: 1.40239846e-45f.

I numeri Java in virgola mobile sono stati definiti secondo lo standard IEEE 754.

Vedere anche: double.

for

Il ciclo for, come nella maggior parte dei linguaggi, ripete un'istruzione o un blocco per un numero prefissato di volte.

Vedere anche: while e do...while.

Sintassi:

for (inizializzazione; condizione; incremento) {
  statements;
}

Ogni parte del ciclo for può essere vuota, ovvero consistere del solo punto e virgola (;), ed ogni parte del ciclo for può essere composta da più istruzioni separate da virgola (,).

Esempio:

// ...
for (int i = 0; i > 10, j < 20; i++) {
  // ...
  j--;
}

goto

Il linguaggio Java comprende goto come keyword ma non è attualmente utilizzata.

if

L'istruzione if permette di eseguire porzioni diverse di codice in base al risultato di una condizione (booleana).

Può essere utilizzato con o senza else (facoltativo). Può essere utilizzato "nidificato".

In Java, esiste anche l'operatore ternario (? :) che è un'espressione e quindi, diversamente dalla keyword if il cui effetto è l'esecuzione di uno statement, produce un risultato.

La forma dell'operatore ternario è: condizione ? seVero : seFalso.

Vedere anche: switch.

Esempio 1:

if (a < b) {
  System.out.println("a è minore di b!");
  // ...
}

Esempio 2:

boolean b = true;
if (b) {
  statements1;
} else {
  statements2;
}

Esempio 3:

boolean b = true;
if (b) {
  statements1;
} else if (...) {
  statements2;
} else if (...) {
  statements3;
} else {
  statementsN;
}

Esempio operatore ternario:

int m = x < y ? x : y;

implements

In Java, le interfacce (interface) forniscono modelli di comportamento che le classi devono implementare.

La keyword implements permette, ad una classe, di implementare un'interfaccia.

Implementare un'interfaccia vuol dire promettere di implementare tutti i metodi dichiarati nell'interfaccia altrimenti la classe sarà astratta.

Una classe può implementare anche più interfacce.

Vedere anche: interface, extends.

Esempio 1:

public class Frutta implements ComeFrutta {
  // ...
  // implementare i metodi dichiarati nell'interfaccia
}

Esempio 2:

public class Frutta extends Cibo implements ComeFrutta {
  // ...
  // implementare i metodi dichiarati nell'interfaccia
}

Esempio 3:

public class BestClass extends BestSuperClass implements BestInterface1, BestInterface2 {
  // ...
  // implementare i metodi dichiarati nelle interfacce
}

import

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 utilizzare le classi (o le interfacce) contenute nei package si usa la keyword import.

Si può importare una singola classe (o interfaccia) con la sintassi import nomePackage.NomeClasse o un intero package con la sintassi import nomePackage.*. I sottopackage devono essere esplicitamente importati.

Vedere anche: package.

Esempio:

import java.awt.*;
// Importa tutte le classi e le interfacce del package java.awt
import java.applet.Applet;
// Importa solo la classe Applet del package java.applet
public class MyApplet extends Applet {
  // ...
}

instanceof

È un operatore che consente di determinare a run-time il tipo di un oggetto. Restituisce true o false a seconda che l'oggetto sia o no un'istanza della classe di confronto o di una delle sue superclassi.

L'operatore si applica anche alle interfacce.

Se un oggetto implementa un'interfaccia allora instanceof con il nome di quell'interfaccia restituisce true.

Esempio 1:

if ("foo" instanceof String) ... // restituisce true

Esempio 2:

Point pt = new Point(3, 5);
if (pt instanceof String) ... // restituisce false

int

Tipo di dato primitivo che rappresenta valori compresi fra -2147483648 e 2147483647 inclusi.

Vedere anche: short, byte, long, char.