Schlüsselwörter und Bezeichner in Java 

Abgerundete Kästchen in Syntaxdiagrammen

Ein abgerundetes Kästchen in einem morphologischen Diagramm  steht für ein Zeichen, ein abgerundetes Kästchen in einem Syntaxdiagramm  steht für eine lexikalische Einheit. Deswegen darf in einem abgerundeten Kästchen in einem morphologischen Diagramm immer nur ein Zeichen stehen, während in einem abgerundeten Kästchen in einem Syntaxdiagramm auch mehrere Zeichen  stehen dürfen, die zusammen eine lexikalische Einheit bilden.

Beispiel eines Syntaxdiagrammes mit einer lexikalischen Einheit mit mehreren Zeichen

Gamma
     .---.      .-.
--->( abc )--->( ; )--->
     '---'      '-'

Drei mögliche Inkarnationen der Kategorie »Gamma«

abc;
abc ;
abc 
;

In den beiden obigen Beispielen zur Kategorie »Vorzeichen« ist sowohl die Interpretation als morphologisches Diagramm als auch die Interpretation als Syntaxdiagramm möglich gewesen, weil ein Vorzeichen wie »-« sowohl ein Zeichen ist als auch eine lexikalische Einheit sein kann. In dem hier angegebenen Beispiel zur Kategorie »Gamma« findet sich nun eine lexikalische Einheit »abc«, die aus drei Zeichen  besteht.

Lexikalische Einheiten aus mehreren Zeichen, wie beispielsweise »abc«, werden manchmal auch als Wortsymbole  bezeichnet. Dadurch wird ausgedrückt, daß es sich zwar im allgemeinen um mehrere Zeichen  handelt, aber in der Programmiersprache die lexikalische Einheit »abc« als ein einziges Symbol  angesehen wird, genauso wie etwa die lexikalische Einheit »;«, die nur aus einem Zeichen besteht.

Zerlegung des Quelltextes »abc;« in zwei lexikalische Einheiten

     .---.      .-.
--->( abc )--->( ; )--->
     '---'      '-'

Schlüsselwörter

Ein Schlüsselwort  ist eine Wort, das in den offiziellen Syntaxdiagrammen von Java  als ein Terminalsymbol erscheint. Man findet sie in den offiziellen Syntaxdiagrammen also in abgerundeten Kästchen. (In den Produktionsregeln der Java Language Specification  sind Schlüsselwörter Wörter in nicht-kursiver dicktengleicher serifenbetonter Linearantiqua [„Schreibmaschinenschrift“].)

Jedes Schlüsselwort ist damit auch eine lexikalische Einheit.

Es handelt sich bei Schlüsselwörtern also um feststehende Bestandteile der Syntax der Programmiersprache Java.

Wir können aus dem Syntaxdiagramm „final-Variablendeklaration“ vier Schlüsselwörter ablesen: »final«, »int«, »long« und »double«.

final-Variablendeklaration (vereinfachtes Syntaxdiagramm)

final-Variablendeklaration
     .-----.         .-----.        .------------.      .-.      .----------.
--->( final )---.--->| Typ |---.--->| Bezeichner |---->( = )---->| Ausdruck |--->
     '-----'    |    '-----'   ^    '------------'      '-'      '----------'
                |     .---.    |
                '--->( var )---'
                      '---'
Typ
          .---.
---.---->( int )---->.--->
   |      '---'      ^
   |     .------.    |
   '--->(  long  )---'
   |     '------'    |
   |     .------.    |
   '--->( double )---'
   |     '------'    |
   |     .------.    |
   '---->| Name |----'
         '------'

Liste der bisher verwendeten Schlüsselwörter

»double«, »int«, »long«, »final«

(Die in einigen früheren Syntaxdiagrammen dieses Kurses in abgerundeten Kästchen stehenden Wörter »java«, »lang«, »System«, »out«, »println« und »print« sind jedoch keine  Schlüsselwörter. Sie standen nur wegen einer Vereinfachung  der tatsächlichen Syntaxdiagramme in abgerundeten Kästchen.)

»var« ist ausnahmsweise kein  Schlüsselwort, obwohl es im Syntaxdiagramm vorkommt.

Liste aller Schlüsselwörter

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

Aussprachehinweise

super ˈsupɚ

Bezeichner

Wir hatten den Begriff „Bezeichner“ schon früher im Kurs verwendet. Damals wurde als Bezeichner im wesentlichen das verstanden, was wir jetzt eine „Bezeichnerzeichenfolge“ nennen. Da wir inzwischen Schlüsselwörter kennengelernt haben, können wir die Definition des Begriffs „Bezeichner“ nun etwas genauer fassen.

Ein Bezeichner  ist eine Bezeichnerzeichenfolge, die kein Schlüsselwort  ist.

»double« ist beispielsweise eine Bezeichnerzeichenfolge, aber kein  Bezeichner, da es ein Schlüsselwort ist.

Schlüsselwörter sind Bezeichnerzeichenfolgen, aber keine Bezeichner.

Ein Zeichen wie der Punkt erinnert etwas an einen Operator, aber da es wird „Separator “ genannt.

Lexikalische Einheiten

Die lexikalischen Einheiten  von Java  sind: Bezeichner, Schlüsselwörter, Literale, Separatoren  und Operatoren.

Quelltext wird als eine Folge lexikalischer Einheiten  interpretiert.

Neben des lexikalischen Einheiten findet man im Quelltext noch Leerraum  und Kommentare.

Namen für Variablen

Der Name einer Variablen muß ein Bezeichner  sein.

Der Name einer Variablen darf also kein  Schlüsselwort und kein  qualifizierter Name (mit Punkten) sein.

»double« oder »java.lang.Math.floor« ist also beispielsweise kein  möglicher Name einer Variablen.

Bezeichner, welche in der Standardbibliothek definiert werden, dürfen  für den Namen einer Variablen verwendet werden. Deswegen darf eine Variable beispielsweise »floor« heißen, auch wenn es schon eine Standardmethode »java.lang.Math.floor« gibt.

»var«

Es ist möglich, eine Variable »var« zu nennen, da »var« kein Schlüsselwort ist. (Obwohl »var« im Syntaxdiagramm vorkommt, gilt es ausnahmsweise nicht  als Schlüsselwort.)

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final var var = 7;                  
    java.lang.System.out.println( var ); }}

Protokoll

7