Katkelma Java-koodia, jossa avainsanat on korostettu sinisellä ja lihavoidulla fontilla
Java on oliopohjainen ohjelmointikieli, josta löytyy 67 erilaista avainsanaa. Avainsanat ovat varattuja sanoja, joilta löytyy ennalta määritelty tarkoitus. Tämän takia ohjelmoija ei pysty käyttämään avainsanoja kuten sanaa "public" muuttujan, metodin tai luokan nimenä. Näistä 67 avainsanasta 16 on kontekstista riippuen varattuja ja näitä voidaan joissain tapauksissa käyttää muuttujan, metodin tai luokan nimenä, toisin kuin normaaleja varattuja sanoja. Suurin osa ohjelmointiympäristöistä (eng. IDE, integrated development environment) korostaakin näitä avainsanoja koodin värityksellä, jotta näiden erityistarkoitus Javassa on helpommin tunnistettavissa.

Luettelo Java-avainsanoista
---------------------------

**Datatyypit:**

`boolean`
Määrittää loogisen muuttujan, jolla voi olla vain arvot "true" (tosi) tai "false" (epätosi). Oletusarvoisesti loogisen primitiivityypin arvo on epätosi. Tätä avainsanaa käytetään myös ilmoittamaan, että menetelmä palauttaa primitiivityypin `boolean` arvon.
`char`
Määrittää merkkimuuttujan, joka voi sisältää minkä tahansa merkin Java-lähdetiedoston merkistöstä.
`long`
Määrittelee kokonaislukumuuttujan, joka voi sisältää 64-bittisen etumerkillisen kahden komplementin kokonaisluvun.  [6] Tätä avainsanaa käytetään myös ilmoittamaan, että metodi palauttaa `long` tyyppisen arvon.  [8]
`short`
Määrittelee kokonaislukumuuttujan, joka voi sisältää 16-bittisen etumerkillisen kahden komplementin kokonaisluvun.  [6] Tätä avainsanaa käytetään myös ilmoittamaan, että metodi palauttaa `short` tyyppisen arvon.  [8]
`int`
Int määrittely saa 32-bittisen etumerkillisen kahden komplementin kokonaisluvun. Sillä on pienin arvo ({\displaystyle -2^{31}}) ja suurin arvo ({\displaystyle 2^{31}-1}). Int tyypiseen muuttujaan voi siis tallentaa kokonaislukuja sen suurimman ja pienimmän arvon väliltä.
`byte`
Byte tarkoittaa 8-bittistä etumerkillistä kahden komplementin kokonaislukua. Sillä on pienin arvo (-128) ja suurin arvo (127). Byte voi siis sisältää kokonaislukuja väliltä -128 ja 127.
`float`
Javassa float datatyyppi on yhden tarkkuuden 32-bittinen liukuluku. Float tyyppinen muuttuja voi siis sisältää desimaaliluvun, kuten vaikka 0.0001.

`double`
Javassa double datatyyppi on kahden tarkkuuden 64-bittinen liukuluku. Double tyyppinen muuttuja on samanlainen kuin float, mutta vielä tarkempi. Double datatyyppi voi siis varastoida vielä pienempiä arvoja.
`String`
String tyyppi ei ole primitiivinen datatyyppi, mutta javassa on luokka "String", jolla on paljon eri metodeja merkkijonojen käyttämiseen ja manipuloimiseen. Javassa voit siis luoda string tyyppisen muuttujan. Toisin kuin string, primitiivisiä datatyyppejä ovat esimerkiksi int, float, double, char ja boolean.

  

**Näkyvyys:**

`private`
`private` avainsanaa käytetään menetelmän, kentän tai sisäisen luokan määrittelyssä; yksityisiin jäseniin pääsevät vain muut oman luokkansa jäsenet. Private -tyyppistä metodia ei siis voida kutsua koodin muista luokista. 
`public`
`public` avainsanaa käytetään luokan, menetelmän tai kentän "näkyvyyden" määrittelyssä; minkä tahansa luokan jäsenet voivat käyttää julkisia luokkia, menetelmiä ja kenttiä. 
`protected`
`Protected` määritetyt ominaisuudet ovat käytettävissä sen luokan lapsiluokilla. `Protected` toimii siis kuin private määritelmä, mutta lapsiluokilla on pääsy näin määriteltyihin ominaisuukksiin.
`package`
`Package` määrittely tarkoittaa sitä, että vain sen kyseisen paketin sisällä voidaan käyttää `package` määriteltyjä asioita. `Package` määrittely toimii siis samalla tavalla kuin public määrittely, mutta paketin ulkopuoliset kutsut eivät toimi. Javassa tämä on oletusarvoinen näkyvyysmäärite.
`void`
`void` avainsanaa käytetään ilmoittamaan, että menetelmä ei palauta arvoa. 

  

**Silmukat ja lausekkeet:**

`for`
`For` -avainsanaa käytetään for-silmukan luomiseen. Lausekkeessa määritellään muuttujan alustus, looginen lauseke ja inkrementaatio. Muuttujan alustus suoritetaan ensin, jonka jälkeen looginen lauseke arvioidaan. Jos lausekkeen arvo on "true", silmukan sisällä olevat lausekkeet suoritetaan ja lopuksi suoritetaan inkrementaatio. Tämän jälkeen looginen lauseke arvioidaan uudelleen. Tätä jatketaan, kunnes looginen lauseke saa arvon "false", jolloin silmukka päättyy. Tyypillisesti for-silmukkaa käytetään, kun kierrosten lukumäärä on tiedossa.

J2SE 5.0:sta alkaen for-avainsanaa voidaan käyttää myös niin kutsutun "`for-each`-silmukan" luomiseen, joka määrittelee taulukon tai iteroitavan objektin, jonka jokainen alkio voidaan käydä läpi yksi kerrallaan. Näin jokainen silmukan iteraatio suorittaa silmukkaan liittyvän koodilohkon käyttäen eri elementtiä taulukossa tai objektissa.
`do`
`do` -avainsanaa käytetään yhdessä `while`-avainsanan kanssa luomaan `do-while`-silmukka, joka suorittaa ensin silmukan sisällä olevan koodilohkon ja arvioi sitten while-avainsanan yhteydessä olevaa loogista lauseketta. Mikäli lausekkeen arvo on "true", koodilohko suoritetaan uudelleen. Tätä jatketaan, kunnes looginen lauseke saa arvon "false", jolloin silmukka päättyy.
`while`
`while` -avainsanaa käytetään while-silmukan luomiseen, joka arvioi ensin loogista lauseketta ja suorittaa sen jälkeen silmukkaan liittyvän koodilohkon, jos lauseke saa arvon "true". Tätä jatketaan, kunnes lauseke saa arvon "false". While-avainsanaa voidaan myös käyttää `do-while`-silmukan luomiseen.
`break`
`break` -avainsanaa käytetään silmukassa nykyisen suorituksen lopettamiseen ja silmukasta poistumiseen. Yleensä jonkin ehtolausekkeen yhteydessä mikäli silmukasta halutaan poistua aikaisemmin tai lopetusehdon yhteydessä esimerkiksi while(true) -ikisilmukassa. Break-avainsanaa käytetään myös `switch-case`-rakenteessa poistumaan switch-lohkosta.
`continue`
`continue` -avainsanaa käytetään ohjelman suorituksen jatkamiseen nykyisen silmukan lopusta tai siirtymään silmukassa seuraavaan kierrokseen kesken suorituksen.
`if`
`if` -avainsanaa käytetään `if` -lauseen luomiseen, joka testaa loogisen lausekkeen; jos lausekkeen arvo on "true", `if` -lauseeseen liittyvä lausekelohko suoritetaan. Tätä avainsanaa voidaan käyttää myös `if-else` -lausekkeen luomiseen.
`else`
`ilse` -avainsanaa käytetään `if` -avainsanan kanssa `if-else` -lausekkeen luomiseen, joka testaa loogisen lausekkeen; jos lausekkeen arvo on "true", `if` -lauseeseen liittyvä lausekelohko arvioidaan; jos sen arvo on "false", `else` -lauseeseen liittyvä lausekelohko suoritetaan.
`switch`
`iwitch` -avainsanaa käytetään yhdessä `case` ja `default` avainsanojen kanssa `switch` käskyn luomiseen, joka arvioi muuttujan, vertaa sen arvon tiettyyn `case`:en ja suorittaa kyseiseen `case`:en liittyvän lauseiden lohkon. Jos mikään `case` ei vastaa arvoa, `default` -avainsanalla merkitty valinnainen lohko suoritetaan, jos se on sisälletty.
`case`
`iwitch` -lohkon lauseke voidaan nimetä yhdellä tai useammalla `case` tai `default` -avainsanalla. `Switch` -lauseke arvioi lausekkeensa ja suorittaa sen jälkeen kaikki lauseet, jotka liittyvät vastaavaan `case` -nimikkeeseen.
`default`
`default` -avainsanaa voidaan valinnaisesti käyttää `switch` -lausekkeessa nimetäkseen lauseiden lohkon, joka suoritetaan, jos mikään `case` ei vastaa määritettyä arvoa. Toisaalta `default` -avainsanaa voidaan myös käyttää Java-annotaatiossa oletusarvojen määrittämiseen. Java 8:sta lähtien `default` -avainsanalla voidaan sallia rajapinnan metodin toteutuksen määrittäminen.
`this`
`this` -avainsanaa käytetään edustamaan sen luokan instanssia, jossa se esiintyy. `this` -avainsanaa voidaan käyttää luokan jäsenten käyttämiseen ja nykyisen instanssin viittaamiseen. `this` -avainsanaa käytetään myös välittämään kutsu yhdestä rakentajasta toiseen rakentajaan samassa luokassa.

  

**Poikkeukset:**

`try`
`try` -avainsanaa käytetään määrittämään lausekelohko, jossa on poikkeuskäsittely. Jos `try` -lohkon sisällä heitetään poikkeus, valinnainen `catch` -lohko voi käsitellä ilmoitettuja poikkeustyyppejä. Lisäksi voidaan ilmoittaa valinnainen `finally` -lohko, joka suoritetaan, kun suoritus poistuu `try` -lohkosta ja `catch` -lausekkeista riippumatta siitä, heitetäänkö poikkeus vai ei. `try` -lohkossa on oltava vähintään yksi `catch` -lauseke tai `finally` -lohko.
`catch`
`catch` -avainsanaa käytetään yhdessä `try` -lohkon ja valinnaisen `finally` -lohkon kanssa. `catch` -lohkon lausekkeet määrittävät, mitä tehdään, jos `try` -lohko heittää tietyn tyyppisen poikkeuksen.
`finally`
`finally` -avainsanaa käytetäänän määrittämään lausekelohko lohkolle, joka on määritelty aiemmin `try` -avainsanalla. `finally` -lohko suoritetaan sen jälkeen, kun suoritus on poistunut `try` -lohkosta ja siihen liittyvistä `catch` -lausekkeista riippumatta siitä, onko poikkeus heitetty tai otettu kiinni tai onko suoritus jättänyt metodin kesken `try` - tai `catch` -lohkon `return` -avainsanalla.
`throw`
`throw` -avainsana aiheuttaa ilmoitetun poikkeustapauksen heittämisen. Tämä aiheuttaa sen, että suoritus jatkuu ensimmäisellä ympäröivällä poikkeuksen käsittelijällä, joka on ilmoitettu `catch` -avainsanalla käsittelemään tehtävän kanssa yhteensopivaa poikkeustyyppiä. Jos nykyisestä metodista ei löydy tällaista poikkeuksen käsittelijää, metodi palaa ja prosessi toistetaan kutsuvassa metodissa. Jos poikkeuksen käsittelijää ei löydy mistään pinossa olevasta metodikutsusta, poikkeus siirretään säikeen sieppaamattomalle poikkeuksen käsittelijälle.
`throws`
`throws` -avainsanaa käytetään metodi-ilmoituksissa määrittämään, mitä poikkeuksia ei käsitellä metodissa vaan ne siirretään ohjelman seuraavalle korkeammalle tasolle. Kaikki metodissa olevat vangitsemattomat poikkeukset, jotka eivät ole `RuntimeException` -olioita, on ilmoitettava `throws`-avainsanalla.

  

**Kontekstista riippuen varattuja avainsanoja:**

###### `abstract`

`module`

`non-sealed`

`open`

`opens`

`permits`

`provides`

`record`

`requires`

`sealed`

`to`

`transitive`

`uses`

`var`

`with`

`yield`

  

**Muita varattuja avainsanoja:**

`_`
Alaviiva lisättiin varattujen avainsanojen joukkoon Java 9:n myötä, eikä sitä voi enää käyttää muuttujan nimenä enää.
`abstract`

`assert`

`class`

`const`

`enum`
enum-avainsanalla määritellään lueteltu tyyppi -muuttuja (engl. *Enumerated type*), joka on Javassa pohjimmiltaan luokka.
`extends`
Käytetään luokan määrittelyssä osoittamaan luokan superluokka.
`false`
Totuusarvomuuttujan (boolean) "epätosi"-arvo.
`final`

`goto`

`implements`

`import`

`instanceof`

`interface`

`native`

`new`
`new` -avainsanaa käytetään uuden luokka- tai listaobjektin luomisessa.
`null`

`return`
Käytetään metodin lopussa. `return` -avainsanan jälkeen määritellään myös metodin palauttama arvo, mikäli sillä on sellainen tehtävä.
`static`

`super`

`synchronized`

`transient`

`true`
Totuusarvomuuttujan (boolean) "tosi"-arvo.
`volatile`

  

**Käyttämättömät, mutta varatut avainsanat:**

`const`
Vaikka `const` on varattu avainsana Javassa, niin sillä ei ole funktiota. Vakioiden määrittelyyn käytetään Javassa `final` avainsanaa.
`goto`
Vaikka `goto` on varattu avainsana Javassa, niin sillä ei ole funktiota.
`strictfp`
`strictfp` avainsanaa käytettiin Javan aiemmissa versioissa rajoittamaan liukulukujen tarkkuuden arvoja, mutta on nykyversiossa tarkoitukseton, joskin varattu avainsana.

Lähteet
-------

1. 1 2 3 4  Primitive Data Types *The Java Tutorials*.  February 14, 2008. Sun Microsystems, Inc.. Viitattu 3.12.2008.
2. 1 2 3  Returning a Value from a Method *The Java Tutorials*.  February 14, 2008. Sun Microsystems, Inc.. Viitattu 3.12.2008.
3. 1 2  Controlling Access to Members of a Class *The Java Tutorials*.  February 14, 2008. Sun Microsystems, Inc.. Viitattu 3.12.2008.
4. 1 2 3  The for Statement *The Java Tutorials*.  February 14, 2008. Sun Microsystems, Inc.. Viitattu 3.12.2008.
5. 1 2  The while and do-while Statements *The Java Tutorials*.  February 14, 2008. Sun Microsystems, Inc.. Viitattu 3.12.2008.
6. 1 2  The if-then and if-then-else Statements *The Java Tutorials*.  February 14, 2008. Sun Microsystems, Inc.. Viitattu 3.12.2008.
7. 1 2  The switch Statement *The Java Tutorials*.  February 14, 2008. Sun Microsystems, Inc.. Viitattu 3.12.2008.