Course Module 1 - Lecture: Gereserveerde woorden in Java

1. Woordenlijst

Zoals in elke programmeertaal, heeft Java woorden met een speciale betekenis. Bijvoorbeeld, returnof ifof while. Deze woorden worden trefwoorden ( trefwoorden ) genoemd en worden door de Java-taal als gereserveerd beschouwd.

U kunt deze woorden niet gebruiken als variabelenaam, methodenaam of klassenaam. De compiler zal ze altijd op een strikt gedefinieerde manier interpreteren. Er zijn 54zulke woorden op Java.

`abstract`	`assert`	`boolean`	`break`	`byte`
`case`	`catch`	`char`	`class`	`const`
`continue`	`default`	`do`	`double`	`else`
`enum`	`extends`	`final`	`finally`	`float`
`for`	`goto`	`if`	`implements`	`import`
`instanceof`	`int`	`interface`	`long`	`native`
`new`	`package`	`private`	`protected`	`public`
`return`	`short`	`static`	`strictfp`	`super`
`switch`	`synchronized`	`this`	`throw`	`throws`
`transient`	`try`	`void`	`volatile`	`while`
`var`	`true`	`null`	`false`

Je kent er al een paar, en we zullen het nu over de rest hebben.

2. Primitieve typen

Zoals u zich waarschijnlijk herinnert, heeft Java 8 primitieve typen, en elk daarvan heeft zijn eigen trefwoord:

byte
short
int
long
char
float
double
boolean
void

Als je voldoende nieuwsgierig bent, is de kans groot dat je al hebt geprobeerd een variabele int een naam te geven. En dat is je natuurlijk niet gelukt. Dit komt precies omdat de namen van alle primitieve typen gereserveerde woorden zijn.

Ook het voidtype valt in deze categorie.

3. Lussen en takken

Lussen en takken geven ons ook een vrij lange lijst met trefwoorden:

if
else
switch
case
default
while
do
for
break
continue

Slechts 10 woorden zijn voldoende om de taal verschillende soorten lussen, takken en besturingsinstructies te geven voor het onderbreken van lussen ( breaken continue) en meerdere takken ( switch). Al deze zoekwoorden ken je al.

4. Uitzonderingen

Uitzonderingen geven ons 5 zoekwoorden:

try
catch
finally
throw
throws

Deze maken allemaal deel uit van een try-catch-finallyblok. De operator voor het genereren van uitzonderingen is throwen het throwssleutelwoord ondersteunt het checkeduitzonderingsmechanisme.

Het goede nieuws is dat je al bekend bent met alle zoekwoorden die betrekking hebben op uitzonderingen, dus je bent ook al grotendeels bekend met het werken met uitzonderingen.

5. Zichtbaarheid

Hier zijn er slechts drie zoekwoorden en u kent ze al.

private
protected
public

publicgeeft toegang tot een methode/variabele/klasse vanaf elke plek in het programma.

privateverbiedt dat een methode/variabele/klasse overal in het programma toegankelijk is. Toegang is alleen toegestaan binnen dezelfde klasse als een methode gemarkeerd met de privatemodifier.

protectedwerkt hetzelfde als private, maar geeft ook toegang tot een methode/variabele/klasse van overgeërfde klassen. De voordelen van deze modifier zullen voor u duidelijker worden wanneer u vertrouwd raakt met OOP en overerving.

6. Werken met klassen

Er zijn 11 trefwoorden in deze categorie:

class
interface
enum
import
package
extends
implements
static
final
abstract
default

Ze zijn in te delen in 4 groepen.

De eerste groep heeft betrekking op het maken van klassen: class, interfaceen enum. Je hebt al geleerd over het declareren van klassen en opsommingen . Het interfacesleutelwoord wordt gebruikt om nog een ander klasse-achtig type te declareren: interfaces.

De tweede groep bestaat uit de pakket- en importtrefwoorden , waarmee u al bekend bent. Het sleutelwoord package wordt gebruikt om het pakket van een klasse in een klassenbestand te specificeren. En importzo kunnen we korte namen van externe klassen gebruiken bij het schrijven van onze eigen klassen.

De trefwoorden extendsen implementsworden gebruikt voor overerving. Je zult ze helemaal aan het begin van de Java Core-zoektocht bekijken.

Tot slot bestaat de laatste groep uit de static, final, default, en abstractmodifiers. Je weet al een beetje over staticen final. Het abstractsleutelwoord wordt gebruikt om een klasse of methode abstract te maken. Je krijgt meer details als je overerving bestudeert in de Java Core-zoektocht.

7. Werken met objecten en variabelen

Er worden nog zes trefwoorden gebruikt bij het werken met objecten, methoden en variabelen.

new
instanceof
this
super
return
var(sinds Java 10)

De newoperator wordt gebruikt om nieuwe objecten te maken - dat weet je al.

De instanceofoperator wordt gebruikt om te controleren of een variabele een verwijzing bevat naar een object van een bepaald type. Je bent er al bekend mee.

Het thissleutelwoord wordt gebruikt om problemen op te lossen die ontstaan door het schaduwen van instantievariabelen en methoden. Je hebt dit ook bestudeerd.

Het supersleutelwoord is analoog aan this, maar het wordt gebruikt om te verwijzen naar de methoden en variabelen van de bovenliggende klasse. De ouderklasse wordt ook wel de superklasse genoemd.

De returninstructie wordt gebruikt om de waarde van een methode terug te geven, en ook om de uitvoering van een methode te beëindigen.

Ten slotte varis voor het declareren van een variabele waarvan het type automatisch wordt afgeleid. Hiermee ben je al bekend.

8. Multithreading

Op het niveau van Java-syntaxis wordt multithreading weergegeven door slechts twee woorden.

synchronized
volatile

We zullen ze niet eens aanraken. Ga naar de Java Multithreading- zoektocht en dan duiken we erin.

9. Diversen

Er zijn nog 4 bijzondere zoekwoorden:

native
transient
assert
strictfp

nativeis een modifier die vóór een methodedeclaratie kan worden geschreven. Het betekent dat de methodecode niet in Java is geschreven, maar in C++ en is ingebed in de Java-machine (nou ja, of een DLL). Zoals je waarschijnlijk al geraden hebt, is de Java-machine zelf ook in C++ geschreven. Net als veel van de standaard bibliotheekmethoden.

transientis een modifier die vóór instantievariabelen (velden van een klasse) kan worden geschreven. Het vraagt de Java-machine om de gemarkeerde variabele over te slaan (of te negeren) tijdens het serialiseren van een object van de klasse. Je kunt meer leren over serialisatie in de Java Collections-quest.

assertkomt ook naar Java vanuit C++. Met zijn hulp kunt u extra controles aan uw code toevoegen (bijvoorbeeld om te controleren of een variabele null is). Het belangrijkste hier is dat deze controles worden in- of uitgeschakeld tijdens het compileren.

U kunt het project bouwen voor interne testen en deze controles worden uitgevoerd (inbegrepen in de build). Of u kunt ze tijdens het compileren uitschakelen om de versie van het programma te maken die aan gebruikers wordt geleverd.

Wat betreft het strictfpsleutelwoord en de extra precisie van Intel-processors, we hebben een heel verhaal voor je .

10. Gereserveerd maar niet gebruikt

Er zijn ook twee trefwoorden die gereserveerd maar niet gebruikt worden.

const
goto

Deze zijn ook een erfenis van de C++-taal, waar ze bestaan en worden gebruikt.

11. Geen zoekwoorden

Formeel zijn de constanten true, falseen nullgeen trefwoorden. Dat gezegd hebbende, ze hebben elk hun eigenaardigheden. U kunt een methode trueof een variabele geen naam geven false. De compiler zal dergelijke code niet begrijpen en zal deze niet compileren.