Statische Variablen, Konstanten und Methoden in Java

In diesem Beitrag behandeln wir statische Variablen, Konstanten und Methoden.

In Java können mit Hilfe von statischen Programmelementen Eigenschaften genutzt werden, die nicht an Instanzen (konkrete Objekte) einer Klasse gebunden sind.

Am Ende des Beitrags stellen wir den statischen Initialisierer vor, mit dessen Hilfe komplexere Initialisierungen durchgeführt werden können.

Mit dem statischen Initialisierer können statische Variablen und Konstanten in Java auch nach ihrer Deklaration an beliebigen Stellen in der Klassendefinition initialisiert werden.

Statische Variablen (Klassenvariablen) und Konstanten in Java

Statische Variablen existieren unabhängig von einem Objekt. Im Gegensatz zu Objektvariablen werden sie über die Klasse aufgerufen und nicht über ein konkretes Objekt.

Möchte man in Java eine statische Variable definieren, muss man diese mit Hilfe des Schlüsselworts static als statisch deklarieren, bspw. so: static private int anzObj;.

Der Zugriff auf diese statische Variable erfolgt über die Klasse, in der sie definiert ist, und zwar über den Klassennamen: Klassennamen.Variablennamen.

In Java wird jede statische Variable nur einmal angelegt und kann von allen Objekten dieser Klasse aufgerufen werden. Da sich alle Instanzen einer Klasse die Klassenvariablen teilen, wirken sich Änderungen, die durch eine Instanz an den statischen Variablen vorgenommen werden auch auf alle anderen Instanzen aus.

Daher können Klassenvariablen als globale Variablen angesehen werden, die vom Zeitpunkt ab dem ihre Klassen geladen wurden bis zum Programmende existieren. Da jede statische Variable über den Namen ihrer Klasse aufgerufen wird, können keine Namenskollisionen auftreten.

Statische Konstanten in Java

Möchte man eine statische Variable als Konstante definieren, muss diese mit dem Schlüsselwort final als unveränderbar deklariert werden, etwa so: private static final int ZEITFAKTOR = 3600;.

Durch das Schlüsselwort final kann die Klassenvariable nach dem Initialisieren nicht mehr verändert werden. Ihr kann im weiteren Programmverlauf kein neuer Wert zugewiesen werden. Zur besseren Lesbarkeit werden Konstantennamen in Java groß geschrieben.

In der folgenden Beispielanwendung werden wir eine statische Variable verwenden und mit ihrer Hilfe die Anzahl der aktuell existierenden Instanzen der eigenen Klasse zählen. In der Anwendung wird auch eine statische Konstante definiert.

Beispielanwendung für statische Variablen und Konstanten in Java

/*
* Beispielanwendung für statische Variablen und Konstanten in Java
*/

public class TestObjekt
{
  private static int anzObj;
  private static final int MAXOBJ = 5; // Konstante muss bei Initial. gesetzt werden
  //private static final int MINOBJ;  // kein Wert gesetzt, daher Compiler-Fehler

  public TestObjekt()
  {
     this.anzObj++; // this-Zeiger in Konstruktoren auf Klassenvariablen erlaubt
     System.out.println("Objekt erzeugt!");
  }

  public void finalize()
  {
     this.anzObj--; // this-Zeiger in nicht statischen Methoden erlaubt
     System.out.println("Objekt geloescht!");
  }

  public static void main (String[] args)
  {
     // this.anzObj = 0;  // this-Zeiger in statischen Methoden nicht vorhanden
     TestObjekt.anzObj = 0; // anzObj = 0; kann auch verwendet werden

     TestObjekt obj1 = new TestObjekt();
     TestObjekt obj2 = new TestObjekt();
     TestObjekt obj3 = new TestObjekt();
 
     obj1.finalize();

     System.out.println("\nObjekte: " + TestObjekt.anzObj + "\n");

     for (int i=TestObjekt.anzObj; i<TestObjekt.MAXOBJ; i++)
     {
        obj1 = new TestObjekt();
     }     

     System.out.println("\nObjekte: " + TestObjekt.anzObj);
  }
}

In Zeile 7 wird die statische Variable anzObj definiert. Der Klassenvariable wird bei der Deklaration noch kein Wert zugewiesen, dies erfolgt erst in Zeile 26 mit Zugriff über den Klassennamen: TestObjekt.anzObj = 0;.

In Zeile 8 wird die statische Konstante MAXOBJ deklariert und mit dem Wert 5 initialisiert. In Zeile 36 wird der Wert der Konstante abgefragt, der Zugriff erfolgt auch hier über den Klassennamen: i < TestObjekt.MAXOBJ;.

Die Anweisung in Zeile 25 ist auskommentiert. Sie würde zu einem Compiler-Fehler führen, da der this-Zeiger in statischen Methoden nicht zur Verfügung steht. Stattdessen muss der Zugriff auf statische Variablen und Konstanten über den Klassennamen erfolgen, wie in Zeile 26.

Starten wir nun die Beispielanwendung. In der unten abgebildeten Kommandozeilenausgabe ist die resultierende Textausgabe dargestellt:

Statische Methoden (Klassenmethoden) in Java

Ein weiteres statisches Programmelement in Java sind Klassenmethoden. Klassenmethoden sind statische Methoden und existieren unabhängig von einer konkreten Instanz.

Eine statische Methode wird über die Klasse aufgerufen, in der sie definiert ist und zwar erfolgt der Aufruf über den Namen der Klasse: Klassenname.Methodenname.

Methoden werden in Java mit Hilfe des static-Schlüsselworts als statisch deklariert. Die folgende Deklaration definiert eine statische Methode die einen int-Wert zurückgibt: private static int berechneWert() {...}.

Hinweis: Von Klassenmethoden aus kann nicht auf Instanzvariablen zugegriffen werden, da statische Methoden unabhängig von konkreten Objekten existieren. In Klassenmethoden kann der this-Zeiger nicht verwendet werden. Wird er dennoch benutzt, erhält der Entwickler einen Compiler-Fehler, wie in Zeile 25 in der oberen Beispielanwendung.

Es ist aber auch ohne this-Zeiger möglich von statischen Methoden aus auf statische Variablen zuzugreifen. Dazu muss der Klassenname vor den Variablennamen gestellt werden. Dieses Voranstellen des Klassennamens (Qualifizieren mittels Klassennamen) ist nur erforderlich, falls die statische Variable von einer lokalen Variable überdeckt wird.

Die Verwendung von Klassenmethoden bietet sich bei Berechnungen mit primitiven Datentypen an oder wenn Funktionen zur Verfügung gestellt werden sollen, die nicht mit Objektdaten arbeiten. Beispiele dafür sind in der Math- und System-Klasse in der Klassenbibliothek von Java zu finden.

Die bekannteste statische Methode in Java ist die Methode main, die als Startpunkt für jede Java-Anwendung dient.

Die Klassenmethoden: public static void main (String[] args)

Die main-Methode ist der Einstiegspunkt in Java-Anwendungen. Beim Starten einer Java-Anwendung lädt der Java-Interpreter das im Aufruf angegebene Klassenobjekt und sucht nach einer statischen Methode mit der folgenden Signatur: public static void main (String[] args).

Kann der Java-Interpreter die main-Methode nicht finden, führt dies zu einem Laufzeitfehler und es wird eine Fehlermeldung ausgegeben.

Wird die main-Methode gefunden, erstellt der Java-Interpreter ein Array mit den Kommandozeilenparametern und übergibt das Array als Argument an die main-Methode.

Mehrfach-Initialisierung mit Hilfe des statischen Initialisierers

In Java können statische Variablen auch nach der Deklaration initialisiert werden. Oft erfolgt jedoch die Initialisierung direkt in einem Schritt mit der Deklaration. Dies kann aber bei komplexeren Initialisierungen schnell unübersichtlich werden. Der statische Initialisierer löst genau dieses Problem und erlaubt die nachträgliche Initialisierung von statischen Variablen und Konstanten.

Der statische Initialisierer ähnelt einem Konstruktor und ermöglicht es beliebig viele statische Variablen und Konstanten mit Startwerten zu belegen, eine Konstante jedoch nur ein einziges Mal.

In einer Klasse können mehrere statische Initialisierer verwendet werden. Sie werden als Block ähnlich einer Methode definiert und tragen den Blocknamen static. Die statischen Initialisierer werden beim Laden der Klasse aufgerufen. Dabei werden statische Variablen und statische Initialisierer in der textuellen Reihenfolge ihrer Deklaration ausgeführt.

In der folgenden Beispielanwendung werden statische Variablen und Konstanten mit Hilfe von statischen Initialisierern initialisiert.

Beispielanwendung der statische Initialisierer in Java

/*
* Beispielanwendung der statische Initialisierer in Java
*/

public class StaticInit
{
  private static int staticVar1, staticVar2, staticVar3;
  private static int staticVar4 = 0;
  private static final int KONSTANTE1 = 5; // Konstante muss bei Initial. gesetzt werden
  private static final int KONSTANTE2, KONSTANTE3; // oder vom statischen Initialisierer

  static
  {
     staticVar1 = 2;
     staticVar2 = staticVar1 * 3;
     KONSTANTE2 = 10;
  }

  public static void main (String[] args)
  {
     System.out.println("\nstaticVar1: " + staticVar1);
     System.out.println("staticVar2: " + staticVar2);
     System.out.println("staticVar3: " + staticVar3);
     System.out.println("staticVar4: " + staticVar4);
     System.out.println("\nKONSTANTE1: " + KONSTANTE1);
     System.out.println("KONSTANTE2: " + KONSTANTE2);
     System.out.println("KONSTANTE3: " + KONSTANTE3);
  }

  static
  {
     staticVar1 = 4;
     staticVar3 = staticVar1 * staticVar2;
     staticVar4 = 50;
     KONSTANTE3 = staticVar4;
  }
}

In den Zeilen 12 bis 17 und Zeilen 30 bis 36 werden mit Hilfe von zwei statischen Initialisierern verschiedene statische Variablen und Konstanten initialisiert. Es ist zu beachten, dass statische Variablen mehrfach mit Werten überschrieben werden können, Konstanten aber nur einmal.

Statische Initialisierer können auch am Ende der Klassendefinition stehen, wie in Zeilen 30 bis 36. Dies ist auch die letzte Möglichkeit Konstanten zu initialisieren. Wurden deklarierte Konstanten nicht bis dahin initialisiert, erfolgt ein Compiler-Fehler.

Starten wir nun die Beispielanwendung. In der unten abgebildeten Kommandozeilenausgabe ist die resultierende Textausgabe dargestellt:

Mit dem folgenden Link gelangt ihr wieder zurück zum Java Programmieren Kurs.

---