Zielsetzung
Bisher haben die meisten von Ihnen das ganze Projekt in einem Konsolenfenster ablaufen lassen. In diesem zweiten Teil der Folge 11 soll Ihnen gezeigt werden, wie man das Projekt als "richtige" Java-Anwendung implementiert. Übungen sind in diesem zweiten Teil nicht vorgesehen, weil das Programmieren von Java-Anwendungen nicht zum Kernlehrplan des Landes NRW gehört. Engagierte Schüler und Schülerinnen sollten sich diesen Teil der Folge 11 aber trotzdem ansehen.
Java-Anwendungen haben Sie zum ersten Mal in der Folge 5 kennengelernt. Dort steht auch eine Beispiel-Anwendung mit Buttons und Textfeldern zur Verfügung. Buttons und Textfelder werden Sie auch in diesem Teil der Folge 11 benötigen.
Schritt 1 - Die Java-Anwendung
Hier zunächst der komplette und lauffähige Quelltext der Anwendung. Bei manchen Windows-Rechnern kommt es aber zu Graphikfehlern, allerdings nicht reproduzierbar. Unter MacOS läuft das Programm ohne Fehler.
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class TestAnwendung extends JFrame implements ActionListener
{
Vokabelliste liste;
TextField eingabe, ausgabe;
Button ok;
public TestAnwendung()
{
liste = new Vokabelliste();
setSize(400,300);
setTitle("Test fuer die Klasse Vokabel");
setResizable(false);
setVisible(true);
initComponents();
init();
}
public void initComponents()
{
eingabe = new TextField();
ausgabe = new TextField();
ok = new Button("Uebersetzen");
setLayout(null);
eingabe.setBounds(20, 70,300,40);
ausgabe.setBounds(20,120,300,40);
ok.setBounds(20,170,300,40);
eingabe.setBackground(new Color(255,255,220));
ausgabe.setBackground(new Color(220,255,255));
eingabe.setFont(new Font("Arial",1,18));
ausgabe.setFont(new Font("Arial",1,18));
ok.setFont(new Font("Arial",1,18));
ok.addActionListener(this);
add(eingabe);
add(ausgabe);
add(ok);
}
public void init()
{
liste.hinzufuegen("Hund" ,"dog");
liste.hinzufuegen("Katze" ,"cat");
liste.hinzufuegen("Schwein","pig");
liste.hinzufuegen("Kuh" ,"cow");
liste.hinzufuegen("Adler" ,"eagle");
liste.hinzufuegen("Spatz" ,"sparrow");
liste.hinzufuegen("Igel" ,"hedgehog");
liste.hinzufuegen("Zebra" ,"zebra");
liste.hinzufuegen("Loewe" ,"lion");
liste.hinzufuegen("Tiger" ,"tiger");
liste.hinzufuegen("Ratte" ,"rat");
liste.hinzufuegen("Falke" ,"falcon");
}
public void actionPerformed(ActionEvent event)
{
if (event.getSource() == ok)
{
ausgabe.setText(liste.english(eingabe.getText()));
}
}
public static void main(String[] args)
{
new TestAnwendung();
}
}
Und so sieht die fertige Anwendung aus, nachdem eine Vokabel ins Englische übersetzt worden ist:
Die Anwendung unter MacOS Monterey (12.5)
Autor: Ulrich Helmich 2022, Lizenz: siehe Seitenende
Gehen wir den Quelltext Schritt für Schritt durch.
Importe und Attribute
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class TestAnwendung extends JFrame implements ActionListener
{
Vokabelliste liste;
TextField eingabe, ausgabe;
Button ok;
Da Buttons und Textfelder benötigt werden, müssen zunächst einige Bibliotheken importiert werden, und die Klasse TestAnwendung darf nicht nur JFrame beerben, sondern muss auch einen ActionListener implementieren, damit die Buttons abgefragt werden können.
Das Attribut liste stellt ein Objekt der Klasse Vokabelliste zur Verfügung, die Attribute eingabe und ausgabe sind für die beiden Textfelder verantwortlich, und das Attribut ok stellt den einzigen Button der Anwendung dar.
Konstruktor
Schauen wir uns nun den Konstruktor der Anwendung an:
public TestAnwendung()
{
liste = new Vokabelliste();
setSize(400,300);
setTitle("Test fuer die Klasse Vokabel");
setResizable(false);
setVisible(true);
initComponents();
init();
}
Zunächst wird das Vokabellisten-Objekt liste initialisiert, indem der Konstruktor der Klasse Vokabelliste aufgerufen wird. Parameter sind dafür nicht erforderlich.
Mit setSize() wird die Größe des zu erzeugenden Programmfensters auf 400 x 300 Pixel festgelegt. Das reicht für die kleine Anwendung völlig aus.
Der Befehl setTitle() legt den Titel des Fensters fest, mit setResizable() und dem Parameter false wird verhindert, dass der Benutzer die Größe des Fensters verändern kann, und mit setVisible() und dem Parameter true wird dafür gesorgt, dass das erzeugte Fenster überhaupt sichtbar ist. Der Befehl initComponents() ruft eine selbst geschriebene Methode auf, welche dafür sorgt, dass die Komponenten der Anwendung initialisiert werden, also der Button und die beiden Textfelder. Auch init ruft eine selbst geschriebene Methode auf, die für weitere Initialisierungen wichtig ist. Natürlich hätte man die in den beiden Methoden initComponents() und init() stehenden Quelltextzeilen auch direkt in den Konstruktor einbauen können, dann wäre dieser aber unübersichtlich geworden.
initComponents
public void initComponents()
{
eingabe = new TextField();
ausgabe = new TextField();
ok = new Button("Uebersetzen");
setLayout(null);
eingabe.setBounds(20, 70,300,40);
ausgabe.setBounds(20,120,300,40);
ok.setBounds(20,170,300,40);
eingabe.setBackground(new Color(255,255,220));
ausgabe.setBackground(new Color(220,255,255));
eingabe.setFont(new Font("Arial",1,18));
ausgabe.setFont(new Font("Arial",1,18));
ok.setFont(new Font("Arial",1,18));
ok.addActionListener(this);
add(eingabe);
add(ausgabe);
add(ok);
}
Die ersten drei Zeilen erzeugen zwei Textfelder und einen Button.
Dann wird mit setLayout() und dem Parameter null dafür gesorgt, dass diese Komponenten pixelgenau positioniert werden können.
Die setBounds()-Befehle legen dann die Positionen der drei Komponenten pixelgenau fest. Die beiden ersten Parameter geben die Position der linken oberen Ecke der Komponente an, die beiden anderen Parameter stehen für die Breite und die Höhe der Komponente.
Der Befehl setBackground() sorgt für eine schöne Hintergrundfarbe bei den Textboxen.
Mit setFont() kann man dafür sorgen, dass die Eingaben der Textfelder in einer bestimmten Schriftart erscheinen.
Jetzt kommt ein ganz wichtiger Befehl, denn man im Eifer des Gefechts machmal vergisst und sich dann wundert, warum die Anwendung nicht auf Benutzereingaben reagiert. Mit addActionListener() wird der Button mit dem ActionListener verbunden. Nur so kann der Button überhaupt reagieren, wenn man ihn anklickt.
Die drei add()-Befehle am Ende sorgen schließlich dafür, dass die drei hier definierten Komponenten in die Komponentenliste der Anwendung aufgenommen werden. Vergisst man die add-Befehle, weiß die Java-Anwendung gar nicht, dass sie diese Komponenten besitzt.
Init
Diese Methode wurde aus der Konsolen-Version übernommen. Sie sorgt dafür, dass die Vokabelliste mit Inhalt gefüllt wird:
public void init()
{
liste.hinzufuegen("Hund" ,"dog");
liste.hinzufuegen("Katze" ,"cat");
liste.hinzufuegen("Schwein","pig");
liste.hinzufuegen("Kuh" ,"cow");
liste.hinzufuegen("Adler" ,"eagle");
liste.hinzufuegen("Spatz" ,"sparrow");
liste.hinzufuegen("Igel" ,"hedgehog");
liste.hinzufuegen("Zebra" ,"zebra");
liste.hinzufuegen("Loewe" ,"lion");
liste.hinzufuegen("Tiger" ,"tiger");
liste.hinzufuegen("Ratte" ,"rat");
liste.hinzufuegen("Falke" ,"falcon");
}
Dazu muss jetzt nicht viel gesagt werden...
actionPerformed
public void actionPerformed(ActionEvent event)
{
if (event.getSource() == ok)
{
ausgabe.setText(liste.english(eingabe.getText()));
}
}
Da es nur einen einzigen Button in dieser Anwendung gibt, hat diese Methode nicht viel zu tun. Sie wartet einfach darauf, dass irgendwann mal der Button angeklickt wird. Ist das der Fall, passiert folgendes:
Mit eingabe.getText() wird der String ausgelesen, den der Benutzer in die Textbox eingabe eingetippt hat, beispielsweise das Wort "Hund".
Mit englisch(eingabe.getText()) wird die Methode englisch der Klasse Vokabelliste aufgerufen, welche die englische Übersetzung des Strings liefert. Wurde "Hund" in die Textbox eingabe getippt, so sollte englisch die Übersetzung "dog" liefern.
Mit ausgabe.setText(...) wird dann die Übersetzung - hier also "dog" in die Textbox ausgabe geschrieben.
main
Die main-Methode ist diejenige Methode, die immer dann ausgeführt wird, wenn man die Java-Anwendung aufruft. Die einzige Aufgabe der main-Methode in unserer Anwendung besteht darin, den Konstruktor TestAnwendung aufzurufen, der dann für alles Weitere sorgt.
Schritt 2 - die Klassen Vokabel und Vokabelliste
Hier kann ohne weiteres die Konsolen-Version der Klassen übernommen werden. Die anzeigen()-Methoden können sogar ganz entfallen, weil sie in der Java-Anwendung nicht benötigt werden.
Falls Sie vorhaben, die Anwendung zu erweitern, werden Sie die anzeigen()-Methoden nicht benötigen. Wenn Sie beispielsweise die gesamte Vokabelliste ausgeben wollen, müssen Sie sich eine Java-Komponente aussuchen, die dazu in der Lage ist und zum Beispiel auch einen senkrechten Scrollbalken zur Verfügung stellt, falls die Liste länger ist als das Java-Fenster hoch ist. Dazu brauchen Sie dann aber keine anzeigen()-Methoden der Vokabelliste, sondern müssen sich die deutschen und englischen Strings aus den Vokabel-Objekten "herausholen" und dann mit setText()-Methoden in die Java-Komponente hineinschreiben.
War schon das Programmieren einer einfachen Java-Anwendung mit einem Button und ein paar Textfeldern eigentlich kein Gegenstand des Informatik-Unterrichtes, so ist das Erstellen einer "richtigen" Anwendung mit Listboxen und anderem Komponenten noch weniger Gegenstand des gymnasialen Informatikunterrichts. Wenn Sie tatsächlich eine solche Anwendung erstellen wollen, müssen Sie selbst im Internet nach entsprechenden Anleitungen schauen.
Wenn es allerdings jemandem gelingen sollte, eine solche Anwendung in Java zu erstellen, würde ich mich freuen, wenn ich den Quelltext hier im Anhang unter seinem/ihrem Namen veröffentlichen könnte.