Definizione ed esempi dell'identificatore Java

UN Giava identificatore è 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 che scegli, rendili significativi e segui il convenzioni di denominazione Java standard.

Esempi di identificatori Java

Se hai variabili che contengono il nome, l'altezza e il peso di una persona, scegli gli identificatori che rendono 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

Dal momento che ci sono alcune sintassi rigide o regole grammaticali quando si tratta di identificatori Java (non preoccuparti, non sono difficili da capire), assicurati di essere consapevole di queste cose e non:

Parole riservate piace
```
classe
```
,
```
Continua
```
,
```
vuoto
```
,
```
altro
```
, e Se
non può essere usato.

instagram viewer

"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 includono, 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 è possibile utilizzare 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 (e identificatori) SQL non può essere scritto 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ù personaggi che provengono da 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)