L'Abécédaire de Java

Les mots-clés de Java sont des mots réservés par le langage en vue d'une utilisation spéciale. On ne peut donc pas les utiliser en-dehors de l'usage prévu par Java, notamment comme identifiant de variable, nom de classe, de package ou de méthode.

• abstract : modificateur de classe ou de méthode, afin de la rendre abstraite.
  abstract class MaClasse {
    abstract void maMethode();
}
• assert (depuis Java 1.4) : instruction qui exprime les conditions avant de continuer l'exécution d'une méthode ; permet de programmer par contrat. Si la condition n'est pas vérifiée, une exception AssertionError est levée.
  double diviser(double dividende, double diviseur) {
    assert diviseur != 0 : "Division par zéro interdite";
}

• boolean : type primitif, pouvant prendre une valeur booléenne : true (vrai) ou false (faux).
• break : instruction qui provoque l'interruption d'un flux d'instructions et la sortie immédiate d'un bloc d'instructions : un bloc de contrôle (switch), un bloc itératif (do, for, while) ou un bloc try.
• byte : type primitif, représentant un entier signé sur 8 bits, soit un octet.
• case : instruction qui introduit un cas ou étiquette dans un bloc de contrôle switch (Cf. swith).
• catch : instruction qui crée une clause dans laquelle attraper et traiter une exception précédemment levée dans un bloc try (Cf. try).
• char : type primitif représentant un caractère.
• class : instruction pour définir une classe.
  class MaClasse {
    ...
}
• const : actuellement inutilisé par Java.
• continue : instruction qui provoque directement le passage à la prochaine itération d'un bloc itératif.
• default : dans un bloc de contrôle switch, cette étiquette introduit l'instruction par défaut à effectuer, quand les conditions d'aucun des cas prévus n'ont été vérifiées.
• do : instruction qui commence un bloc itératif do... while, autrement dit "Faire ... tant que la condition est vraie", où la condition d'itération est vérifiée à la fin du bloc. Une première itération est donc toujours accomplie.
  do {
    ...
} while(condition);
  
• double : type primitif, représentant un nombre réel signé sur 64 bits, soit 8 octets.
• else : instruction qui propose une clause alternative dans une suite de blocs conditionnels (Cf. if).
  if (condition) {
    ...
} else {
    ...
}
• enum (depuis Java 1.5) : instruction pour définir une énumération, c'est-à-dire un type qui comporte un nombre fini d'éléments.
  enum Jour {
    LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI, DIMANCHE
}
• extends : instruction qui définit un héritage entre une classe mère et une classe fille.
  classe MaClasseFille extends MaClasseMere { ... }
• false : valeur booléenne pour une négation, signifiant faux.
• final : modificateur de classe, de méthode ou de variable. Une classe final ne peut pas être étendue ; une méthode final ne peut pas être redéfinie par héritage ; une variable final est une constante et sera donc affectée d'une valeur une seule fois.
• finally : instruction qui introduit la dernière clause faisant suite à un bloc try, sachant que les instructions de cette clause seront toujours exécutées, quelle que soit l'issue du bloc try (Cf. try).
• float : type primitif, représentant un nombre réel signé sur 32 bits, soit 4 octets.
• for : instruction qui introduit un bloc itératif "Pour". Sa déclaration se fait en 3 étapes séparées par des points-virgules :
  for (condition_initiale; condition_echappement; instruction_iteration) {
    ...
}
  Par exemple :
  for (int compteur = 0; compteur < 10; compteur++) {     System.out.println(compteur);
}
• goto : actuellement inutilisé par Java.
• if : instruction qui introduit un bloc conditionnel "Si". Les instructions du bloc sont exécutées si la condition qui suit if est vérifiée :
  if (condition) {
    ...
}

if (condition1) {
    ...
} else if (condition2) {
    ...
} else {
    ...
}
• implements : instruction qui, à la déclaration d'une classe, stipule qu'elle implémente une interface donnée.
  class MaClasse implements MonInterface { ... }
• import : instruction qui définit un import de classe, qui permet de manipuler ensuite une classe sans fournir à chaque fois son nom de package.
  import unpackage.UneClasse;
  Les import permettent d'alléger l'écriture du code et de fixer les différentes dépendances d'une classe.
  Depuis Java 1.5, il existe aussi les import static, qui permettent d'importer les attributs et méthodes static d'une classe.
  import static unpackage.UneClasse.CONSTANTE;
import static unpackage.UneClasse.uneMethode;
• instanceof : instruction qui compare le type d'un objet à un type donné ; retourne true si les types sont identiques, false sinon.
  if (monObjet instanceof UneClasse)
• int : type primitif, représentant un nombre entier signé sur 32 bits, soit 4 octets.
• interface : instruction pour définir une interface.
• long : type primitif, représentant un nombre entier signé sur 64 bits, soit 8 octets.
• native : modificateur de méthode, qui indique que son implémentation n'est pas codée en Java, mais dans un langage dépendent d'une plateforme. Son code est fourni dans un autre fichier. Une méthode native ne possède pas de corps et sa signature se termine donc par un point-virgule :
  native void maMethodeNative();
• new : opérateur pour instancier un objet à partir d'une classe donnée, immédiatement suivi d'un constructeur de cette classe.
  MaClasse monObjet = new MaClasse();
• null : valeur spéciale pour des références qui ne pointent sur aucun objet.
  Exemple d'un objet initialisé à null :
  Object monObjet = null;
• package : instruction pour définir le package d'appartenance d'une classe.
  package nomdupackagedemaclasse;

class MaClasse { ... }
• private : modificateur d'accès de classe, de méthode ou d'attribut, utilisé à sa déclaration, pour interdire tout accès direct depuis l'extérieur de la classe qui l'encapsule.
• protected : modificateur d'accès de classe, de méthode ou d'attribut, utilisé à sa déclaration, pour ne le rendre accessible que par les classes en héritant ou par les classes du même package.
• public : modificateur d'accès de classe, de méthode ou d'attribut, utilisé à sa déclaration, pour le rendre directement accessible par toute autre classe.
• return : instruction pour retourner une valeur de retour dans le cas d'une méthode avec retour, ou bien pour provoquer une sortie immédiate d'une méthode sans retour.
  Exemple d'une méthode sans retour :
  void maMethode() {
    ...
    return;
}
  
  Exemple d'une méthode avec retour :
  MaClasse maMethode() {
    MaClasse monObjet = null;
    ...
    return monObjet;
}
• short : type primitif, représentant un nombre entier signé sur 16 bits, soit 2 octets.
• static : modificateur d'attribut, de méthode ou de bloc.
  Un attribut (respectivement une méthode) static est un attribut (respectivement une méthode) de classe, et non d'instance, c'est-à-dire partagé par toutes les instances de la classe :
  class MaClasse {
    static int nombreEntier = 0;
    static void maMethode() { ... }
}

System.out.println(MaClasse.nombreEntier);
MaClasse.maMethode();
  
  Pour un bloc static :
  class MaClasse {
    static {
        ...
    }
}
• strictfp (depuis Java 1.2) : modificateur de classe, d'interface ou de méthode, qui force la JVM à adhérer au standard IEEE 754 pour toute opération sur des nombres réels, indépendamment de la plateforme sur laquelle tourne la JVM.
• super : référence vers la classe de base depuis la classe dérivée.
• switch : instruction qui introduit un bloc de contrôle sur la valeur d'une variable.
  L'instruction exécutée dépendra du cas correspondant à cette valeur :
  switch(number) {
    case 1:
        ...
        break;
    case 2:
        ...
        break;
    case 3:
        ...
        break;
    default:
        ...
}
• synchronized : instruction utilisée en programmation multi-tâche, pour désigner une section critique, de manière à ce qu'un thread accède de façon exclusive à cette méthode ou à ce bloc.
  Quand une méthode est la section critique, les 2 syntaxes suivantes sont possibles :
  void synchronized methode() { ... }
  et :
  void methode() {
    synchronized(this) { ... }
}
  Quand une méthode static est la section critique, c'est la dernière syntaxe qui est reprise :
  class MaClasse {
    static void methode() {
        synchronized(MaClasse.class) { ... }
     }
}
  Quand une section critique porte sur un objet :
  synchronized(monObjet) { ... }
• this : référence vers l'instance courante d'une classe
• throw : instruction pour lever une nouvelle exception. Une telle exception doit être une instance d'une classe dérivant de Throwable et devra être traitée par la méthode appelante.
  throw new Exception("Description de l'exception levée");
• throws : instruction pour définir les différentes exceptions susceptibles d'être levées ou transmises par une méthode.
  void maMethode throws IOException { ... }
• transient : modificateur d'attribut, indiquant qu'un tel attribut ne sera pas transmis par sérialisation.
• true : valeur booléenne pour une affirmation, signifiant vrai.
• try : instruction pour définir un bloc capable de traiter d'éventuelles exceptions.
  try {
    ...
} catch (MonException1 exception1) { ... }
} catch (MonException2 exception2) { ... }
} finally { ... } // facultatif
• void : utilisé à la place du type de retour pour les méthodes sans retour, signifiant "rien".
  void uneMethodeSansRetour { ... }
• volatile : modificateur d'attribut, utilisé pour des attributs modifiables de façon asynchrone, c'est-à-dire que plusieurs threads peuvent y accéder en même temps. A chaque accès de l'attribut par un thread, la JVM doit rafraîchir la copie mise en cache par ce thread, de manière à ce qu'il dispose de la valeur correcte.
• while : instruction pour définir un bloc itératif "Tant que la condition est vraie, faire ...".
  while(condition) {
    ...
}

Types primitifs numériques

Type	Bits	Octets	Valeur minimale	Valeur maximale
byte	8	1	-2^7	2^7-1
short	16	2	-2^15	2^15-1
int	32	4	-2^31	2^31-1
long	64	8	-2^63	2^63-1
float	32	4	n/a	n/a
double	64	8	n/a	n/a