AWT-Komponenten in Java: Buttons, Listen und Textfelder

Buttons

Schaltflächen können als Objekte mit dem Operator new erzeugt werden:

Button button = new Button("Button");

Die bei der Erstellung verwendete Zeichenkette wird auf der Schaltfläche angezeigt, sobald sie auf dem Bildschirm erscheint. Diese Zeichenkette wird auch zur Identifizierung zurückgegeben, wenn ein Ereignis der Schaltfläche auftritt.

Button-Ereignisse

Ereignisse eines einfachen Tastendrucks können durch Überschreiben der Methode action() abgefangen werden:

public boolean action(Event evt, Object obj) {
    if (evt.target instanceof Button)
        System.out.println((String) obj);
    else
        System.out.println("Event No-Button");
}

Um zwischen allen vorhandenen Schaltflächen zu unterscheiden, kann das Zielobjekt des Event-Objekts mit den Objekten verglichen werden, die wir in unsere Benutzeroberfläche eingefügt haben:

import java.net.*;
import java.applet.Applet;
import java.awt.*;

public class BotonApplet extends Applet {
    Button b1, b2, b3;

    public void init() {
        b1 = new Button("Button B1");
        b2 = new Button("Button B2");
        b3 = new Button("Button B3");
        this.add(b1);
        this.add(b2);
        this.add(b3);
    }

    public boolean action(Event evt, Object obj) {
        if (evt.target.equals(b1))
            System.out.println("Es wurde der Knopf B1 gedrückt");
        if (evt.target.equals(b2))
            System.out.println("Es wurde die Taste B2 gedrückt");
        if (evt.target.equals(b3))
            System.out.println("Es wird die Taste B3 gedrückt");
        return true;
    }
}

Listen-Buttons (Choice)

Auswahllisten-Buttons (Choice) ermöglichen einen schnellen Zugriff auf eine Liste von Elementen. Beispielsweise könnte man eine Farbauswahl implementieren und diese in einem Choice-Button halten:

import java.net.*;
import java.applet.Applet;
import java.awt.*;

public class BotonSeleccion extends Applet {
    Choice selector;

    public void init() {
        selector = new Choice();
        selector.addItem("Rot");
        selector.addItem("Grün");
        selector.addItem("Blau");
        add(selector);
    }

    public boolean action(Event evt, Object obj) {
        if (evt.target instanceof Choice) {
            String color = (String) obj;
            System.out.println("Die gewählte Farbe ist: " + color);
        }
        return true;
    }
}

Die über die Methode addItem() bereitgestellte Zeichenkette wird als Object-Argument des Choice-Ereignisses zurückgegeben. Im Auswahltreiber wird zunächst überprüft, ob das Ereignis tatsächlich von einer Schaltfläche des Typs Choice ausgelöst wurde.

Auswahl-Buttons (Checkbox)

Checkboxen werden häufig als Status-Buttons verwendet. Sie liefern Ja oder Nein (true / false). Das an das Ereignis übergebene Object-Argument bei Checkbox-Ereignissen ist vom Typ Boolean: wahr (true), wenn das Kästchen ausgewählt ist, und falsch (false) im anderen Fall.

Sowohl die Beschriftung als auch der Zustand können aus dem Ereignisargument zurückgegeben oder über die Methoden getLabel() und getState() des Checkbox-Objekts abgerufen werden.

import java.net.*;
import java.applet.Applet;
import java.awt.*;

public class BotonComprobacion extends Applet {
    Checkbox fill;

    public void init() {
        fill = new Checkbox("Relleno");
        add(fill);
    }

    public boolean action(Event evt, Object obj) {
        if (evt.target instanceof Checkbox)
            System.out.println("CheckBox: " + evt.arg.toString());
        return true;
    }
}

Radio-Buttons (CheckboxGroup)

Checkboxen können zu einer Optionsfeld-Gruppe (CheckboxGroup) zusammengefasst werden. Dies sind Gruppierungen von Checkboxen, bei denen zu jedem Zeitpunkt immer nur genau eine Taste aktiv ist.

import java.net.*;
import java.applet.Applet;
import java.awt.*;

public class BotonRadio extends Applet {
    CheckboxGroup radio;

    public void init() {
        radio = new CheckboxGroup();
        add(new Checkbox("Erster", radio, true));
        add(new Checkbox("Zweiter", radio, false));
        add(new Checkbox("Dritter", radio, false));
    }
}

Integrierte Buttons (Self-Contained)

In dieser Art von Button ist die Ereignisbehandlung innerhalb einer abgeleiteten Klasse des Buttons selbst integriert. Man kann solche Schaltflächen der Anwendung hinzufügen, ohne sich um die Behandlung der Ereignisse kümmern zu müssen.

import java.net.*;
import java.applet.Applet;
import java.awt.*;

class OKButton extends Button {
    public OKButton() {
        setLabel("OK");
    }

    public boolean action(Event evt, Object obj) {
        System.out.println("OK-Button gedrückt");
        return true;
    }
}

public class BotonAuto extends Applet {
    OKButton ok;

    public void init() {
        ok = new OKButton();
        add(ok);
    }
}

Es ist zu beachten, dass keine action()-Methode in der BotonAuto-Applet-Klasse benötigt wird, da die eigene Button-Klasse ihre Ereignisse selbst behandelt. Wären andere Objekte im Applet platziert worden, hätte man eine action()-Methode verwenden können, um die Ereignisse dieser anderen Objekte zu verarbeiten.

Labels (Etiketten)

Etiketten (Label) bieten eine Möglichkeit, statischen Text auf einem Panel zu platzieren, um dem Benutzer unveränderliche Informationen anzuzeigen.

import java.net.*;
import java.applet.Applet;
import java.awt.*;

public class LabelApplet extends Applet {
    public void init() {
        Label etiq1 = new Label("Hallo Java");
        Label etiq2 = new Label("Anderes Etikett");
        setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10));
        add(etiq1);
        add(etiq2);
    }
}

Listen (List)

Listen (List) erscheinen in Benutzeroberflächen, um die Handhabung vieler Elemente durch den Benutzer zu erleichtern. Sie ähneln den Choice-Buttons. Eine Bildlaufleiste wird eingeblendet, wenn nicht alle Elemente der Liste gleichzeitig sichtbar sind.

import java.net.*;
import java.applet.Applet;
import java.awt.*;

public class ListApplet extends Applet {
    public void init() {
        List l = new List(4, false);
        l.addItem("Merkur");
        l.addItem("Venus");
        l.addItem("Erde");
        add(l);
    }

    public boolean action(Event evt, Object obj) {
        if (evt.target instanceof List)
            System.out.println("Listeneingabe von: " + obj);
        return true;
    }
}

Um auf die ausgewählten Elemente zuzugreifen, verwendet man die Methoden getSelectedItem() oder getSelectedItems(). Für Listen mit Einzelauswahl löst ein Doppelklick auf ein Element die action()-Methode auf die gleiche Weise aus wie bei Menüereignissen.

import java.net.*;
import java.applet.Applet;
import java.awt.*;

public class ListaMult extends Applet {
    List lm = new List(6, true);

    public void init() {
        Button button = new Button("Akzeptieren");
        lm.addItem("Merkur");
        lm.addItem("Venus");
        lm.addItem("Erde");
        add(lm);
        add(button);
    }

    public boolean action(Event evt, Object obj) {
        if (evt.target instanceof Button) {
            if ("Akzeptieren".equals(obj)) {
                String[] selection = lm.getSelectedItems();
                for (int i = 0; i < selection.length; i++) {
                    System.out.println(selection[i]);
                }
            }
        }
        return true;
    }
}

Im Fall einer Mehrfachauswahl in einer Liste wird ein externes Ereignis benötigt, um die mit der Liste verknüpften Aktionen auszulösen. Daher haben wir einen Button integriert, dessen Ereignis dafür sorgt, dass das Applet die ausgewählten Elemente aus der Liste sammelt.

Textfelder (TextField)

Textfelder (TextField) können leer mit einer bestimmten Länge, mit vordefiniertem Text oder mit vordefiniertem Text und definierter Spaltenbreite erstellt werden.

import java.net.*;
import java.applet.Applet;
import java.awt.*;

public class AreaTextoSimple extends Applet {
    TextField tf1, tf2, tf3, tf4;

    public void init() {
        // Leeres Textfeld
        tf1 = new TextField();
        // Leeres Textfeld mit 20 Spalten
        tf2 = new TextField(20);
        // Vordefinierter Text
        tf3 = new TextField("Hallo");
        // Vordefinierter Text in 30 Spalten
        tf4 = new TextField("Hallo", 30);
        add(tf1);
        add(tf2);
        add(tf3);
        add(tf4);
    }

    public boolean action(Event evt, Object obj) {
        if (evt.target instanceof TextField) {
            if (evt.target.equals(tf1))
                System.out.println("Textfeld 1: " + evt.arg.toString());
            if (evt.target.equals(tf2))
                System.out.println("Textfeld 2: " + evt.arg.toString());
            if (evt.target.equals(tf3))
                System.out.println("Textfeld 3: " + evt.arg.toString());
            if (evt.target.equals(tf4))
                System.out.println("Textfeld 4: " + evt.arg.toString());
        }
        return true;
    }
}

Wenn ein Benutzer die Eingabetaste (Enter) in einem Textfeld drückt, generiert das TextField ein Ereignis, das wir ähnlich wie bei anderen AWT-Komponenten mit der Methode action() abfangen können.

Textbereiche (TextArea)

Objekte des Typs TextArea werden verwendet, um Text über mehrere Zeilen hinweg darzustellen. Die Präsentation kann sowohl editierbar als auch schreibgeschützt sein. Mit der Methode setEditable() kann gesteuert werden, ob der Benutzer den Text bearbeiten darf, genau wie bei einem TextField.

import java.net.*;
import java.applet.Applet;
import java.awt.*;

public class AreaTexto extends Applet {
    TextArea t1, t2;

    public void init() {
        Button btn = new Button("OK");
        t1 = new TextArea();
        t2 = new TextArea("Java Tutorial", 5, 40);
        t2.setEditable(false);
        add(t1);
        add(t2);
        add(btn);
    }

    public boolean action(Event evt, Object obj) {
        if (evt.target instanceof Button) {
            if ("OK".equals(obj)) {
                String text = t1.getText();
                System.out.println(text);
            }
        }
        return true;
    }
}

Um auf den aktuellen Inhalt eines Textbereichs zuzugreifen, wird die Methode getText() verwendet. Textbereiche generieren in der Regel keine eigenen Aktionen bei Tasteneingaben; daher müssen externe Ereignisse verwendet werden, um zu wissen, wann auf die in der TextArea enthaltenen Informationen zugegriffen werden soll. In unserem Fall haben wir eine Schaltfläche, die beim Klicken ein Ereignis auslöst, welches den Inhalt des im Applet eingebetteten Textbereichs ausliest.