Définition et exemples d'identificateurs Java

UNE Java identifiant est un nom donné à un package, une classe, une interface, une méthode ou une variable. Il permet à un programmeur de se référer à l'élément depuis d'autres endroits du programme.

Pour tirer le meilleur parti des identifiants que vous choisissez, donnez-leur un sens et suivez les conventions de dénomination Java standard.

Exemples d'identificateurs Java

Si vous avez des variables qui contiennent le nom, la taille et le poids d'une personne, choisissez des identifiants qui rendent leur objectif évident:

 String name = "Homer Jay Simpson";

 poids int = 300;

 double hauteur = 6;

 System.out.printf ("Mon nom est% s, ma taille est% .0f pied et mon poids est% d livres. D'oh!% N ", nom, taille, poids);

À retenir sur les identificateurs Java

Puisqu'il y a une syntaxe stricte ou des règles grammaticales en ce qui concerne les identificateurs Java (ne vous inquiétez pas, ils ne sont pas difficiles à comprendre), assurez-vous que vous en êtes conscient et que vous ne le faites pas:

instagram viewer

Mots réservés comme
```
classe
```
,
```
continuer
```
,
```
néant
```
,
```
autre
```
, et si
Ne peut pas être utilisé.
"Lettres Java" est le terme donné aux lettres acceptables qui peuvent être utilisées pour un identifiant. Cela inclut non seulement les lettres de l'alphabet, mais aussi les symboles, qui incluent uniquement, sans exception, le trait de soulignement (_) et le signe dollar ($).
Les "chiffres Java" incluent les chiffres 0-9.
Un identifiant peut commencer par une lettre, un signe dollar ou un trait de soulignement, mais pas un chiffre. Cependant, il est important de réaliser que les chiffres pouvez être utilisé tant qu'ils existent après le premier caractère, comme
```
e8xmple
```
Les lettres et chiffres Java peuvent appartenir au jeu de caractères Unicode, ce qui signifie que des caractères en chinois, japonais et autres langues peuvent être utilisés.
Les espaces ne sont pas acceptables, donc un trait de soulignement peut être utilisé à la place.
La longueur n'a pas d'importance, vous pouvez donc avoir un identifiant vraiment long si vous le souhaitez.
Une erreur au moment de la compilation se produit si l'identifiant utilise la même orthographe qu'un mot clé, le littéral nul ou le littéral booléen.
Étant donné que la liste des mots clés SQL peut, à un moment donné dans le futur, inclure d'autres mots SQL (et identificateurs ne peut pas être orthographié de la même manière qu'un mot clé), il n'est généralement pas recommandé d'utiliser un mot clé SQL comme identifiant.
Il est recommandé d'utiliser des identifiants liés à leurs valeurs afin qu'ils soient plus faciles à retenir.
Les variables sont sensibles à la casse, ce qui signifie mavaleur
ne signifie pas la même chose que
```
MyValue
```

Remarque: Si vous êtes pressé, supprimez simplement le fait qu'un identifiant est un ou plusieurs caractères provenant du pool de chiffres, lettres, le trait de soulignement et le signe dollar, et que le premier caractère ne doit jamais être un nombre.

Suivant les règles ci-dessus, ces identifiants seraient considérés comme légaux:

```
_Nom de variable
```
```
_3variable
```
```
$ testvariable
```
```
VariableTest
```
```
variabletest
```

this_is_a_variable_name_that_is_long_but_still_valid_because_of_the_underscores

```
Valeur max
```

Voici quelques exemples d'identifiants qui ne sont pas valides car ils désobéissent aux règles mentionnées ci-dessus:

```
8exemple
```
(cela commence par un chiffre)
```
exa + ple
```
(le signe plus n'est pas autorisé)
```
test variable
```
(les espaces ne sont pas valides)
```
this_long_variable_name_is_not_valid_because_of_this-hyphen
```
(alors que les traits de soulignement sont acceptables comme dans l'exemple ci-dessus, même le trait d'union dans cet identifiant le rend invalide)