6.5 Statische Methoden und Variablen

Exemplarvariablen sind eng mit ihrem Objekt verbunden.¹Wird ein Objekt geschaffen, erhält es einen eigenen Satz von Exemplarvariablen, die zusammen den Zustand des Objekts repräsentieren. Ändert eine Objektmethode den Wert einer Exemplarvariablen in einem Objekt, so hat dies keine Auswirkungen auf die Daten der anderen Objekte; jedes Objekt speichert eine individuelle Belegung. Es gibt jedoch auch Situationen, in denen Eigenschaften oder Methoden nicht direkt einem individuellen Objekt zugeordnet werden. Dazu gehören zum Beispiel die Methoden:

sin(), etwa in Math.sin(Math.PI/2.0)

max(), etwa in Math.max(1, -2)

Color.HSBtoRGB(), zum Konvertieren von Farben in Farbräumen

Integer.parseInt(), Umwandeln von einem String in den Integer oder in Variablen, die sogar konstant sein können

MAX_INTEGER, die größte darstellbare Zahl

PI aus Math bestimmt die Zahl 3,1415 ...

Hier klicken, um das Bild zu Vergrößern

Diese genannten Eigenschaften sind weniger einem konkreten Objekt mit seinem ureigenen Objektzustand zuzuordnen, als vielmehr der Klasse. Diese Art von Zugehörigkeit wird in Java durch statische Eigenschaften unterstützt. Da sie nicht zu einem Objekt gehören wie Objekteigenschaften, nennen wir sie auch Klasseneigenschaften. Die Sinus-Funktion ist ein Beispiel für eine statische Methode der Mathe-Klasse und MAX_INTEGER ein statisches Attribut der Klasse Integer.

6.5.1 Warum statische Eigenschaften sinnvoll sind

Statische Eigenschaften haben gegenüber Objekteigenschaften den Vorteil, dass sie im Programm ausdrücken, keinen Zustand vom Objekt zu nutzen. Betrachten wir noch einmal Funktionen aus der Mathe-Klasse. Wenn sie Objektmethoden wären, so würden sie in der Regel mit einem Objektzustand arbeiten. Die Funktionen nähmen dann keinen Parameter, sondern arbeiteten mit dem internen Zustand des aufrufenden Objekts. Das macht aber keine Mathe-Funktion. Um den Sinus eines Winkels zu berechnen, benötigen wir kein spezifisches Mathe-Objekt. Statische Funktionen sind aus diesem Grunde häufiger als statische Variablen, da sie ihre Arbeitswerte ausschließlich aus den Parametern ziehen. Statische Variablen werden in erster Linie als Konstanten verwendet.

6.5.2 Statische Eigenschaften mit static

Um statische Eigenschaften in Java umzusetzen, fügen wir vor der Definition einer Variablen oder einer Methode das Schlüsselwort static hinzu. Für den Zugriff verwenden wir einfach den Klassennamen, den wir wie eine Referenz verwenden. In der UML können statische Eigenschaften durch Unterstreichen markiert werden.

public class DiskoUtensilien
{
  /**
   * Platz, die jede Person benötigt.
   */
  public final static double PLATZ_PRO_PERSON = 5 /* Quadratmeter */;
  
  /**
   * Platz, die eine gegebene Anzahl Personen in einer Disko benötigen.
   * 
   * @param anzahl  Anzahl Personen.
   * @return        Quadratmeter.
   */
  public static double platzFuerPersonen( int anzahl )
  {
    return anzahl * PLATZ_PRO_PERSON;
  }
}

System.out.println( DiskoUtensilien.platzFuerPersonen(290) );

6.5.3 Statische Eigenschaften als Objekteigenschaften nutzen

Besitzt eine Klasse eine Klasseneigenschaft, so kann sie auch wie ein Objektattribut über die Referenz angesprochen werden. Das bedeutet, dass es zwei Möglichkeiten gibt, wenn ein Objektexemplar existiert und die Klasse ein statisches Attribut hat. Bleiben wir bei unserem obigen Beispiel mit der Klasse DiskoUtensilien. Jetzt können wir für den Zugriff auf PLATZ_PRO_PERSON schreiben:

DiskoMitStatics d = new DiskoUtensilien();
System.out.println( d.PLATZ_PRO_PERSON );               // keine gute Idee
System.out.println( DiskoUtensilien.PLATZ_PRO_PERSON ); // das ist gut so

Die unteren beiden Anweisungen sind identisch. Betrachten wir alleine dieses Codesegment, so ist für uns nicht sichtbar, dass PLATZ_PRO_PERSON eine statische Variable ist. Aus diesem Grund sei der Tipp gegeben, statische Eigenschaften über ihren Klassennamen anzusprechen. Falls eine Klasse nur statische Attribute definiert, so spricht nichts dagegen einen privaten Konstruktor anzugeben - Exemplare werden damit vermieden.

6.5.4 Statische Eigenschaften und Objekteigenschaften

Wie wir oben gesehen haben, können wir über eine Objektreferenz auch statische Eigenschaften nutzen. Wir wollen uns aber noch einmal vergewissern, wie Objekteigenschaften und statische Eigenschaften gemischt werden können. Erinnern wir uns daran, dass unsere ersten Programme aus der main()-Methode bestanden, aber unsere anderen Methoden auch static sein mussten. Dies ist sinnvoll, denn eine statische Methode kann - ohne explizite Angabe eines aufrufenden Objekts - nur andere statische Methoden aufrufen. Wie sollte auch eine statische Methode eine Objektmethode aufrufen können, wenn es kein dazugehöriges Objekt gibt? Statische Methoden gibt es immer, wenn es die Klasse gibt. Andersherum kann aber jede Objektmethode eine beliebige statische Methode direkt aufrufen. Genauso verhält es sich mit Attributen. Eine statische Methode kann keine Objektattribute nutzen, da es kein implizites Objekt gibt, auf dessen Eigenschaften zugegriffen werden könnte.

this-Referenzen und statische Eigenschaften

Auch der Einsatz der this-Referenz ist bei statischen Eigenschaften nicht möglich. Das trifft in erster Linie statische Methoden, die eine this-Referenz verwenden wollen.

class InStaticNoThis
{
  int a;
  static void martina()
  {
    this.a = 1;           // Compilerfehler genauso wie a = 1
  }
}

6.5.5 Statische Variablen zum Datenaustausch

Der Wert einer statischen Variablen wird bei dem Klassenobjekt gespeichert und nicht bei einem Exemplar der Klasse. Wie wir aber gesehen haben, kann jedes Exemplar einer Klasse auch auf die statischen Variablen der Klasse zugreifen. Da eine statische Variable aber nur einmal pro Klasse vorliegt, führt dies dazu, dass mehrere Objekte sich eine Variable teilen. Somit wird ein Austausch von Informationen über die Objektgrenze hinaus erlaubt. Doch kein Vorteil ohne Nachteil. Es kann bei nebenläufigen Zugriffen zu Problemen kommen. Deshalb müssen wir spezielle Synchronisationsmechanismen nutzen.

Hier klicken, um das Bild zu Vergrößern

class ShareData
{
  private static int share;
  public void memorize( int i )
  {
    share = i;
  }
  public int retrieve ()
  {
    return share;
  }
  public static void main( String args[] )
  {
    ShareData s1 = new ShareData();
    ShareData s2 = new ShareData();
    s1.memorize( 2 );
    System.out.println( s2.retrieve() );    // ist 2
  }
}

6.5.6 Warum die Groß- und Kleinschreibung wichtig ist

Die Vorgabe der Namenskonvention sagt, Klassennamen sind mit Großbuchstaben zu vergeben und Variablennamen mit Kleinbuchstaben. Treffen wir auf eine Anweisung wie Math.max(a, b), so wissen wir sofort, dass max() eine statische Methode sein muss, weil davor ein Bezeichner steht, der großgeschrieben ist. Dieser kennzeichnet also keine Referenz, sondern einen Klassennamen. Daher sollten wir in unseren Programmen großgeschriebene Objektnamen meiden.

String StringModifier = "What is the Matrix?";
String t = StringModifier.trim();

class turnbeutel
{
  static void vergessen() { ... }
}

6.5.7 Konstanten mit dem Schlüsselwort final bei Variablen

In Programmen gibt es Variablen, die sich ändern, wie ein Schleifenzähler, aber auch andere, die sich beim Ablauf eines Programms nicht ändern. Dazu gehören etwa die Anzahl Buchstaben in ›Nichts als die Wahrheit‹ - zumindest in der ersten Ausgabe - oder die Ausmaße einer DIN-A4-Seite². Die Werte sollten nicht wiederholt im Quellcode stehen, sondern über ihren Namen angesprochen werden. Dazu werden Variablen definiert, denen genau der konstante Wert zugewiesen wird; die Konstanten heißen dann symbolische Konstanten.

Statische Variablen werden auch verwendet, um symbolische Konstanten zu definieren. Damit die Variablen unveränderlich blieben, gesellt sich zusätzlich der Modifizier final dazu. Dem Compiler wird auf diese Weise mitgeteilt, dass dieser Variablen nur einmal ein Wert zugewiesen werden darf. Für Variablen bedeutet dies: Es sind Konstanten, jeder spätere Schreibzugriff wäre ein Fehler.

Listing 6.12 Genre.java

public class Genre
{
  public final static int CHRISTIAN_GANGSTA_RAP  = 0;
  public final static int COUNTRY                = 1;
  public final static int GANGSTA                = 2;
  public final static int JUNGLE                 = 3;
  public final static int JPOP                   = 4;
  public final static int GOTHIC_TECHNO          = 5;
  public final static int POLKA                  = 6;
  public final static int PSYCHEDELIC_CLASSIC    = 7;
  public final static int TECHNO                 = PSYCHEDELIC_CLASSIC + 1;
}

In der Klasse Genre werden mehrere Konstanten definiert. Für Konstanten ist es günstig, sie relativ zum Vorgänger zu wählen, um das Einfügen in der Mitte zu vereinfachen. Das sehen wir bei der letzen Variable TECHO. Da im Quellcode das vorkommen der Zahlen 2, 4, 5 undurchsichtig wäre, sind symbolische Namen zwingend. Stehen dennoch Zahlen ohne öffentliche Bedeutung im Quellcode, so werden sie magische Zahlen (engl. magic numbers) genannt.

Hier klicken, um das Bild zu Vergrößern

Abbildung 6.5 Die Genre-Klasse in einer alternativen ‚Eclipse-Darstellung'

Eine in der Sprache Java verankerte Möglichkeit zur Definition von Konstanten wird es in Java 1.5 mit enum geben.

6.5.8 Problem mit finalen Klassenvariablen

Finale Klassenvariablen können in der Entwicklung mit einer größeren Anzahl von Klassen zu einem Problem werden. Das liegt an der Eigenschaft der finalen Werte, dass sie sich nicht ändern können und sich daher sicher an der Stelle einsetzen lassen, wo sich gebraucht werden. Ein Beispiel:

class Finanz
{
  public final static int MWST = 16;
}

Greift eine andere Klasse auf die Variable MWST zu, so ist das im Quellcode nicht als direkter Variablenzugriff Finanz.MWST kodiert, sondern das Literal 16 wird direkt an der Aufrufstelle eingesetzt. Das ist eine Optimierung des Compilers, die er laut Java-Definition machen kann.

Das ist zwar nett, bringt aber gewaltige Probleme mit sich, etwa dann, wenn sich die Konstante einmal ändert. Dann muss nämlich auch jede Klasse übersetzt werden, die Bezug auf die Konstante hatte. Falls die abhängigen Klassen nicht neu übersetzt würden, würden sie mit dem alten eincompilierten Wert arbeiten.

Die Lösung ist, die bezugnehmenden Klassen neu zu übersetzen und sich am Besten anzugewöhnen, bei einer Änderung einer Konstante gleich alles neu zu compilieren. Ein anderer Weg transformiert die finale Variable in eine später initialisierte Form:

class Finanz
{
  public final static int MWST = new Integer( 16 ).intValue();
}

Die Initialisierung findet in jedem Konstruktor statt und die Konstante mit dem Literal ist erst einmal weg. Der Compiler wird also Finanz.MWST nicht als 16 vorfinden und daher das Literal an den Aufrufstellen nicht einbauen. In der Klassendatei wird der Bezug Finanz.MWST weiterhin zu finden sein, und eine Änderung der Konstante ist für alle Nutzer deutlich.

6.5.9 Typsicherere Konstanten

Konstanten sind eine wertvolle Möglichkeit, den Quellcode aussagekräftiger zu machen. Der herkömmliche Weg geht über Ganzzahl-Konstanten:

public final int KONSTANTE1 = 0;
public final int KONSTANTE2 = 1;
public final int KONSTANTE3 = 2;

Dieser Weg bringt den Nachteil mit sich, dass die Konstanten nicht unbedingt von jedem angewendet werden müssen und ein Programmierer eventuell direkt die Zahlen oder Zeichenketten einsetzt. Dieses Problem kommt zum Beispiel auf, wenn ein Font-Objekt für die grafische Oberfläche angelegt werden soll, aber unser Gedächtnis versagt, in welcher Reihenfolge die Parameter einzugeben sind. Ein Fallbeispiel:

Font f = new Font( "Dialog",  12, Font.BOLD );

Leider ist dieses falsch, denn die Parameter für die Zeichensatzgröße und den Schriftstil sind vertauscht. Das Problem ist, dass die Konstanten nur Namen für Werte eines frei zugänglichen Grundtyps sind, und nur der Wert an die Funktion übergeben wird. Niemand kann verbieten, dass direkt die Werte eingetragen werden. Das führt dann zu Fehlern, wie im oberen Fall. In diesem ist 12 die Ganzzahl für den Schriftstil, obwohl es dafür nur die Werte 0, 1, 2 geben sollte. Mit Zeichenketten als Wert der Konstanten kommen wir der Lösung auch nicht näher.

Eine gute Möglichkeit, von Ganzzahlen wegzukommen, ist, Objekte einer Klasse als Konstanten einzusetzen. Folgendes bietet sich an:

Listing 6.13 TypsicherGenre.java

public final class TypsicherGenre
{
  public static final TypsicherGenre COUNTRY = new TypsicherGenre();
  public static final TypsicherGenre TECHNO  = new TypsicherGenre();
  private int id;
  private static int nextId;
  private TypsicherGenre()  // von aussen lassen sich keine weiteren
  {                         // Objekte erzeugen
    id = nextId++;
  }
}

Die Klasse TypsicherGenre definiert die Konstanten als statische Attribute vom Typ TypsicherGenre. Da die Objekte für die Konstanten aber nur einmal vorliegen, lassen sie sich einfach mit ==, wie im folgenden Beispiel mit func() gezeigt, vergleichen.

Hier klicken, um das Bild zu Vergrößern

Listing 6.14 TypsicherGenre.java

public class TypsichereKonstantenDemo
{
  static void func( TypsicherGenre k )
  {
    if ( k == TypsicherGenre.COUNTRY )
      System.out.println( "GEKRINGELT" );
    if ( k == TypsicherGenre.TECHNO )
      System.out.println( "GESTRICHELT" );
  }
  
  public static void main( String args[] )
  {
    func( TypsicherGenre.TECHNO );
  }
}

6.5.10 Statische Blöcke

Eine Art Konstruktor für das Klassenobjekt selbst (nicht die Exemplare der Klasse) ist ein static-Block, der in jede Klasse gesetzt werden kann. Der Block wird genau dann ausgeführt, wenn die Klasse vom Klassenlader in die virtuelle Maschine geladen wird. In der Regel geschieht das nur einmal während eines Programmlaufs. Unter gewissen Umständen - ein eigener Klassenlader für die Klasse - kann jedoch eine Klasse auch aus dem Speicher entfernt werden und dann mit einem anderen Klassenlader wieder neu geladen werden.

class StaticBlock
{
  static
  {
    System.out.println( "Eins" );
  }

  static
  {
    System.out.println( "Zwei" );
  }

  public static void main( String args[] )
  {
    System.out.println( "Jetzt geht's los." );
  }
}

Lädt der Klassenlader die Klasse StaticBlock, so führt er zuerst den ersten Block mit der Ausgabe »Eins« aus und dann den Block mit der Ausgabe »Zwei«. Da die Klasse StaticBlock auch das main() besitzt, führt die virtuelle Maschine anschließend die Start-Funktion aus.

class StaticNowMain
{
  static
  {
    System.out.println( "Jetzt bin ich das Hauptprogramm" );
    System.exit( 0 );
  }
}

¹ Das Symbol beziehungsweise diese Sichtbarkeit ist erst seit der UML-Spezifikation 1.4 definiert.

² Ein DIN-A4-Blatt ist 29.7 Zentimeter hoch und 21.0 Zentimeter breit.