Home > Informatik > Stufe Q1

11.2 Eine Vokabel-Anwendung

Teil 1 - Teil 2

Zielsetzung

Bisher haben die meisten von Ihnen das ganze Projekt als reine BlueJ-Anwendung 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(500,500);
        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();
    }
}

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(500,500);
        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 500 x 500 Pixel festgelegt. Damit wird die "Tradition" von den alten BlueJ-Versionen gewahrt; hier hatte ein Applet die Standardgröße von 500 x 500 Pixeln.

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ändertn kann, und mit setVisible und dem Parameter true wird dafür gesorgt, dass das erzeugte Fenster überhaupt sichbar 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 Schnickschnack noch weniger Gegenstand des gymnasialen Informatikunterrichts. Wenn Sie als engagierter Schüler tatsächlich eine solche Anwendung erstellen und ihren Lehrer damit beeindrucken wollen, müssen Sie selbst im Internet nach entsprechenden Anleitungen schauen. Von Ihrem Lehrer können Sie dazu in der Regel aber keine Hilfe erwarten.