Definizione ed esempi di identificatori Java

Un identificatore Java è un nome assegnato a un pacchetto, classe, interfaccia, metodo o variabile. Consente a un programmatore di fare riferimento all'elemento da altre posizioni nel programma.

Per ottenere il massimo dagli identificatori scelti, renderli significativi e seguire le convenzioni standard di denominazione Java.

Esempi di identificatori Java

Se hai variabili che contengono il nome, l'altezza e il peso di una persona, quindi scegli identificatori che rendano ovvio il loro scopo:

 Nome stringa = "Homer Jay Simpson";

 int peso = 300;

 doppia altezza = 6;

 System.out.printf ("Il mio nome è% s, la mia altezza è% .0f piede e il mio peso è% d libbre. D'oh!% N", nome, altezza, peso);

Questo da ricordare sugli identificatori Java

Poiché ci sono alcune sintassi rigide o regole grammaticali quando si tratta di identificatori Java (non preoccuparti, non sono difficili da capire), assicurati di essere a conoscenza di queste cose e non:

Parole riservate come
```
classe
```
,
```
Continua
```
,
```
vuoto
```
,
```
altro
```
, e Se
non può essere usato.
"Lettere Java" è il termine dato alle lettere accettabili che possono essere utilizzate per un identificatore. Ciò include non solo le normali lettere dell'alfabeto, ma anche i simboli, che include, senza eccezioni, il trattino basso (_) e il simbolo del dollaro ($).
Le "cifre Java" includono i numeri da 0 a 9.
Un identificatore può iniziare con una lettera, un simbolo di dollaro o un trattino basso, ma non una cifra. Tuttavia, è importante rendersi conto che le cifre può essere usato fintanto che esistono dopo il primo personaggio, come
```
e8xmple
```
Le lettere e le cifre Java possono essere qualsiasi cosa dal set di caratteri Unicode, il che significa che possono essere utilizzati caratteri in cinese, giapponese e altre lingue.
Gli spazi non sono accettabili, quindi è possibile utilizzare un carattere di sottolineatura.
La lunghezza non ha importanza, quindi puoi scegliere un identificatore molto lungo se lo desideri.
Si verificherà un errore in fase di compilazione se l'identificatore utilizza la stessa ortografia di una parola chiave, il valore letterale null o il valore letterale booleano.
Poiché l'elenco delle parole chiave SQL potrebbe, ad un certo punto in futuro, includere altre parole SQL (e gli identificatori non possono essere scritti come una parola chiave), di solito non è consigliabile utilizzare una parola chiave SQL come identificatore.
Si consiglia di utilizzare identificatori correlati ai loro valori in modo che siano più facili da ricordare.
Le variabili fanno distinzione tra maiuscole e minuscole, il che significa MyValue
non significa lo stesso di
```
MyValue
```

Nota: Se hai fretta, togli il fatto che un identificatore è uno o più caratteri che provengono dal pool di numeri, lettere, trattino basso e segno del dollaro e che il primo carattere non deve mai essere un numero.

Seguendo le regole di cui sopra, questi identificatori sarebbero considerati legali:

```
_variablename
```
```
_3variable
```
```
$ testvariable
```
```
VariableTest
```
```
variabletest
```

this_is_a_variable_name_that_is_long_but_still_valid_because_of_the_underscores

```
MAX_VALUE
```

Ecco alcuni esempi di identificatori che non sono validi perché disobbediscono alle regole sopra menzionate:

```
8example
```
(questo inizia con una cifra)
```
exa + ple
```
(il segno più non è permesso)
```
test variabile
```
(gli spazi non sono validi)
```
this_long_variable_name_is_not_valid_because_of_this-trattino
```
(mentre i caratteri di sottolineatura sono accettabili come nell'esempio dall'alto, anche il trattino in questo identificatore lo rende non valido)

Scienza