Mots réservés

Certains mots seulement ne sont pas commentés. abstract
boolean
break
byte
byvalue
case
cast
catch
char
class
const
continue
default
do
double
else(if-else pour l'instruction conditionnelle)
enum
extends
false
final
finally
float
for
future
generic
goto
if (if-else pour l'instruction conditionnelle)
implements
import
inner
instanceof

int
interface
long
native
new
null
operator
outer
package
private
protected
public
rest
return
short
static
super
switch
synchronized
this
throw
throws
transient
true
try
var
void
volatile
while


abstract
Il s'agit d'un modificateur utilisé lors de la déclaration d'une classe ou d'une méthode. On dit alors que la classe ou la méthode est abstraite.
Une méthode abstraite n'a que son prototype, c'est-à-dire son type de retour suivi, de son nom, suivi de la liste de ses paramètres entre des parenthèses, suivi d'un point-virgule. Une méthode abstraite ne peut pas être déclarée static ou private ou final.
Dès qu'une classe contient une méthode abstraite, elle doit elle aussi être déclarée abstraite.
Une classe abstraite ne peut pas être instanciée. Il faudra l'étendre et définir toutes les méthodes abstraites qu'elle contient pour pouvoir l'utiliser.

boolean
Le type boolean est un type pour des variables qui ne peuvent prendre que deux valeurs : false et true (qui sont aussi deux mots réservés du langage).
les attributs booléens sont initialisés à false.
L'opérateur unaire ! s'applique à une variable ou à une valeur booléenne et change true en false et false en true.
Si on a :
    boolean fini = false;
alors !fini vaut true.

break On utilise l'instruction break; pour :
catch
Cette clause conduit à attraper une exception. On appelle "bloc catch" la clause catch et le bloc d'instructions qui la suit.
La syntaxe est du type :
try {
instructions effectuées;
instruction ou méthode pouvant
lancer une exception de la classe MyException;
instructions effectuées si l'exception n'a pas été lancée;
}
catch(MyException e) {
instructions effectuées si une instance de
MyException, a été lancée et donc attrapée;
}
Un "bloc catch" suit nécessairement un "bloc try".
Si un "bloc catch" attrape une exception qui a été lancée, le déroulement du programme se poursuit avec l'instruction qui suit le "bloc catch".

do
Le mot réservé do sert à définir une "boucle do-while". Une boucle do-while suit le schéma suivant :
do {
suite d'instructions
}while (condition);
Les parenthèses autour condition sont obligatoires.
Quand on arrive sur une boucle do-while, le programme "passe dans la boucle", ce qui signifie que la suite d'instructions est exécutée puis condition est testée ; si elle vaut vrai, (true) le programme passe à nouveau dans la boucle, puis condition est testée ; et ainsi de suite jusqu'à ce que la condition soit fausse (vale false).

enum
Utilisé pour l'en-tête d'une classe définissant un type énuméré.

extends
Ce mot réservé peut être utilisé suivi d'un nom de classe lors de la définition d'une nouvelle classe.
Exemple :
class MaNouvelleClasse extends ClasseGenerale {
...
}

MaNouvelleClasse est alors dite sous-classe de ClasseGenerale. On dit aussi que MaNouvelleClasse étend ClasseGenerale. MaNouvelleClasse hérite de toutes les méthodes de ClasseGenerale qui sont visibles (voir les
modificateurs de visibilité).
Une classe étend au plus une autre classe.

Une interface peut aussi étendre (grâce à extends) une autre ou plusieurs autres interfaces.
Exemple :
interface Dessinable extends Coloriable, Tracable
{
...
}

Dessinable hérite de toutes les constantes et méthodes abstraites contenues dans Coloriable et Tracable.


final
Il s'agit d'un modificateur qui s'applique à une classe, une donnée ou une méthode.

finally
La clause précède un bloc d'instructions. La clause et le bloc d'insructions constituent ce qu'on appelle un "bloc finally".
Un "bloc finally"est en général utilisé pour effectuer des nettoyages (fermer des fichiers, libérer des ressources...).
Un bloc finally suit:
Dans les deux cas, quelque soit la façon dont on est sorti du "bloc try" (par une instruction break, ou continue, ou return, par une propagation d'exceptions, ou bien normalement), les instructions contenues dans le "bloc finally" sont exécutées. Si un "bloc catch" situé entre le "bloc try" et le "bloc finally" attrape une exception, les intructions du "bloc catch" sont faites avant celles du "bloc finally".
for
Ce mot réservé sert à définir une "boucle for". Il y a deux type bien distincts de boucle for.

Premier type
Cette boucle suit le schéma suivant :

for (instruction1; condition; instruction2) {
suite d'instructions
}:
Les parenthèses autour "des trois champs" instruction1; condition; instruction2 sont obligatoires. Les trois champs, séparés par deux points-virgules, sont obligatoires aussi. S'il y a une seule instruction dans la suite des instructions, les accolades sont facultatives.
Losque le flux d'exécution du programme arrive sur la boucle for, il exécute instruction1, puis il teste condition ; si condition vaut vrai (true), il "passe dans la boucle", c'est-à-dire qu'il exécute la suite des instructions qui s'y trouvent. Après cela, il remonte à la boucle for, il effectue instruction2, puis il teste à nouveau condition et ainsi de suite jusqu'à ce que condition vale faux (false), alors le flux d'exécution continue avec ce qui suit la boucle.

Second type
Cette boucle s'utilise avec un tableau ou bien avec une collection (du type d'une classe qui implémente l'interface java.util.collection, ou une sous-interface de ce type : ArrayList, Vector...). Si T est un tableau d'int, on peut écrire :

for (int t : T) {
suite d'instructions
}
La suite d'instructions sera exécutée pour tous les int contenus dans T.

Si T est un tableau d'objets d'un type nommé Compte, on peut écrire :

for (Compte c : T) {
suite d'instructions
}
La suite d'instructions sera exécutée pour tous les "comptes" contenus dans T.

Si liste est un ArrayList ou un Vector..., contenant des objets d'un type nommé Compte (ArrayList<Compte> ou Vector<Compte>...), on peut écrire :

for (Compte c : liste) {
suite d'instructions
}
La suite d'instructions sera exécutée pour tous les "comptes" contenus dans liste. Dans les trois cas, il y a une seule instruction dans la suite des instructions, les accolades sont facultatives.
future
Ce mot n'est pas utilisé actuellement.

generic
Ce mot n'est pas utilisé actuellement.

goto
Ce mot n'est pas utilisé actuellement.

if-else

Les mots réservés if et else servent à définir une instruction conditionnelle


implements
Ce mot est employé dans l'en-tête de la déclaration d'une classe, suivi d'un nom d'interface ou de plusieurs noms d'interfaces séparés par des virgules. S'il y a une clause extends, la clause implements doit se trouver après la clause extends.
Exemple :
class MaClasse extends AutreClasse 
implements UneInterface, UneAutreInterface
Si une classe non abstraite possède une clause implements, elle doit définir toutes les méthodes de l'interface indiquée.
import
Ce mot permet dans un fichier source un raccourci sur un nom complet de classe d'un paquetage. Une instruction
    import ...;
est toujours placée en début de fichier, juste après l'indication de paquetage. Il peut y a voir une liste d'instruction import...; les unes en-dessous des autres.
On peut employer l'instruction import sous deux formes. Nous donnons un exemple pour chaque forme.

Premier exemple :

import coursJava/monPaquet/DansPaquetage;
permet d'utiliser la classe DansPaquetage sans rappeler le nom complet. Autrement dit, lorsque l'on aurait écrit sans l'instruction import :
coursJava.monPaquet.DansPaquetage UneInstance= 
new coursJava.monPaquet.DansPaquetage();
pourra être écrit après l'instruction import :
DansPaquetage UneInstance= new DansPaquetage();

Deuxième exemple :

import coursJava/monPaquet/*;
permet d'utiliser le nom de toute classe faisant partie du paquetage coursJava.monPaquet sans rappeler le nom complet.

La première méthode est préférable car plus explicite quand on lit un code Java.


inner
Ce mot n'est pas vraiment utilisé actuellement mais le sera sans doute bientôt dans le contexte de définition d'une classe à l'intérieur d'une autre.


interface
Ce mot débute la définition d'une interface. Une interface sert essentiellement à
Une interface peut contenir des attributs qui doivent être initialisés par des expressions constantes. Ces attributs sont automatiquement final et static, et sont donc des constantes.
Une interface peut contenir des prototypes de méthodes. Celles-ci sont automatiquement publiques.
Une interface ne contient pas de constructeur.
int
C'est un type pour une variable entière codée sur 4 octets.

instanceof
C'est un opérateur qui prend à sa gauche une référence ref d'objet et à sa droite un nom C de classe ou un nom I d'interface. Cet opérateur retourne true si l'objet référencé appartient à une classe ou une sous-classe de la classe C ou bien à une classe qui implémente l'interface I. Il retourne false dans le cas contraire, et aussi si ref vaut null.

native
Ce modificateur est appliqué à la déclaration d'une méthode. Il indique que la méthode est implémentée en C, ou d'une façon dépendante de la plate-forme. Une méthode native n'est que déclarée et non définie, ce qui signifie qu'elle n'a pas de corps (mais un poin-virgule à la fin de sa ligne déclarative.

new
Il s'agit d'un opérateur unaire qui crée un nouvel objet ou un nouveau tableau.

Pour créer un nouvel objet, le mot new doit être suivi d'une méthode qui soit un constructeur.
Par exemple, on pourra avoir :

MaClasse obj;
...
obj = new MaClasse(5, "bonjour");

si toutefois la classe MaClasse a un constructeur qui possède deux paramètres, un entier et une chaîne de caractères.

Pour créer un nouveau tableau, on peut par exemple écrire :

String[] arguments = new String[10];
ou bien :
int[][] uneMatrice = new int[4][5];
ou encore :
int[][] quatreLignes = new int[4][];
null
Ce mot désigne l'"adresse nulle". Si on a un attribut :
    Compte compte;
compte vaut null jusqu'à ce qu'on rencontre une instruction du type :
    compte = new Compte(...);.
Autrement dit, une variable d'un type objet ou tableau (i.e. référence d'objet ou tableau) vaut null si elle ne référence pas d'objet ou pas de tableau.


operator
Ce mot n'est pas utilisé actuellement.

package
Un fichier source peut commencer par le mot package suivi d'un nom de
paquetage.
outer
Ce mot n'est pas utilisé actuellement.

private
Ce mot réservé est un modificateur de visibilité qui s'applique à un champ (attribut ou méthode) d'une classe. On dit alors que le champ est privé. Un champ privé n'est visible que depuis sa propre classe. Elle n'est visible nulle part ailleurs et en particulier pas dans les sous-classes.

protected
Ce mot réservé est un modificateur de visibilité qui s'applique à un champ (attribut ou méthode) d'une classe. On dit alors que le champ est protégé. Un champ protégé d'une classe A est toujours visible à l'intérieur de son paquetage. A l'extérieur de son paquetage, un champ protégé est hérité par une sous-classe B mais non visible au travers d'une instance de A ou de B (sauf pour une instance de B invoquée dans B ou dans une sous-classe de B).

public
Cet mot réservé est un modificateur de visibilité qui s'applique à une classe, une interface ou à un champ (attribut ou méthode) d'une classe. On dit alors que la classe, l'interface ou le champ est publique.
Une classe ou une interface publique est visible de partout, y compris les autres paquetages. Si ce modificateur n'est pas appliqué à une classe ou une interface, celle-ci n'est visible que de l'intérieur de son paquetage.
Un champ publique est visible de partout du moment que sa classe est visible.

rest
Ce mot n'est pas utilisé actuellement.

return
L'instruction :
    return;
ne peut être utilisée que dans une méthode qui ne renvoie pas de valeur (ce qui est indiqué par le retour void). Elle fait alors immédiatement sortir de la méthode dans laquelle elle se trouve.
Dans une méthode qui doit renvoyer une valeur, on emploie obligatoirement une instruction :
    return xx;
xx est une valeur du type annoncé comme type de retour dans l'en-tête de la méthode. Cette instruction fait alors immédiatement sortir de la méthode dans laquelle elle se trouve et la valeur de retour est transmise au niveau de l'appel de la méthode. Si la méthode a pour en-tête :
    int meth();
et si on termine la méthode par :
    return n;
n est de type int, et si enfin on appelle la méthode par l'instruction :
    p = meth();
(p étant de type int), alors la valeur de la variable n au moment du return sera affectée à la variable p.

static
Ce modificateur s'applique aux attributs et aux méthodes ; lorsque ce modificateur est utilisé, on dit qu'il s'agit d'un attribut ou d'une méthode de classe.
On rappelle qu'une méthode ou un attribut auxquels n'est pas appliqué le modificateur static sont dits d'instance.

De l'extérieur d'une classe ou d'une classe héritée, un attribut ou une méthode de classe pourront être utilisés précédés du nom de leur classe :
nom_d'une_classe.nom_de_la_donnée_ou_méthode_de_classe
ou bien (mais cela est moins correct) du nom d'une instance de la classe.
Signalons enfin qu'une méthode static ne peut pas être redéfinie, ce qui signifie qu'elle est automatiquement
final.
super
Ce mot réservé permet d'invoquer un champ (attribut ou méthode) de la super-classe de l'objet sur lequel on est entrain de travailler (objet dit courant), et qui serait sinon caché par un champ de même nom de la classe de l'objet courant (soit que le champ en question soit une méthode qui a été redéfinie, soit que le champ soit un attribut qui a été masqué). Lorsque, dans une méthode, on invoque un champ de l'objet courant, on ne précise en général pas le nom de l'objet, ce que l'on peut néanmoins faire avec le mot this. Lorsqu'on emploie super, ce mot vient remplacer this qui figure implicitement. Employer super revient à remplacer la classe de l'objet courant par la super-classe.
Remarquons qu'il est interdit de "remonter de plusieurs étages" en écrivant super.super.etc.
On utilise aussi super(paramètres) en première ligne d'un constructeur. On invoque ainsi le constructeur de la super-classe ayant les paramètres correspondants.

synchronized
Cela peut être un modificateur pour une méthode ou bien une instruction.
  • Lorsqu'une méthode synchronized est invoquée, celle-ci ne pourra s'exécuter que lorsqu'elle aura obtenu un verrou sur l'instance à laquelle elle s'applique ; elle gardera alors le verrou jusqu'à ce qu'elle soit totalement exécutée.
  • L'instruction synchronized est utilisée de la façon suivante :
    synchronized(identificateur)
    {
    instruction1;
    instruction2;
    ...
    }
    L'identificateur identificateur situé dans les parenthèses doit être un objet ou un tableau.
    Le bloc suivant l'instruction synchronized s'appele section critique. Pour exécuter la section critique, le bloc doit obtenir un verrou sur l'objet ou le tableau représenté par identificateur.
  • this
    On peut utiliser this comme une référence ou bien this(...) pour faire appel à un autre constructeur de la même classe.
    Si this n'est pas suivi de parenthèses, il s'agit d'une référence à l'objet modélisé par la classe décrite. À l'exécution, this prend une valeur de type adresse, c'est l'adresse de l'objet concerné. Si une classe possède un attribut nommé n, this.n peut être utilisé dans une méthode de la classe : il s'agit de l'attribut n. Si la méthode ne possède pas de
    variable locale de même nom, la mention de this. est facultative ; si elle ne figure pas, elle est ajoutée par le compilateur.
    Dans un constructeur ou une méthode d'instance, l'objet représenté par this est l'objet avec lequel on est en train de travailler. On peut utiliser this pour passer l'objet sur lequel on est en train de travailler en paramètre à une méthode.
    Invoquer this(...) ne peut se faire qu'en première ligne d'un constructeur. On invoque alors un autre constructeur de la même classe dont la liste de paramètres corresponde aux paramètres indiqués entre les parenthèses.
    Exemple :
    class Cercle {
    int x,y, rayon;
    Cercle(int x, int y, int rayon) {
    this.x=x;
    this.y=y;
    this.rayon=rayon;
    }

    Cercle(int x, int y) {
    this(x,y,10);
    }
    }

    throw
    C'est ce mot réservé qui permet de "lancer" une exception lorsqu'un événement exceptionnel s'est produit. On écrira par exemple :
    if (il_y_a_un_probleme) throw new MyException)();
    où MyException serait ici une sous classe de java.lang.Exception définie par ailleurs.
    Remarquez bien que l'on lance une instance d'une exception (présence du mot new).
    Quand une exception est lancée, toutes les instructions suivantes sont ignorées et on remonte la pile des appels des méthodes : on dit que l'exception se propage. Pendant la propagation si une méthode de la pile d'appel a été invoquée à l'intérieur d'un "bloc try":

    throws
    Lorsqu'une méthode contient une instruction (éventuellement à travers l'appel à une autre méthode) susceptible de lancer une certaine exception sans l'attraper (par un mécanisme try-catch), elle doit l'annoncer dans son en-tête. Par exemple :
    void maMethode throws NumberFormatException, myException {
    ...
    instruction pouvant lancer une erreur de la classe
    NumberFormatException ou myException;
    ...
    }

    try
    Ce mot doit être suivi d'un bloc d'instructions. On parlera alors d'un "bloc try".
    En soit, il ne fair rien d'autre que de permettre l'utilisation de blocs "
    catch"ou (et) "finally" qui peuvent éventuellement suivre le "bloc try"
    transient
    Il s'agit d'un modificateur de visibilité applicable aux variablesattributs d'instance d'une classe. Il n'est actuellement pas utilisé mais il devrait désigner ultérieurement un attribut ne jouant pas de rôle dans la description de l'objet (on dira aussi qu'elle ne fait pas partie de l'état persistant de l'objet) et qu'il n'est donc pas nécessaire de sauver sur disque.

    var
    Ce mot n'est pas utilisé actuellement.

    volatile : ce mot est un modificateur applicable aux un attributs. Il signifie qu'il est possible qu'il y ait changement asynchrone de l'attribut . Le compilateur ne peut pas effectuer d'optimisation sur cet attribut .
    while
    Le mot réservé while sert à définir une "boucle while". Une boucle while suit le schéma suivant :
    while (condition) {
    suite d'instructions
    }
    Les parenthèses autour de la condition sont obligatoires. S'il y a une seule instruction dans la suite des instructions, les accolades sont facultatives.
    Quand on arrive sur une boucle while, la condition est testée ; si elle vaut vrai (true), le programme "passe dans la boucle", ce qui signifie que la suite des instructions est exécutée, puis le flux d'exécution remonte en haut de la boucle ; la condition est à nouveau testée ; si elle vaut vrai (true), le programme passe à nouveau dans la boucle et ainsi de suite jusqu'à ce que la condition soit fausse (vale false).

    ©Irène Charon, Télécom ParisTech 2011