• Initialisierung anonymer Klassen
• Anonyme Implementierung von Interfaces

Anonyme Klassen sind ein Spezialfall der lokalen Klassen. Sie haben keinen Namen und werden stets im Argument einer new-Anweisung definiert. Sie dienen dazu, kleine »Einmal«-Objekte mit einfachen Aufgaben zu definieren, beispielsweise für Callbacks bei der Oberflächenprogrammierung.

Anonyme Klassen bieten sich besonders für die Erstellung von Adapter-Klassen für Oberflächenkomponenten an, weil oft nur wenige Aktionen beim Eintritt eines Ereignisses auszuführen sind. Ein Klassenname würde hier die Lesbarkeit des Codes nicht verbessern. Anonyme Klassen sollten aber auch in diesem Anwendungsgebiet nur eingesetzt werden, wenn die Implementierung kurz und einfach ist. Wenn die Implementierung mehr als fünf bis sechs Anweisungen hat oder nicht intuitiv zu verstehen ist, solllte besser eine lokale Klasse verwendet werden.

Zur Deklaration von anonymen Klassen wurde die Syntax der new-Anweisung so erweitert, dass hinter dem Klassenbezeichner und der Argumentliste noch ein Klassenrumpf angegeben werden kann. Im Gegensatz zu den anderen Arten von Klassen werden anonyme Klassen in einem Ausdruck und nicht in einer Anweisung definiert. Sie können daher in Zuweisungen oder auch als aktueller Methodenparameter angegeben werden. In Zuweisungen muss die Definition einer anonymen Klasse mit einem Semikolon hinter der schließenden Klammer (}) abgeschlossen werden. Das Objekt, das ein Exemplar einer anonymen Klasse erzeugt, wird zum umschließenden Exemplar des erzeugten Objekts.

Das folgende Beispiel zeigt eine anonyme Unterklasse von WindowAdapter. Eine Animation, die in einem Frame läuft, wird beim »Ikonifizieren« angehalten und beim »Deikonifizieren« wieder gestartet. Hierzu werden die beiden entsprechenden Methoden überschrieben, und die anderen von WindowAdapter geerbten, leer implementierten Methoden werden belassen.

  Frame frame = new Frame();
  frame.addWindowListener(new WindowAdapter() {
    public void windowIconified(WindowEvent e) {
      animator.stop();
    }

    public void windowDeiconified(WindowEvent e) {
      animator.start();
    }
  });

Initialisierung anonymer Klassen

Anonyme Klassen sind gegenüber den anderen Arten von Klassen dahingehend eingeschränkt, dass sie keine Konstruktoren definieren können. Daher muss man auf Exemplar-Initialisierungen zurückgreifen, wenn man Aktionen zum Zeitpunkt der Erzeugung durchführen will. Es ist aber möglich, einen Parameter-behafteten Konstruktor der Oberklasse aufzurufen. In diesem Beispiel wird ein Button erzeugt, dessen Hintergrundfarbe in einer Exemplar-Initialisierung auf Blau gesetzt wird:

  // Aufruf eines Konstruktors mit Parameter
  blueButton = new Button("OK") {
    // Exemplar-Initialisierung
    { setBackground(Color.blue); }
  // abschließendes Semikolon!
  };

Anonyme Implementierung von Interfaces

Die Syntax der anonymen Klassen gestattet es auch, anonyme Implementierungen von Interfaces zu erzeugen. Hierzu wird wie bei einem Konstruktor der Name des Interface im Argument der new-Anweisung angegeben:

  interface MyInterface {
    public void test();
  }
  
  public class AnonIntDemo {
      ...
      MyInterface myInterface;
  
      myInterface = new MyInterface() {
        public void test() {
        ...
        }
      };
      ...
  }

Die Angabe des bei Interface-Implementierungen sonst üblichen Schlüsselworts implements ist bei anonymen Interface-Implementierungen nicht erlaubt. Weiterhin muss die Parameterliste hinter dem Namen des Interface immer leer sein, da Interfaces keine Konstruktoren haben.

Das Interface ActionListener wird bei der Oberflächenprogrammierung häufig anonym implementiert, da es nur eine Methode besitzt. Mit diesem Interface kann sich ein Objekt bei einem Button registrieren, um einen Callback zu erhalten, wenn der Button gedrückt wird.

Das folgende Beispiel zeigt anonyme Implementierungen von ActionListener und TextListener bei einem Editierfeld, das aus einem Textfeld und einem Button zum Speichern besteht. Wenn der Button gedrückt wird, sperrt er sich selbst und speichert den Text. Bei einer Änderung des Textes wird der Button wieder aktiviert:

  saveButton = new Button("Speichern");
  saveButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      // Button deaktivieren und Text speichern
      saveButton.setEnabled(false);
      saveText();
    }
  });
  ...
  TextArea textArea = new TextArea();
  textArea.addTextListener(new TextListener () {
    public void textValueChanged(TextEvent e) {
      // Bei Änderung des Textes Button aktivieren
      saveButton.setEnabled(true);
    }
  });

Material zum Beispiel

• Applet starten
• Quelltexte:
  • AnonEdit.java