01 Java – Token

Die deutsche Sprache besteht aus Sätzen, welche sich wiederum aus bestimmten Worten und Wortreihenfolgen zusammensetzen. Dies wird als Grammatik bezeichnet. Auch Java (so wie jede andere Programmiersprache) besitzt solch eine Grammatik. Diese wird als Syntax bezeichnet. Der Compiler zerlegt diese Syntax oder auch Codezeilen in seine Bestandteile und identifiziert diese als Token. Diese Token sind die kleinsten Elemente eines Java-Programms. Unterschieden wird zwischen 6 Token-Arten.

Bezeichner
Schlüsselwörter
Literale
Operatoren
Separatoren
Kommentare

Bezeichner

Ein Bezeichner (engl. Identifier) ist im Prinzip ein frei wählbarer Name. Dieser wird unter anderem an Variablen, Methoden, Klassen, etc. vergeben und zu einem späteren Zeitpunkt kann ein Konstrukt mit diesem Bezeichner angesprochen werden.

Namensregeln

Java setzt strikte Regeln, welche Zeichen an welcher Stelle für Bezeichner erlaubt sind.

Bezeichner dürfen nicht mit einer Zahl [0-9] beginnen.
Bezeichner dürfen keine Operatoren oder Separatoren enthalten.
Eine .java-Datei, deren Klasse und der Konstruktor müssen den gleichen Namen haben.

Namenskonventionen

Konventionen sind keine festen Regeln, sondern Richtlinien. Es kann zwar von ihnen abgewichen werden, es wird jedoch empfohlen, sich an sie zu halten.

Benennung in englischer Sprache.
Es sollten keine Schlüsselwörter und auch nicht in abgewandelter Form verwendet werden (Ausnahmen wie z.B. class → clazz sind dennoch möglich).
Es sollten keine Umlaute [Ä, ä, Ö, ö, Ü, ü, ß] verwendet werden.
Es sollten keine Dollarzeichen $ verwendet werden.
Es sollten keine Unterstriche _ verwendet werden (Ausnahme: Konstanten).
Dollarzeichen $ und Unterstriche _ sollten am Anfang nur aus gutem Grund verwendet werden.
Variablen und Methoden sollten nach der CamelCase-Notation benannt werden.
Klassen (und damit auch Konstruktoren und Java-Dateien) sollten nach der PascalCase-Notation benannt werden.
Konstanten sollten nach der SCREAMING_SNAKE_CASE-Notation benannt werden.

Keywords – 57

Schlüsselwörter (engl. Keywords) sind reservierte Wörter, die eine spezielle Bedeutung für den Compiler haben. Diese Wörter dürfen und können im Regelfall nicht als Namen für Variablen, Methoden, Klassen oder andere Bezeichner verwendet werden, da sie zur Sprachsyntax von Java gehören und bestimmte Aktionen oder Strukturen definieren. Einige Ausnahmen werden im Abschnitt Kontextbezogene "Keywords" beschrieben.

Keywords	Anwendungsbereich	Beschreibung
`assert`	Annahmen	Stellt Annahmen über den Zustand des Programms sicher. Müssen erst aktiviert werden, um verwendet werden zu können.
`boolean`	Variablen Konstanten Methoden (Rückgabetyp) Methoden (Parameter)	Primitiver Datentyp Datentyp einer Variablen Datentyp einer Konstanten Rückgabetyp einer Methode Parameter einer Methode
`break`	Schleifen switch-Ausdrücke	Beendet die Ausführung einer Schleife. Verhindert das "Durchfallen" in einem `switch`-Ausdruck.
`byte`	Variablen Konstanten Methoden (Rückgabetyp) Methoden (Parameter)	Primitiver Datentyp Datentyp einer Variablen Datentyp einer Konstanten Rückgabetyp einer Methode Parameter einer Methode
`case`	switch-Ausdrücke	Definiert einen `case` innerhalb eines `switch`-Ausdrucks, der ausgeführt wird, wenn der Wert der `switch`-Variablen mit dem Wert des `case` übereinstimmt.
`catch`	Exceptions	Beginnt einen Block, der einen bestimmten Ausnahmetyp behandelt.
`char`	Variablen Konstanten Methoden (Rückgabetyp) Methoden (Parameter)	Primitiver Datentyp Datentyp einer Variablen Datentyp einer Konstanten Rückgabetyp einer Methode Parameter einer Methode
`class`	Klassen	Deklariert eine Klasse.
`const`*	-	Reserviertes, aber nicht verwendetes Keyword.
`continue`	Schleifen	Fährt mit dem nächsten Durchlauf der nächstgelegenen umschließenden Schleife fort.
`default`	Interfaces (Default-Methoden) switch-Ausdrücke	Methoden mit diesem Modifier bringen in Interfaces Standardimplementierungen mit. Diese Methoden können, müssen aber nicht überschrieben werden, wenn das Interface implementiert wird. Bei Abfragen mittels `switch`-Ausdrücken wird das Schlüsselwort als "else"-Zweig verwendet.
`do`	do-while-Schleife	Beginnt eine fußgesteuerte `do`-`while`-Schleife.
`double`	Variablen Konstanten Methoden (Rückgabetyp) Methoden (Parameter)	Primitiver Datentyp Datentyp einer Variablen Datentyp einer Konstanten Rückgabetyp einer Methode Parameter einer Methode
`else`	if-Abfragen	Definiert einen Default-Zweig eines `if`-Ausdrucks, der ausgeführt wird, wenn alle vorherigen Bedingungen `false` ergeben.
`enum`	Enumerationen	Deklariert ein Enum.
`extends`	Klassen Interfaces	Lässt eine Klasse von einer anderen erben.
`finally`	Exceptions	Der `finally`-Block wird optional nach einem `try`-Block definiert. Dieser wird jedes Mal ausgeführt, unabhängig davon, ob eine Exception geworfen wurde.
`float`	Variablen Konstanten Methoden (Rückgabetyp) Methoden (Parameter)	Primitiver Datentyp Datentyp einer Variablen Datentyp einer Konstanten Rückgabetyp einer Methode Parameter einer Methode
`for`	for-Schleife for-each-Schleife	Deklariert eine `for`-Schleife. Deklariert eine `for`-each-Schleife.
`goto`*	-	Reserviertes, aber nicht verwendetes Keyword.
`if`	if-Abfragen	Deklariert eine `if`-Abfrage.
`implements`	Klassen Interfaces	Implementiert ein Interface.
`import`	Importanweisungen	Importiert eine oder mehrere Klassen aus einem anderen Package zur Verwendung in die aktuelle Datei/Klasse.
`instanceof`	Typüberprüfungen	Überprüft eine Variable auf seinen Referenztyp.
`int`	Variablen Konstanten Methoden (Rückgabetyp) Methoden (Parameter)	Primitiver Datentyp Datentyp einer Variablen Datentyp einer Konstanten Rückgabetyp einer Methode Parameter einer Methode
`interface`	Interfaces	Deklariert ein Interface.
`long`	Variablen Konstanten Methoden (Rückgabetyp) Methoden (Parameter)	Primitiver Datentyp Datentyp einer Variablen Datentyp einer Konstanten Rückgabetyp einer Methode Parameter einer Methode
`new`	Objekterzeugung / Instanziierung	Erzeugt ein neues Objekt/Instanz.
`package`	Package-Anweisung	Registriert die aktuelle Datei/Klasse für das Dateiverzeichnissystem, damit diese von anderen gefunden werden kann.
`return`	Methoden	Gibt den Rückgabewert an den Aufrufer der Methode zurück.
`short`	Variablen Konstanten Methoden (Rückgabetyp) Methoden (Parameter)	Primitiver Datentyp Datentyp einer Variablen Datentyp einer Konstanten Rückgabetyp einer Methode Parameter einer Methode
`super`	Objektvariablen Objektmethoden Konstruktoren	Ruft Konstruktoren der Oberklasse auf. Ruft Objektvariablen der Oberklasse auf. Ruft Objektmethoden der Oberklasse auf.
`switch`	switch-Ausdrücke	Definiert einen `switch`-`case`-Ausdruck.
`this`	Objektvariablen Objektmethoden Konstruktoren	Ruft Konstruktoren der Klasse auf. Ruft Objektvariablen der Klasse auf. Ruft Objektmethoden der Klasse auf.
`throw`	Exceptions	"Wirft" eine Exception.
`throws`	Methoden (Ausnahmenweitergabe)	Kennzeichnung einer Methode, dass diese eine Exception werfen kann, die welche an den Aufrufer weitergeleitet wird.
`try`	Exceptions	Deklariert einen `try`-`catch`-Block zum Abfangen von Exceptions.
`void`	Methoden (Rückgabetyp)	Gibt an, dass die Methode keinen Rückgabetyp hat.
`while`	while-Schleife do-while-Schleife	Deklariert eine `while`-Schleife. Deklariert eine `do`-`while`-Schleife.

Modifizierer – 12

Keyword	Anwendungsbereich	Beschreibung
`abstract`	Methoden Klassen	Enthält eine Klasse mindestens eine abstrakte Methode, muss auch diese Klasse den Modifier tragen. Eine abstrakte Klasse kann nicht instanziiert werden. Abstrakte Methoden besitzen keinen Rumpf und müssen von Kindklassen implementiert werden.
`final`	Variablen Konstanten Methoden Klassen	Variablen können nicht überschrieben werden. Konstanten können nicht überschrieben werden. Methoden können nicht überschrieben werden. Von Klassen kann nicht geerbt werden.
`native`	Methoden	Gibt an, dass eine Methode in nativem Code mithilfe von JNI implementiert ist. Die in C oder C++ implementierten Methoden werden native Methoden oder fremde Methoden genannt. `native` gibt an, dass eine Methode in plattformabhängigem Code implementiert ist, der häufig in diesen Sprachen vorkommt.
`package-private`	Variablen Konstanten Methoden Klassen Konstruktoren	Wird automatisch intern angewendet, wenn kein anderer Access Modifier zugewiesen wird. Eine Ausnahme sind Konstruktoren in Enumerationen. Dort ist es standardmäßig `private`. Kann nicht von Entwicklern gesetzt werden. Konstrukte mit diesem Modifier sind nur innerhalb desselben Package sichtbar.
`private`	Variablen Konstanten Methoden Innere Klassen Konstruktoren	Zugriff nur innerhalb der Klasse.
`protected`	Variablen Konstanten Methoden Innere Klassen Konstruktoren	Zugriff von Kindklassen Zugriff von allem innerhalb desselben Package.
`public`	Variablen Konstanten Methoden Klassen Konstruktoren	Zugriff von überall.
`static`	Variablen Konstanten Methoden Innere Klassen	Objektunabhängiger Zugriff. Zugriff über den Klassennamen.
`strictfp`	Methoden Klassen	Sicherstellung, dass Fließkommaoperationen auf allen Plattformen gleich berechnet werden und nicht von der Art des Prozessors oder der Implementierung der JVM abhängen. Klassen oder Methoden mit diesem Keyword führen alle Operationen in Übereinstimmung mit dem IEEE 754 Standard durch. Ab Java 17 werden alle Operationen standardmäßig mit IEEE 754 durchgeführt. `strictfp` ist daher redundant geworden. In speziellen Umgebungen oder in älteren Java-Versionen hat das Keyword möglicherweise noch Relevanz.
`synchronized`	Methoden	Auf Methoden kann immer nur von einem Thread zugegriffen werden.
`transient`	Variablen Methoden	Variablen eines Objekts werden bei der Serialisierung nicht berücksichtigt. Methoden eines Objekts werden bei der Serialisierung nicht berücksichtigt.
`volatile`	Variablen Konstanten	Alle Threads lesen und schreiben den Wert der Variablen direkt aus dem Hauptspeicher, anstatt eine Kopie im Cache zu verwenden. Damit wird sichergestellt, dass die Threads den aktuellen Wert sehen und inkonsistente oder falsche Ergebnisse verhindert werden.

Kontextbezogene "Keywords" – 6

Alle "Keywords" in der folgenden Tabelle können als Identifier verwendet werden (mit Ausnahme von non-sealed).

Keyword	Anwendungsbereich	Beschreibung
`non-sealed`	Versiegelte Klassen Versiegelte Interfaces	Der Modifizierer `non-sealed` wurde als Vorschaufunktion in Java 15 eingeführt und mit Java 17 finalisiert. Es öffnet eine Klasse wieder ohne Beschränkungen für weitere Vererbungen. `non-sealed` ist das einzige Keyword, welches einen Operator besitzt und kann deshalb nicht als Identifier genutzt werden.
`permits`	Versiegelte Klassen Versiegelte Interfaces	`permits` wurde als Vorschaufunktion in Java 14 eingeführt und mit Java 16 finalisiert. Es ermöglicht in Verbindung mit `sealed` und die explizite Angabe der Kindklassen, die Vererbung von Klassen einzuschränken.
`record`	Records	Der Modifizierer `record` wurde als Vorschaufunktion in Java 14 eingeführt und mit Java 16 finalisiert. Es wird anstelle des `class`-Schlüsselwortes verwendet, um eine Record-Klasse zu erstellen.
`sealed`	Versiegelte Klassen Versiegelte Interfaces	Der Modifizierer `sealed` wurde als Vorschaufunktion in Java 15 eingeführt und mit Java 17 finalisiert. Es ermöglicht in Verbindung mit `permits` und die explizite Angabe der Kindklassen, die Vererbung von Klassen einzuschränken.
`var`	Variablen	Seit Java 10 gibt es die Möglichkeit eine Variable mit `var` zu deklarieren. Es dient im Rahmen der Type Inference als Platzhalter für einen Datentyp. Es wird häufig als Keyword verwechselt, ist aber ein Reserved Type Name.
`yield`	switch-Ausdrücke	`yield` wurde in Java 14 hinzugefügt. Es findet nur innerhalb eines switch-Ausdrucks als Return-Anweisung Anwendung.

Literale

Literale (engl. Literals) bzw. Literalkonstanten bezeichnen Werte, die sich im Programm nicht ändern können. Unterschieden wird unter den folgenden 7 Literal-Arten.

Kategorie	Literal
Ganzzahl-Literal	`42`
Fließkommazahl-Literal	`3.14`
Boolean Literal	`true` `false`
Zeichen-Literal	`@`
String Literal	`"Hello World!"`
Text Block Literal	`"""Hello World!"""`
Null Literal	`null`

Operatoren

Operatoren (engl. Operators) bezeichnen Zeichen(-folgen), welche in der Programmierung und der Mathematik verwendet werden, um Operationen wie Additionen oder Multiplikationen durchzuführen. Diese Operatoren können in unäre, binäre und ternäre Operatoren unterteilt werden. Darüber hinaus gibt es noch Kategorien wie arithmetische Operatoren, Zuweisungsoperatoren, Vergleichsoperatoren, logische Operatoren, Bitoperatoren und In- / Dekrement.

Unäre Operatoren benötigen nur einen Operanden.
Binäre Operatoren benötigen zwei Operanden.
Ternäre Operatoren werden durch drei Operanden verknüpft.

Operatoren	Kategorie	Beschreibung
`+` `-` `*` `/` `%`	Arithmetische Operatoren	Arithmetische Operatoren führen mathematische Operationen auf numerischen Werten durch.
`=` `+=` `-=` `*=` `/=` `%=` `&=` `\|=` `^=` `>>=` `<<=` `>>>=`	Zuweisungsoperatoren	Zuweisungsoperatoren führen (mal abgesehen von `=`) erst die geforderte Operation durch und weisen das Ergebnis einer Variablen zu.
`&&` `\|\|` `!`	Logische Operatoren	Logische Operatoren verknüpfen zwei boolesche Ausdrücke und geben ebenfalls ein boolesches Ergebnis (`true` oder `false`) zurück.
`>` `<` `>=` `<=` `==` `!=`	Vergleichsoperatoren	Vergleichsoperatoren vergleichen zwei Operanden und geben ein boolesches Ergebnis (`true` oder `false`) zurück.
`~` `\|` `&` `^` `<<` `>>` `>>>`	Bitoperatoren	Arbeiten direkt auf den einzelnen Bits eines Datenwerts.
`++` `--`	Inkrement / Dekrement	Erhöht oder verringert einen Wert um `1`.
`? :`	Ternäre Operator	Dient einer verkürzten Schreibweise des `if` - `else`-Ausdrucks mit möglichem Rückgabewert.
`->`	Lambda Operator	Definiert Lambda-Ausdrücke, welche mit Java 8 hinzugefügt wurden.

Separatoren

Separatoren (engl. Separators) dienen dem Compiler dazu, einzelne Bezeichner und Anweisungen voneinander trennen zu können.

Separator	Beschreibung
`(` `)`	Dient als Kennzeichnung der Parameter und Attribute bei Methodenaufrufen, sowie der Änderung der Berechnungsvorschrift.
`{` `}`	Kennzeichnen den Anfang und das Ende eines Anweisungsblocks.
`[` `]`	Dient zur Definition von Arrays, dessen Größen und den Zugriff auf einzelne Felder des Arrays.
`;`	Wird als Abschluss einer Anweisung verwendet.
`,`	Dient als Abtrennung zwischen Werten, Anweisungen und Parametern.
`.`	Trennt Paketnamen von Unterpaketen und Klassen, sowie Variablen von Methoden.
`...`	Dient als variable Parameterangabe bei Methoden.
`@`	Wird als Präfix für Annotationen verwendet.
`::`	Dient als Methodenreferenz und Alternative zu Lambda-Ausdrücken.

Kommentare

Kommentare (engl. Comments) können dabei helfen, anderen Entwicklern (und auch einem selbst) den eigenen Code verständlicher zu machen. Dies erhöht die Wartbarkeit, Lesbarkeit und das Verständnis für die Funktion des Codes. Unterschieden wird zwischen drei Kommentararten.

// Ich bin ein einzeiliger Kommentar!

            /*
             * Ich bin ein
             * mehrzeiliger Kommentar
             */
        

            /**
             * Ich bin ein
             * Java-Doc Kommentar
             */
        

Wird in einer IDE (Integrated Development Environment) beispielsweise über einen Klassen- oder Methodennamen gehovert, erscheint ein kleines Fenster – dies ist die Java-Dokumentation. Sie beschreibt den Aufbau und die Funktionsweisen der Klassen, Methoden etc. genauer.

Assoziativität

Die Assoziativität beschreibt die genaue Reihenfolge, in der die Operatoren und Separatoren ausgewertet werden. Operatoren mit einer höheren Priorität oder Vorrang werden vor Operatoren mit einer niedrigeren Priorität ausgewertet. Besitzen zwei Operatoren die gleiche Priorität, entscheidet die Assoziativität über die Auswertungsreihenfolge.

Last modified: 07 October 2024