Definition och exempel på Java-identifierare

En Java-identifierare är ett namn som ges till ett paket, klass, gränssnitt, metod eller variabel. Det tillåter en programmerare att referera till objektet från andra platser i programmet.

För att få ut mesta möjliga av de identifierare du väljer, gör dem meningsfulla och följer de vanliga Java-namnkonventionerna.

Exempel på Java-identifierare

Om du har variabler som har en persons namn, höjd och vikt väljer du identifierare som gör deras syfte uppenbart:

 String name = "Homer Jay Simpson";

 int-vikt = 300;

 dubbel höjd = 6;

 System.out.printf ("Mitt namn är% s, min höjd är% .0f fot och min vikt är% d pund. D'oh!% N", namn, höjd, vikt);

Detta att komma ihåg om Java-identifierare

Eftersom det finns vissa strikta syntaxer eller grammatiska regler när det gäller Java-identifierare (oroa dig inte, de är inte svåra att förstå), se till att du är medveten om dessa do och inte:

Reserverade ord som
```
klass
```
,
```
Fortsätta
```
,
```
tomhet
```
,
```
annan
```
, och om
kan inte användas.
"Java-bokstäver" är termen som ges till de acceptabla bokstäverna som kan användas för en identifierare. Detta inkluderar inte bara vanliga alfabetbokstäver utan också symboler, som bara innehåller, utan undantag, understreck (_) och dollartecken ($).
"Java-siffror" inkluderar siffrorna 0-9.
En identifierare kan börja med en bokstav, dollartecken eller understruk, men inte en siffra. Det är dock viktigt att inse att siffrorna kan användas så länge de finns efter den första karaktären, som
```
e8xmple
```
Java-bokstäver och siffror kan vara allt från Unicode-teckenuppsättningen, vilket betyder att tecken på kinesiska, japanska och andra språk kan användas.
Utrymmen är inte acceptabla, så en understruk kan användas istället.
Längden spelar ingen roll, så du kan ha en riktigt lång identifierare om du väljer det.
Ett sammanställningstidsfel kommer att uppstå om identifieraren använder samma stavning som ett nyckelord, nolliteral eller boolesk bokstavlig.
Eftersom listan med SQL-nyckelord någon gång i framtiden kan inkludera andra SQL-ord (och identifierare kan inte stavas på samma sätt som ett nyckelord) rekommenderas det vanligtvis inte att du använder ett SQL-nyckelord som identifierare.
Det rekommenderas att använda identifierare som är relaterade till deras värden så att de är lättare att komma ihåg.
Variabler är skiftlägeskänsliga, vilket betyder myvalue
betyder inte detsamma som
```
MyValue
```

Notera: Om du har bråttom tar du bort det faktum att en identifierare är en eller flera tecken som kommer från poolen med siffror, bokstäver, understreck och dollartecken och att det första tecknet aldrig får vara ett nummer.

Enligt ovanstående regler skulle dessa identifierare betraktas som lagliga:

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

this_is_a_variable_name_that_is_long_but_still_valid_because_of_the_underscores

```
MAX_VALUE
```

Här är några exempel på identifierare som är inte giltiga eftersom de inte följer de regler som nämns ovan:

```
8example
```
(detta börjar med en siffra)
```
exa + pel
```
(plustecknet är inte tillåtet)
```
variabeltest
```
(mellanslag är inte giltiga)
```
this_long_variable_name_is_not_valid_because_of_this-bindestreck
```
(medan understreckna är acceptabla som i exemplet ovan, till och med den bindestreck i denna identifierare gör den ogiltig)

Vetenskap