· 

Alle Java Keywords

1. Einführung

In Java gibt es viele verschiedene Keywords. Die meisten von ihnen wirst du wahrscheinlich schon verwendet oder zumindest gesehen haben. Doch es gibt auch Keywords, die entweder etwas unbekannter sind oder eigentlich gar nicht zu den Keywords zählen! In diesem Artikel findest du eine Sammlung aller Java-Keywords mit einer kurzen Erklärung, was sie jeweils bedeuten.


2. Was ist ein Keyword?

Keywords bzw. Schlüsselwörter sind Teil der Codestruktur einer Programmiersprache. Sie ändern die Art, wie der Compiler mit einem Code-Block umgeht. Das Keyword for sagt ihm z. B., dass er den im Scope dieses Schlüsselworts gekapselten Code eine definierte Anzahl oft wiederholt aufrufen soll. Keywords können nicht als Variable verwendet werden.


3. Welche Keywords gibt es in Java?

Im Hallo-Welt-Programm lassen sich bereits 4 Keywords erkennen:

public class HalloWelt {
   public static void main(String[] args) {
      System.out.println("Hallo Welt!");
   }
}

Die Keywords sind public, class, static und void.

public ist ein sogenannter Zugriffsmodifikator, der für Klassen, Methoden, Interfaces und Variablen verwendet wird. Das mit public versehene Objekt ist, wie der Name bereits vermuten lässt, über die gesamte Anwendung hinweg öffentlich zugreifbar. Daneben existieren noch die Zugriffsmodifikatoren private und protected. Auf mit private geschützte Methoden und Variablen kann nur innerhalb der Klasse, in der sie definiert sind, zugegriffen werden. Um eine private Variable in anderen Klassen verwenden zu können, schreibt man öffentliche Zugriffsmethoden, also Getter und Setter. Mit protected wird die Sichtbarkeit auf Package-Ebene festgelegt. Ein Paket kannst du nebenbei übrigens mit dem Keyword package definieren. Zum Import eines Packages kann import verwendet werden.

Mit dem Keyword class wird eine neue Klasse definiert. Davor kann auch noch das Keyword abstract stehen, das anzeigt, dass die vorliegende Klasse eine abstrakte Klasse ist. Steht abstract vor einer Methode, dann muss diese später in einer Subklasse implementiert werden. Wenn eine Methode, Variable oder Klasse static (also statisch) ist, meint man damit, dass kein Objekt benötigt wird, um die darin enthaltene Funktionalität verwenden zu können. Die Main-Methode braucht z. B. kein Objekt, sondern wird vom Java-Interpreter direkt aufgerufen. Zudem kann man mit diesem Keyword Methodenblöcke markieren, die beim ersten Aufruf einer Klasse ausgeführt werden sollen. void als Pseudodatentyp wird verwendet, um zu signalisieren, dass eine Methode keinen return-Wert hat. 

Damit wären wir bereits beim nächsten Keyword, nämlich return. Mit diesem kann innerhalb einer Methode ein Wert zurückgegeben werden:

public static int get_the_answer(){
   return 42;
}

Hier taucht bereits das nächste Keyword auf, nämlich int. Dies ist die Kurzform für Integer, der einen primitiven (d. h. einfachen) Datentypen für 32-Bit lange Ganzzahlen darstellt. Primitive Datentypen werden für den Aufbau komplexer Datentypen genutzt. get_the_answer( ) gibt also eine Variable vom Typ Integer zurück. Neben Integer existieren in Java weitere primitive Datentypen, die alle durch ein Keyword gekennzeichnet sind, nämlich: 

  • double für 64-Bit Fließkommazahlen
  • float für 32-Bit Fließkommazahlen
  • short für 16-Bit Ganzzahlen 
  • long für 64-Bit Ganzzahlen
  • boolean für die Wahrheitswerte wahr und falsch
  • char für vorzeichenlose (also unsigned) 16-Bit Unicode Zeichen und
  • byte für 8-Bit Daten-Pakete.
int a = 42;
double b = 4.2;
float c = 4.2f;
short d = 1;
long e = 42l;
boolean f = true;
char g = 'g';
byte h = 0x42;

Mit den Keywords if und else kann eine if-Anweisung definiert werden:

if(a == 42) {
   System.out.println("Die Antwort ist korrekt!");
} else {
   System.out.println("Die Antwort ist leider falsch!");
}

Dazu passend kann man mit switch einen Schalterblock erzeugen, der letztendlich eine elegante Darstellung mehrerer If-Else-Anweisungen ist: 

switch(a) {
case 1:
        System.out.println("Sehr gut!");
        break;
case 2:
        System.out.println("Gut!");
        break;
case 3:
        System.out.println("Befriedigend!");
        break;
case 4:
        System.out.println("Ausreichend!");
        break;
case 5:
        System.out.println("Mangelhaft!");
        break;
case 6:
        System.out.println("Ungenügend!");
        break;
default:
        System.out.println("Die eingegebene Zahl ist keine Note!");
        break;

}

Mit dem Keyword case wird die Fallunterscheidung getroffen, die je nach Bedingung durchlaufen werden. Das Wort break am Ende einer case-Anweisung bedeutet, dass der Schalterblock an dieser Stelle verlassen wird. Man nutzt dieses Schlüsselwort auch, um aus einer Schleife auszubrechen. Mit default definiert man einen Default-Bereich im Schalter-Block. Dieser wird standardmäßig losgelöst von einer Bedingung ausgeführt (sofern das Programm an diese Stelle kommt).

Statt (wie in diesem Fall) mit Integern zu arbeiten, kann man auch Aufzählungstypen (sog. Enums) verwenden. Zur Definition eines Enums verwendet man das Keyword enum:

public enum Noten {
   SEHR_GUT, GUT, BEFRIEDIGEND, AUSREICHEND, MANGELHAFT, UNGENUEGEND
}

Mit for wird eine For- und mit while eine While-Schleife begonnen. Das Keyword do wird in Kombination mit einer While-Schleife verwendet, wodurch eine Do-While-Schleife entsteht.

// For-Schleife
for(int i = 0; i < 42; i++) {
   System.out.println(i);
}

// While-Schleife              
int j = 100; 
while(j >= 0) {
   j--;
}

// Do-While-Schleife           
do {
   System.out.println("Do-While-Schleife");
} while(false);

Mit continue kann der aktuelle Schleifendurchlauf beendet werden:

int [] zahlen = {10, 20, 30, 40, 50};

for(int zahl : zahlen ) {
   if(zahl == 30) {
      continue;
   }
   System.out.println(zahl);
}

Die Ausgabe ist in diesem Fall

10
20
40
50

Für das Exception-Handling sind die Keywords try, catch und finally vorgesehen. Mit try wird ein Code-Bereich eingeleitet, der ausgeführt werden soll. Wenn innerhalb dieses Bereichs eine Exception auftritt, kann diese mit catch gefangen werden. finally markiert einen Bereich in der try-catch-Struktur, der immer ausgeführt wird:

try {
   Integer.parseInt("1");
} catch(NumberFormatException nfe) {
   System.out.println("Beim Parsen der Ganzzahl ist ein Fehler aufgetreten!");
} finally {
   System.out.println("Dieser Block wird immer durchlaufen!");
}

In diesem Zusammenhang tauchen dann oftmals auch die Keywords throw und throws auf. Mit throw wird explizit eine Exception geworfen und throws kennzeichnet in einer Methodensignatur, dass diese eine bestimmte Exception werfen könnte:

public void method(final int antwort) throws Exception {
   if(antwort != 42) {
     throw new Exception();
   }
}

Mit dem Keyword new kann ein neues Objekt erzeugt werden (in diesem Fall ein Exception-Objekt). Um eine Variable, eine Methode oder eine Klasse unveränderlich zu machen nutzt man das Keyword final.

Für eine Selbst-Referenz (z. B. eine Objektvariable innerhalb einer Klasse) wird this verwendet:

public class Objekt {
   // Objektvariable
   public final String name;
        
   public Objekt(final String name) {
      // Der übergebene Name wird der Objektvariable this.name übergeben.
      this.name = name;
   }
}

Wenn eine Klasse von einer anderen Klasse erbt, kennzeichnet man das durch extends:

public class Objekt extends Object {
   // Objektvariable
   public final String name;
        
   public Objekt(final String name) {
      // Der übergebene Name wird der Objektvariable this.name übergeben.
      this.name = name;
   }
}

Interfaces werden mit dem Keyword interface eingeleitet:

public interface Vertrag {
   public static void verhandeln() {
     System.out.println("Es wird verhandelt ...");
   }
}

Eine andere Klasse kann dieses Interface via implements implementieren:

public class Objekt extends Object implements Vertrag {
   // Objektvariable
   public final String name;
        
   public Objekt(final String name) {
      // Der übergebene Name wird der Objektvariable this.name übergeben.
      this.name = name;
   }
}

Mit dem Keyword super referenziert man bei der Vererbung die Basisklasse (bezogen auf Methoden und Konstruktoren):

public class VererbtesObjekt extends Objekt {

   public VererbtesObjekt(final String name) {
      super(name);
   }
}

Im oft schnell entstandenen Vererbungsdschungel kann es durchaus sinnvoll sein zu prüfen, ob ein Objekt die Instanz einer bestimmten Klasse ist. Hierfür nimmt man das zu prüfende Objekt, kombiniert es mit dem Keyword instanceof und schreibt dahinter die Klasse, auf die geprüft werden soll:

final Objekt objekt = new Objekt("Java");
System.out.println(objekt instanceof Objekt); //true  

Durch Assertions versucht der Entwickler (also du) spezielle Annahmen über den Zustand des Programmes zu verifizieren und sicherzustellen, dass diese eingehalten werden. Soll z. B. an einer bestimmten Stelle keine negative Zahl stehen, kann dies mit dem Keyword assert und einer passenden Bedingung geprüft werden:

assert a >= 0;

Wenn die Bedingung nicht erfüllt ist, wird eine Exception ausgelöst. Natürlich kann man dieses Konstrukt auch durch eine If-Anweisung realisieren, doch eine Assertion ist kürzer, besser als Korrektheits-Check erkennbar und sie lässt sich zur Laufzeit wahlweise ein- und ausschalten.

Das Keyword native wird in Java an eine Methode (und nur an eine Methode!) angehängt, um zu signalisieren, dass diese in nativem Code mit dem Java Native Interface (JNI) programmiert wurde. Der Sinn dahinter ist es, einen Performance-Boost zu erzielen und auf Speicherebene kommunizieren zu können:

public class Native { 
   static { 
      System.loadLibrary("Pfad zur nativen Bibliothek"); 
   } 
   public native void native_function(); 
} 

Der Aufruf sieht dann das standardmäßige Erzeugen eines Objekts vor, auf dem dann die native Methode aufgerufen werden kann:

final Native native_object = new Native();
native_object.native_function();

Das Thema „Runden“ ist im Kontext von Computersystemen sehr wichtig aber auch sehr komplex. Mit der Verwendung von strictfp geht die Java Virtual Machine (JVM) bei Operationen strikt nach der IEEE-Norm vor, d. h. nach außen bleiben die Datentypen Double 32 Bit und Float 64 Bit lang, während sie intern evtl. mit einer größeren Genauigkeit berechnet werden. Diese Vorgehensweise soll die Portabilität von Programmen sicherstellen:

// Standard-Klasse.
public class NormaleKlasse {
   // Genaue Methode.
   public static strictfp float mul(float a, float b) {
      return a*b;
   }
}

// Strikte Klasse.
public strictfp class GenaueKlasse {
                
}
        
// Striktes Interface.
public strictfp interface GeneuesInterface {
        
}

Mit synchronized werden in Java kritische Sektionen, die es in nebenläufigen Anwendungen zu schützen gilt, gesichert. Es können bestimmte Code-Bereiche oder ganze Methoden so implementiert werden, dass sie einen exklusiven Zugriff ermöglichen:

public void methode() {
   final Objekt objekt = new Objekt();
   synchronized(objekt) {
      // Geschützter Bereich
   } 
}
                
public synchronized void synchrone_methode() {
   // Synchrone Methode. 
}

Das Keyword volatile, das aus dem Englischen übersetzt einfach nur „flüchtig“ bedeutet, zeigt dem Compiler an, dass sich die damit versehene Variable innerhalb einer Anwendung mit mehreren Threads asynchron ändern kann. Der Effekt geht in eine ähnliche Richtung wie bei synchronized (nur eben ohne den durch synchronized verursachten Overhead).

transient zeigt an, dass eine dadurch gekennzeichnete Variable bei der Serialisierung eines Objektes nicht mit gespeichert werden soll:

public class Objekt extends Object implements Vertrag {
   // Objektvariable
   public final String name;
        
   // Variable, die bei der Serialisierung nicht gespeichert wird.
   public final transient double magic;
        
   public Objekt(final String name) {
      // Der übergebene Name wird der Objektvariable this.name übergeben.
      this.name = name;
      magic = Math.random();
   }
}

Seit Java 10 gibt es ein weiteres Keyword, nämlich var. Damit ist es fortan möglich Variablendeklarationen ähnlich wie in JavaScript etwas kompakter durchzuführen. Z. B. kann man damit eine ArrayList definieren, indem man vor die gewünschte Variable ein var setzt und dahinter die ganz normale ArrayList-Definition mit Übergabe des Typs vornimmt.

var names = new ArrayList<String>();

4. Sind 'true', 'false' und 'null' keine Keywords?

Dir ist vielleicht aufgefallen, dass die Wörter true, false und null bisher noch nicht genannt wurden. Das liegt daran, dass sie zwar wie Keywords aussehen, doch in Wahrheit handelt es sich bei ihnen um Literale. Literale sind Werte, die man (z. B. einer Variable) zuweisen kann. Sie bilden zwar Teile eines Ausdrucks, doch ändern nicht die Art und Weise, wie der Compiler den Code behandelt. true wird als Wahrheitswert wahr, false als Wahrheitswert falsch und null als Referenz auf nichts verwendet. 


5. Reservierte Keywords

Es gibt aktuell zwei Keywords in Java, die noch nicht verwendet werden, jedoch für die Zukunft bereits reserviert wurden, nämlich const und goto. Sie können also ebenfalls nicht als Variablennamen verwendet werden. In anderen Programmiersprachen (z. B. C) gibt es diese Schlüsselwörter aber.