Liste des mots-clés Java

Un extrait de code Java avec les mots-clés mis en évidence en bleu et en gras.

En Java , un mot-clé est l'un des 68 mots réservés ayant une signification prédéfinie. De ce fait, les programmeurs ne peuvent pas utiliser les mots-clés dans certains contextes, comme noms de variables , de méthodes , de classes ou comme identificateurs . Parmi ces 68 mots-clés, 17 sont réservés uniquement de manière contextuelle et peuvent parfois servir d'identificateurs, contrairement aux mots réservés classiques. Compte tenu de leur rôle spécifique, la plupart des environnements de développement intégrés (IDE) Java utilisent la coloration syntaxique pour afficher les mots-clés dans une couleur différente, facilitant ainsi leur identification.

abstract

Une méthode sans définition doit être déclarée abstraite, et la classe qui la contient doit également être déclarée abstraite. Les classes abstraites ne peuvent pas être instanciées. Les méthodes abstraites doivent être implémentées dans les sous-classes. Le mot-clé `abstract` ne peut pas être utilisé avec des variables ou des constructeurs. Notez qu'une classe abstraite n'est pas tenue de contenir une méthode abstraite.

assert(ajouté dans J2SE 1.4 ): Une assertion décrit un prédicat (une affirmation booléenne) placé dans un programme Java pour indiquer que le développeur considère ce prédicat comme toujours vrai à cet endroit. Si une assertion est évaluée à faux lors de l'exécution, une erreur d'assertion se produit, ce qui provoque généralement l'arrêt du programme. Les assertions sont désactivées par défaut lors de l'exécution, mais peuvent être activées via une option de ligne de commande ou par programmation via une méthode du chargeur de classes.
boolean: Définit une variable booléenne prenant uniquement les valeurs « true » ou « false ». Par défaut, la valeur du type primitif booléen est « false ». Ce mot-clé est également utilisé pour déclarer qu'une méthode renvoie une valeur de type primitif booléen boolean. Dans la plupart des autres langages, le type booléen est généralement appelé simplement « true » bool.

break: Utilisé pour mettre fin à l'exécution dans le corps de la boucle actuelle.; Utilisé pour se dégager d'un switchblocage.

byte: Le bytemot-clé est utilisé pour déclarer un champ pouvant contenir un entier signé de 8 bits en complément à deux . Ce mot-clé est également utilisé pour déclarer qu'une méthode renvoie une valeur de type primitif byte.

caseswitchbloc peut être étiquetée avec une ou plusieurs caseétiquettes default. L' switchinstruction évalue son expression, puis exécute toutes les instructions qui suivent l' caseétiquette correspondante ; voir switch[

catch: Utilisé conjointement avec un trybloc et un finallybloc optionnel. Les instructions du catchbloc spécifient le comportement à adopter si un type d'exception spécifique est levé par le trybloc.

char: Définit une variable de type caractère capable de contenir n'importe quel caractère du jeu de caractères du fichier source Java.

class: Un type qui définit l'implémentation d'un type d'objet particulier. La définition d'une classe spécifie les champs d'instance et de classe , les méthodes et les classes internes , ainsi que les interfaces implémentées et la superclasse immédiate . Si la superclasse n'est pas explicitement spécifiée, elle est implicite . Le mot-clé `class` peut également être utilisé pour obtenir un objet sans avoir besoin d'une instance de cette classe. Par exemple, `class` peut être utilisé à la place de `class.getObject()` .continue; Permet de reprendre l'exécution du programme à la fin de la boucle courante. Si elle est suivie d'une étiquette, continueelle reprend l'exécution à la fin de la boucle contenant cette étiquette.

defaultinstruction `switch` pour désigner un bloc d'instructions à exécuter si aucune casevaleur n'est spécifiée ; voir switch . Il peut également servir à déclarer des valeurs par défaut dans une annotation Java . À partir de Java 8, ce mot-clé permet à une interface de fournir une implémentation d'une méthode.defaultdefault

dowhilepour créer une boucle do-while , qui exécute un bloc d'instructions associé à la boucle, puis teste une expression booléenne associée à while. Si l'expression est évaluée à true, le bloc est exécuté à nouveau ; cela continue jusqu'à ce que l'expression soit évaluée à false.

double: Le doublemot-clé est utilisé pour déclarer une variable pouvant contenir un nombre à virgule flottante double précision IEEE 754 de 64 bits . Ce mot-clé est également utilisé pour déclarer qu'une méthode renvoie une valeur de type primitif . double

elseifpour créer une instruction if-else , qui teste une expression booléenne ; si l’expression est vraie true, le bloc d’instructions associé à ifest évalué ; si elle est fausse false, le bloc d’instructions associé à elseest évalué.

enum(ajouté dans J2SE 5.0 ): Un mot-clé Java utilisé pour déclarer un type énuméré . Les énumérations étendent la classe de base extends; Utilisé dans la déclaration d'une classe pour spécifier la superclasse ; utilisé dans la déclaration d'une interface pour spécifier une ou plusieurs superinterfaces. La classe X étend la classe Y pour ajouter des fonctionnalités, soit en ajoutant des champs ou des méthodes à la classe Y, soit en redéfinissant des méthodes de la classe Y. Une interface Z étend une ou plusieurs interfaces en ajoutant des méthodes. On dit que la classe X est une sous-classe de la classe Y ; on dit que l'interface Z est une sous-interface des interfaces qu'elle étend.; Utilisé également pour spécifier une limite supérieure à un paramètre de type dans les génériques.

final: Définissez une entité une fois pour toutes, de sorte qu'elle ne puisse être ni modifiée ni dérivée ultérieurement. Plus précisément : une classe finale ne peut être héritée, une méthode finale ne peut être redéfinie et une variable finale ne peut apparaître qu'une seule fois, en tant qu'expression à gauche d'une commande exécutée. Toutes les méthodes d'une classe finale sont implicitement finales final.

finally: Utilisé pour définir un bloc d'instructions pour un bloc précédemment défini par le trymot-clé. Ce finallybloc est exécuté après la sortie du trybloc et de toutes les clauses associées, catchqu'une exception ait été levée ou interceptée, ou que l'exécution ait quitté la méthode au milieu des tryblocs catchutilisant le returnmot-clé.

float: Le floatmot-clé `int` est utilisé pour déclarer une variable pouvant contenir un nombre à virgule flottante IEEE 754 simple précision de 32 bits. Ce mot-clé est également utilisé pour déclarer qu'une méthode renvoie une valeur de type primitif float.

for: Le formot-clé `for` permet de créer une boucle `for` , qui spécifie l'initialisation d'une variable, une expression booléenne et une incrémentation. L'initialisation de la variable est effectuée en premier, puis l'expression booléenne est évaluée. Si l'expression est vraie true, le bloc d'instructions associé à la boucle est exécuté, puis l'incrémentation est effectuée. L'expression booléenne est alors évaluée à nouveau ; ce processus se poursuit jusqu'à ce que l'expression soit vraie false.

À partir de J2SE 5.0 , le formot-clé peut également être utilisé pour créer une boucle dite « for améliorée », qui spécifie un tableau ou ifinstruction `if` , qui teste une expression booléenne ; si l’expression est vraie true, le bloc d’instructions associé à l’instruction `if` est exécuté. Ce mot-clé peut également être utilisé pour créer une instruction `if-else` ; voir else[

implements: Inclus dans une déclaration de classe pour spécifier une ou plusieurs interfaces implémentées par la classe courante. Une classe hérite des types et des méthodes abstraites déclarés par ces interfaces.

importfichier source pour spécifier des classes ou des packages Java entiers qui seront référencés ultérieurement sans inclure leurs noms de package dans la référence. Depuis J2SE 5.0, importles instructions peuvent importer staticles membres d'une classe. Un module Java peut lui-même être importé (en écrivant `import` import module), ce qui importe automatiquement tous les packages exportés.

instanceof: Un opérateur binaire qui prend une référence d'objet comme premier opérande et une classe ou une interface comme second opérande, et qui produit un résultat booléen. L' instanceofopérateur est évalué à vrai si et seulement si le type d'exécution de l'objet est compatible avec l'affectation de la classe ou de l'interface.

int: Le intmot-clé `int` est utilisé pour déclarer une variable pouvant contenir un entier signé 32 bits en complément à deux. Ce mot-clé est également utilisé pour déclarer qu'une méthode renvoie une valeur de type primitif int.

interface: Utilisée pour déclarer une interface ne contenant que des méthodes abstraites ou par défaut, des champs constants static finalet staticd'autres interfaces. Elle peut ensuite être implémentée par des classes déclarant l'interface avec le implementsmot-clé `interface`. L'héritage multiple étant interdit en Java, les interfaces permettent de contourner cette limitation. Une interface peut être définie à l'intérieur d'une autre.

long: Le longmot-clé `int` est utilisé pour déclarer une variable pouvant contenir un entier signé 64 bits en complément à deux. Ce mot-clé est également utilisé pour déclarer qu'une méthode renvoie une valeur de type primitif long.

native: Utilisé dans les déclarations de méthodes pour spécifier que la méthode n'est pas implémentée dans le même fichier source Java, mais plutôt dans un autre langage.

newScala ), bien qu'il remplisse deux fonctions : il permet l'existence d'espaces de noms différents pour les méthodes et les noms de classes, et il définit statiquement et localement qu'un nouvel objet est bien créé, ainsi que son type d'exécution (ce qui peut introduire une dépendance dans le code).

package: Un package Java est un groupe de classes et d'interfaces similaires. Les packages sont déclarés avec le packagemot-clé `package`.

private: Le privatemot-clé est utilisé dans la déclaration d'une méthode, d'un champ ou d'une classe interne ; les membres privés ne peuvent être accessibles que par d'autres membres de leur propre classe.

protected: Le protectedmot-clé est utilisé dans la déclaration d'une méthode, d'un champ ou d'une classe interne ; les membres protégés ne peuvent être accessibles qu'aux membres de leur propre classe, aux sous-classes de cette classe ou aux classes du même package .

public: Le publicmot-clé est utilisé dans la déclaration d'une classe, d'une méthode ou d'un champ ; les classes, méthodes et champs publics peuvent être accessibles par les membres de n'importe quelle classe.

return: Utilisée pour terminer l'exécution d'une méthode, elle peut être suivie d'une valeur requise par la définition de la méthode et renvoyée à l'appelant.

short: Le shortmot-clé est utilisé pour déclarer un champ pouvant contenir un entier signé en complément à deux sur 16 bits. Ce mot-clé est également utilisé pour déclarer qu'une méthode renvoie une valeur de type primitif short.

static: Utilisé pour déclarer un champ, une méthode ou une classe interne comme champ de classe. Les classes conservent une seule copie de leurs champs, quel que soit le nombre d'instances de cette classe. staticest également utilisé pour définir une méthode comme méthode de classe. Les méthodes de classe sont liées à la classe et non à une instance spécifique, et ne peuvent agir que sur les champs de classe. Les classes et interfaces déclarées comme staticmembres d'une autre classe ou interface sont, du point de vue comportemental, des classes de niveau supérieur.

super: L'héritage est principalement utilisé pour implémenter la liaison dynamique ou le polymorphisme d'exécution en Java. Il permet d'accéder aux membres d'une classe héritée par la classe parente. Une sous-classe peut ainsi accéder aux méthodes redéfinies et aux membres masqués de sa superclasse. Le supermot-clé `new` est également utilisé pour rediriger l'appel d'un constructeur vers un constructeur de la superclasse.; Utilisé également pour spécifier une limite inférieure pour un paramètre de type dans les génériques.

switchcaseet default`else` pour créer une instruction `switch` , qui évalue une variable, compare sa valeur à un critère spécifique case(y compris des motifs ) et exécute le bloc d'instructions associé case. Si aucun casecritère ne correspond, le bloc optionnel étiqueté `if` defaultest exécuté, s'il est inclus. Le mot-clé `switch` peut également être utilisé avec le mot-clé non réservé `if` yieldpour créer des expressions `switch`.

synchronizedmutex sur un objet pendant l'exécution du code par le thread courant. Pour les méthodes statiques, l'objet verrouillé est l'objet de la classe Class. Cela garantit qu'au plus un thread à la fois, opérant sur le même objet, exécute ce code. Le verrou mutex est automatiquement libéré lorsque l'exécution quitte le code synchronisé. Les champs, les classes et les interfaces ne peuvent pas être déclarés comme synchronisés .

this: Utilisé pour représenter une instance de la classe dans laquelle il apparaît. thisPermet d'accéder aux membres de la classe et sert de référence à l'instance courante. Le thismot-clé est également utilisé pour transférer un appel de constructeur d'une classe à un autre constructeur de la même classe.

throw: Lève l'instance d'exception déclarée. L'exécution se poursuit alors avec le premier gestionnaire d'exceptions englobant déclaré par le catchmot-clé `result` pour traiter un type d'exception compatible avec l'affectation. Si aucun gestionnaire d'exceptions n'est trouvé dans la méthode courante, celle-ci se termine et le processus se répète dans la méthode appelante. Si aucun gestionnaire d'exceptions n'est trouvé dans aucun appel de méthode sur la pile, l'exception est transmise au gestionnaire d'exceptions non interceptées du thread.

throws: Utilisé dans les déclarations de méthodes pour spécifier les exceptions qui ne sont pas gérées au sein de la méthode, mais transmises au niveau supérieur du programme. Toutes les exceptions vérifiées non interceptées dans une méthode (celles qui sont étendues, Exceptionmais pas celles qui ne le sont pas RuntimeException) doivent être déclarées à l'aide de ce throwsmot-clé.

transient: Indique qu'un champ d'instance ne fait pas partie de la forme sérialisée par défaut d'un objet. Lors de la sérialisation d'un objet, seules les valeurs de ses champs d'instance non transitoires sont incluses dans la représentation sérialisée par défaut. Lors de la désérialisation d'un objet, les champs transitoires sont initialisés uniquement à leur valeur par défaut. Si la forme par défaut n'est pas utilisée, par exemple lorsqu'une table serialPersistentFields est déclarée dans la hiérarchie de classes, tous transientles mots-clés sont ignorés.

try: Définit un bloc d'instructions incluant la gestion des exceptions. Si une exception est levée à l'intérieur du trybloc, un catchbloc optionnel peut gérer les types d'exceptions déclarés. De plus, un finallybloc optionnel peut être déclaré et sera exécuté à la sortie du trybloc et catchdes clauses, qu'une exception soit levée ou non. Un trybloc doit comporter au moins une catchclause ou un finallybloc.

void: Le voidmot-clé est utilisé pour déclarer qu'une méthode ne renvoie aucune valeur.

volatile: Utilisé dans les déclarations de champs pour garantir la visibilité des modifications apportées aux variables entre les threads. Toute lecture d'une variable volatile sera effectuée depuis la mémoire principale et non depuis le cache du processeur , et toute écriture d'une variable volatile sera effectuée en mémoire principale et non uniquement dans le cache du processeur. Les méthodes, les classes et les interfaces ne peuvent donc pas être déclarées volatiles , de même que les variables locales ou les paramètres.

whileboucle `while` , qui teste une expression booléenne et exécute le bloc d'instructions associé à la boucle si l'expression est vraietrue ; cela continue jusqu'à ce que l'expression soit fausse false. Ce mot-clé peut également être utilisé pour créer une boucle `do-while` ; voir do .

Inutilisé

Les mots suivants sont réservés comme mots-clés, mais n'ont actuellement aucune utilité ni finalité.

_: Introduit dans Java 9, le trait de soulignement est devenu un mot-clé et ne peut plus être utilisé comme nom de variable.

const: Bien que réservé comme mot-clé en Java, `const` constn'est pas utilisé et n'a aucune fonction. Dans d'autres langages, constil est généralement utilisé pour définir des constantes. Pour définir des constantes en Java, voir le finalmot-clé `const`.

goto: Bien que réservé comme mot-clé en Java, gotoil n'est pas utilisé et n'a aucune fonction. Dans d'autres langages, gotoil est généralement utilisé comme une instruction de contrôle unidirectionnelle pour sauter à une étiquette sur une autre ligne de code.

strictfp(ajouté dans J2SE 1.2 ): Bien que réservé comme mot-clé en Java, strictfpil est obsolète et n'a plus aucune fonction. Auparavant, ce mot-clé était utilisé pour limiter la précision et l'arrondi des calculs en virgule flottante afin d'assurer la portabilité.

Mots clés contextuels

Les identifiants suivants sont des mots clés contextuels et ne sont restreints que dans certains contextes :

exports: Utilisé dans une déclaration de module pour spécifier quels paquets sont disponibles pour les autres modules.

module: Déclare un module (un ensemble de packages et de ressources liés pouvant être traités comme une unité), utilisé pour encapsuler et exposer uniquement l'API publique d'une bibliothèque.

non-sealed: Utilisé pour déclarer qu'une classe ou une interface qui étend une classe scellée peut être étendue par des classes inconnues.

open: Indique que toutes les classes d'un package sont accessibles par réflexion par d'autres modules.

opens: Utilisé pour ouvrir un paquet spécifique afin d'accéder à d'autres modules par réflexion.

permits: La clause relative aux permis spécifie les classes autorisées à étendre une classe scellée.

provides: Utilisé pour déclarer qu'un module fournit une implémentation d'une interface de service.

record: Une classe spéciale qui sert de support transparent aux données immuables, fournissant automatiquement les méthodes .equals(), .hashCode(), et .toString().

requires: Utilisé dans une déclaration de module pour spécifier que le module dépend d'un autre module.

sealed: Une classe ou une interface scellée ne peut être étendue ou implémentée que par des classes et des interfaces autorisées à le faire.

to: Utilisé avec la opensdirective pour spécifier quel module est autorisé à accéder au package par réflexion.

transitive: Utilisé avec la requiresdirective pour indiquer qu'un module requiert non seulement un autre module, mais rend également les dépendances de ce module disponibles aux modules qui en dépendent.

uses: Utilisé dans un module pour déclarer que le module utilise un service (c'est-à-dire qu'il consommera un service fourni par d'autres modules).

var: Un identifiant spécial qui ne peut pas être utilisé comme nom de type (depuis Java 10). Utilisé pour déclarer une variable sans spécifier explicitement le type, en s'appuyant plutôt sur le compilateur pour inférer le type sur la base de l'initialiseur.

when: Utilisé comme vérification supplémentaire d'une casedéclaration.

with: Utilisé avec la providesdirective pour spécifier quelle implémentation d'un service est fournie par le module.

yield: Utilisé pour définir une valeur pour une expression switch, lors de l'utilisation de groupes d'instructions étiquetés (par exemple, case L:).

Mots réservés aux valeurs littérales

Les mots suivants font référence aux valeurs littérales utilisées par la langue.

true: Une valeur littérale booléenne.

false: Une valeur littérale booléenne.

null: Une valeur littérale de référence.