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 – 56

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.

Keyword	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 Konstante - Rückgabetyp einer Methode
`break`	- Schleifen - `switch`-`case`-Ausdrücke	- Beendet die Ausführung einer Schleife. - Verhindert das "Durchfallen" in einem `switch`-`case`-Ausdruck.
`byte`	- Variablen - Konstanten - Methoden (Rückgabetyp) - Methoden (Parameter)	- Primitiver Datentyp - Datentyp einer Variablen - Datentyp einer Konstante - Rückgabetyp einer Methode
`catch`	- Ausnahmebehandlungsblock	- Beginnt einen Block, der einen bestimmten Ausnahmetyp behandelt.
`char`	- Variablen - Konstanten - Methoden (Rückgabetyp) - Methoden (Parameter)	- Primitiver Datentyp - Datentyp einer Variablen - Datentyp einer Konstante - Rückgabetyp einer Methode
`class`	- Klassen	- Deklariert eine Klasse.
`const`*	Keine	- Reserviertes, aber nicht verwendetes Keyword.
`continue`	- Schleifen	- Fährt mit dem nächsten Durchlauf der nächstgelegenen umschließenden Schleife fort.
`default`	- Methoden (Interfaces) - `switch`-`case`-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`-`case`-Ausdrücken wird das Schlüsselwort als "else"-Zweig verwendet.
`do`	-`do`-`while`-Schleifen	- Beginnt eine fußgesteuerte `do`-`while`-Schleife.
`double`	- Variablen - Konstanten - Methoden (Rückgabetyp) - Methoden (Parameter)	- Primitiver Datentyp - Datentyp einer Variablen - Datentyp einer Konstante - Rückgabetyp einer Methode
`else`	-`if`-`else`-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	- Erbt von einer anderen Klasse.
`finally`	- Ausnahmebehandlungsblöcke	- 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 Konstante - Rückgabetyp einer Methode
`for`	-`for`-Schleife - `for`-each-Schleife	- Deklariert eine `for`-Schleife. - Deklariert eine `for`-each-Schleife
`if`	-`if`-`else`-Abfragen	- Deklariert eine `if`-Abfrage.
`goto`*	Keine	- Reserviertes, aber nicht verwendetes Keyword.
`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 Typ.
`int`	- Variablen - Konstanten - Methoden (Rückgabetyp) - Methoden (Parameter)	- Primitiver Datentyp - Datentyp einer Variablen - Datentyp einer Konstante - Rückgabetyp einer Methode
`interface`	- Interfaces	- Deklariert ein Interface.
`long`	- Variablen - Konstanten - Methoden (Rückgabetyp) - Methoden (Parameter)	- Primitiver Datentyp - Datentyp einer Variablen - Datentyp einer Konstante - Rückgabetyp einer Methode
`new`	- Objekterzeugung / Instanziierung	- Erzeugt ein neues Objekt/Instanz.
`package`	- Package-Anweisungen	- 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 Konstante - Rückgabetyp einer Methode
`super`	- Objektzugriff auf Oberklasse - Konstruktoren	- Ruft Konstruktoren der Oberklasse auf. - Ruft Variablen der Oberklasse auf. - Ruft Methoden der Oberklasse auf.
`switch`	-`switch`-`case`-Ausdrücke	- Definiert einen `switch`-`case`-Ausdruck.
`this`	- Kontextueller Aufruf über Objekt	- Ruft im Kontext der Klasse, Objektvariablen auf. - Ruft im Kontext der Klasse, Objektmethoden auf.
`throw`	- Ausnahmebehandlungen	- "Wirft" eine Exception.
`throws`	- Methoden (Ausnahmeweitergaben)	- Kennzeichnung einer Methode, dass diese eine Exception werfen kann, die abgefangen werden muss.
`try`	- Ausnahmebehandlungsblöcke	- Deklariert einen `try`-`catch`-Block zum Abfangen von Exceptions.
`void`	- Methoden (Rückgabetyp)	- Gibt an, dass die Methode nichts zurückgibt.
`while`	-`while`-Schleifen - `do`-`while`-Schleifen	- 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 Unterpakten 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.

Last modified: 19 August 2024