Ergänzende Abschnitte zum Kapitel 5

Informatoren für Standardklassen

In der Übung 4.13 kamen die Klassen Choice und TextField des Pakets java.awt vor. In diese Datenbehälter kann der Anwender zur Laufzeit Daten eingeben. Diese können mit Hilfe der Informatoren getSelectedItem bzw. getText gelesen und z.B. in einem Label-Objekt dargestellt werden.

Jetzt können wir auch schon die fortschrittlichere Alternative für die awt-Klassen aus dem Paket javax.swing verwenden. Diese können nicht mit add einem java.applet.Applet-Fenster hinzugefügt werden, sondern der sog. „Inhaltsschicht“ eines javax.swing.JApplet-Fensters, die der Informator getContentPane liefert:

import javax.swing.*; // JApplet, JComboBox, JTextField, JLabel 
import static java.awt.BorderLayout.*; // NORTH, CENTER, EAST, SOUTH
public class Ergebnisse extends JApplet {
  private JComboBox auswahl; // Alternative zu java.awt.Choice
  private JTextField textfeld; // Alternative zu java.awt.TextField
  private JLabel auswahlErgebnis, textErgebnis; // Alternative zu java.awt.Label
  public void init() {
   auswahl = new JComboBox();
   auswahl.addItem ("Rot");
   auswahl.addItem("Grün");
   auswahl.addItem("Blau");
   getContentPane().add(NORTH, auswahl);
   textfeld = new JTextField("Bitte Textzeile eingeben");
   getContentPane().add(CENTER, textfeld);
   auswahlErgebnis = new JLabel();
   getContentPane().add(EAST, auswahlErgebnis);
   textErgebnis = new JLabel();
   getContentPane().add(SOUTH, textErgebnis);
  }

  public void paint(java.awt.Graphics grafik) {
   auswahlErgebnis.setText ((String)auswahl.getSelectedItem ());
     // Konvertierung nach String nötig, weil getSelectedItem ein Object liefert
   textErgebnis.setText(textfeld.getText());
   repaint();
  }
}

Abb.: Ergebnisse

Damit das Fenster nach der Veränderung der JLabel-Objekte (mit setText) mit dem neuen Inhalt dargestellt wird, ist es nötig, in der paint-Methode repaint aufzurufen; diese bewirkt, dass der Interpreter paint wieder aufruft, ohne dass das Fenster „von außen“ angefasst worden wäre.

Der hier dargestellte Weg, die paint-Methode von JApplet zu überschreiben, ist allgemein nicht zu empfehlen. Die Oberflächenobjekte sollen nicht dem Inhaltschicht des Applets hinzugefügt werden, sondern einem JPanel-Objekt, dessen paintComponent-Methode überschrieben werden soll. Eine noch bessere Vorgehensweise ist, wo Lauscher für die Oberflächenobjekte (wie die Auswahlliste und das Textfeld) vorgestellt werden.

In diesem Programm haben wir das ab Version 5 zur Verfügung stehende Sprachelement import static verwendet: Wir haben mit seiner Hilfe nicht eine Klasse importiert (und damit den Paketnamen vor ihrem Namen erspart), sondern die Klassenkomponenten (die static-Variablen) dieser Klasse: NORTH, CENTER, EAST und SOUTH. Ohne diesen Import hätten wir vor jeder Verwendung dieser Werte den Klassennamen BorderLayout hinschreiben müssen.

Beans

Beans ist die Bezeichnung für standardisierte Klassen, bei deren Entwurf bestimmte Konventionen eingehalten wurden. Diese sind Namenskonventionen für Datenkomponenten und die dazugehörigen Operationen. Hierzu gehören auch Namen von Ereignissen und der Ereignisbehandlungsmethoden. Zweck der Standardisierung ist es, Klassen ohne weitere Programmiertätigkeit zu Programmen (oder Programmteilen) zusammenzufügen, und zwar mit Hilfe grafischer Werkzeugen: Der Programmtext, in dem die Beans ausgeprägt und ihre Methoden aufgerufen werden, ist aufgrund der Standardisierung automatisch generierbar.

Beans sind also „normale“ Java-Klassen, die wie üblich benutzt, aber auch mit grafischen Werkzeugen visuell dargestellt und bearbeitet werden können. Es gibt auch keine spezielle Oberklasse Bean, die alle erweitern müssten. Sie folgen nur ganz oder teilweise den Konventionen und können in ihren konventionsgemäßen Anteilen mit Bean-Werkzeugen bearbeitet werden.

Die konventionsgemäßen Datenkomponenten von Beans werden als Eigenschaften (properties) der Klasse bezeichnet. Wenn z.B. groesse eine Eigenschaft ist, dann besteht die Konvention darin, dass die Klasse einen Mutator setGroesse und einen Informator getGroesse exportiert. Für Eigenschaften vom Typ boolean würde der Informator isGroesse heißen. Mit Hilfe dieser Methoden können die Eigenschaften eines Beans (z.B. die Hintergrundfarbe eines Fensters oder die Beschriftung eines Knopfes) durch Bean-Werkzeuge bei der Programmierung vorbesetzt und zur Laufzeit (ggf. vom Bediener) verändert werden.

Als Bean-Werkzeug wird von der Firma Sun zusammen mit sdk die Entwicklungsumgebung BDK (Beans Developement Kit) für die Bearbeitung von Beans zur Verfügung gestellt. Sie enthält das Programm BeanBox. Dieses Bean-Werkzeug benutzt Beschreibungsdateien (manifest file ), in der zusätzliche Informationen zur Bean-Klasse gespeichert werden. Typischerweise befindet sich die Quelltextdatei der Klasse zusammen mit der Beschreibungsdatei in einem Archiv (jar-Datei).

Beans müssen persistent sein d.h. die Objekte von Bean-Klassen zur Laufzeit gespeichert und später ihr Zustand wiederhergestellt werden können. Dazu müssen Bean-Klassen die Schnittstelle java.io.Serializable implementieren.

Die meisten awt- und swing-Klassen sind Beans, d.h. sie gehorchen den Bean-Konventionen. Wenn eine Klasse von ihnen erbt, muss sie nur für die neuen Komponenten den Bean-Konventionen folgen, um mit einem Bean-Werkzeug bearbeitet werden zu können. Beispielsweise ist die folgende einfache Klasse ein Bean:

import java.awt.Color 
public class EinfachesBean extends java.awt.Canvas implements java.io.Serializable {
   public EinfachesBean() {
      super(); // geerbte Eigenschaften werden gesetzt
      setSize (100,50); setBackground (Color.blue);
   }

   private Color farbe = Color.red; // neue Eigenschaft
   public Color getFarbe() { return farbe; } // Informator 
   public void setFarbe(Color neueFarbe) { farbe = neueFarbe; repaint (); } // Mutator
   public void paint(java.awt.Graphics grafik) { // Benutzung der Eigenschaft
      grafik.setColor(farbe); grafik.fillRect (20, 5, 20, 30); 
   }
}

Diese Klasse erbt die Eigenschaften background, foreground, name und font von der Oberklasse java.awt.Canvas, und definiert selber eine neue Eigenschaft farbe. Alle Eigenschaften können in einem Bean-Werkzeug bearbeitet werden:

Abb. Hauptfenster und Eigenschaftseditor von BeanBox (aus bdk 1.1)

Weil die Eigenschaften dieser Klasse (so auch farbe) den Bean-Konventionen genügen, können sie vom BeanBox-Eigenschaftseditor manipuliert werden: Mit Hilfe eines Mausklicks auf das Feld farbe kann die voreingestellte Eigenschaft (Color.red) auf einen beliebigen anderen Wert verändert werden.

Ähnlich können andere Eigenschaften eines Beans, insbesondere die Reaktionen auf Ereignisse visuell manipuliert werden.

Ein gutes Bean-Werkzeug wie die BeanBox von bdk ermöglicht auch die Spurverfolgung (Testen) von Beans; dies ist deswegen günstig, weil andere Testwerkzeuge die Bean-Eigenschaften nicht ausnutzen.

Eine weitere Automatisierung von Beans wird durch folgenden Mechanismus ermöglicht: Datenkomponenten und Methoden einer Klasse können zur Laufzeit ermittelt werden. Bean-Werkzeuge nutzen ihn und nennen ihn Einsicht (introspection). Hierzu bietet die Klasse java.beans.Introspector geeignete Methoden.

Für Klassen, die sich bei der Benennung von Methoden nicht an den Bean-Konventionen halten, gibt es die Möglichkeit, ihre Eigenschaften in einer Klasse zu beschreiben, die die Schnittstelle java.beans.BeanInfo implementiert. Dann lässt sich diese Klasse ebenfalls mit Bean-Werkzeugen bearbeiten.