Java Identifier Definition och exempel

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ölj efter standard Java-namnkonventioner.

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 kilo. D'oh!% N ", namn, höjd, vikt);

Detta att komma ihåg om Java-identifierare

Eftersom det finns några 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 tycka om
```
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 alfabetet bokstäver utan också symboler, som bara innehåller, utan undantag, understreck (_) och dollartecken ($).
instagram viewer
"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 innebär 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 bokstav.
Eftersom listan med SQL-nyckelord vid någon tidpunkt i framtiden kan inkludera andra SQL-ord (och identifierare) kan inte stavas på samma sätt som ett nyckelord), det rekommenderas vanligtvis inte att du använder ett SQL-nyckelord som ett 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 sammansättning av siffror, bokstäver, understreck och dollartecken och att det första tecknet aldrig får vara en siffra.

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)