Ereignisbehandlung in JavaFX

Der Block »{ java.lang.System.out.println( "block" ); }« in dem folgenden Programm wird immer genau dann aufgerufen, wenn im Textfelde »text« die Eingabetaste betätigt wird.

Durch Aufrufe der Methode »setOnAction« wird jener Block zunächst als Ausdruck an das Textfeld übergeben. Dabei wird der Block noch nicht ausgeführt! Das Textfeld merkt sich diesen Block aber und führt ihn immer dann aus, wenn es als Eingabe eine Eingabetaste erhält.

Merkhilfe für Textfelder

Action = Eingabetaste

Main.java

public class Main extends javafx.application.Application
{
  public void start( final javafx.stage.Stage stage ) 
  { final javafx.scene.control.TextField text = new javafx.scene.control.TextField( "text"  );
    text.setOnAction( object ->{ java.lang.System.out.println( "block" ); });
    final javafx.scene.Scene scene = new javafx.scene.Scene( text );
    stage.setScene( scene );
    stage.show(); }}

Übungsaufgaben

Tip: Bei vielen der folgenden Übungsaufgaben sind Änderungen in dem Block hinter »object ->« vorzunehmen!

/ Übungsaufgabe

Das Ergebnis eines Aufrufs der Methode »getText()« eines Textfeldes ist eine Zeichenfolge mit dem derzeitigen Zeicheninhalt jenes Textfelds. Schreiben Sie den Blockausdruck aus dem ersten Beispielprogramm dieser Lektion so um, daß bei einer Aktion (also bei Betätigung der Eingabetaste mit dem Textfeld im Fokus) der derzeitige Inhalt des Textfeldes »text« mit »java.lang.System.out.println« ausgegeben wird (auf die Konsole).

Sie können dann während der Ausführung dieses Programms, einen Text in das Textfeld schreiben und diesen dann mit Betätigung der Eingabetaste auf die Konsole kopieren.

/ Übungsaufgabe

Durch Aufruf der void-Methode »setText(java.lang.String)« eines Textfeldes mit einem java.lang.String-Objekt als Argument kann der Zeicheninhalt jenes Textfeldes durch die als Argumentwert übergebene Zeichenfolge festgelegt werden. Schreiben Sie den Blockausdruck aus dem ersten Beispielprogramm dieser Lektion so um, daß bei einer Aktion der derzeitige Inhalt des Textfeldes »text« auf »Aktion« gesetzt wird.

Sie können dann während der Ausführung dieses Programms mit Betätigung der Eingabetaste den Text »Aktion« in das Textfeld schreiben, welches zuvor ja den Text »text« enthielt.

/ Übungsaufgabe

Sie können dann während der Ausführung dieses Programms mit Betätigung der Eingabetaste immer eine neue Zufallszahl erhalten.

/ Übungsaufgabe

Erstellen Sie ein Programm, das ein Textfeld anzeigt und bei der Betätigung der Eingabetaste in diesem Textfeld, den Text aus dem Textfelde ausliest und dann den eingeklammerten Text in das Textfeld hineinschreibt. Nach der Eingabe »4« soll in dem Textfeld beispielsweise »(4)« erscheinen.

/ Übungsaufgabe

Erstellen Sie ein Programm, das zwei Textfelder anzeigt und bei der Eingabe eines Textes in ein Textfeld diesen in das andere Textfeld kopiert.

Bedeutung eines setOnAction-Aufrufs

  textField.setOnAction( ... )
      ^                   ^
      |                   |
Wer reagieren        Was er tun
    soll                soll

/ Übungsaufgabe

Erstellen Sie ein Programm, das zwei Textfelder anzeigt und bei der Betätigung einer Tastfläche den Text vom ersten in das zweite Textfeld kopiert.

Eine Tastfläche hat die Klasse »javafx.scene.control.Button«.

Diese Klasse kann praktisch genauso wie die Textfeld-Klasse verwendet werden, ein Unterschied besteht lediglich darin, daß vom Benutzer des Programmes kein Text in eine Tastfläche eingegeben werden kann und der mit »setOnAction« festgelegte Block beim Anklicken der Tastfläche ausgeführt wird.

Merkhilfe für Tastfläche: Action = Anklicken
Details zu »javafx.scene.control.Button«: »javafx.scene.control.Button« ist wie »javafx.scene.control.TextField« ein Untertyp von »javafx.scene.Node«. Daher kann eine Tastfläche wie eine Textfeld mit »add(javafx.scene.Node)« zu einem Behälter hinzugefügt werden. (Beachten Sie hier die Beispielprogramm der Lektion (40.1.).; »javafx.scene.control.Button« hat einen Konstruktor »javafx.scene.control.Button(java.lang.String)«, so daß eine neue Tastfläche wie ein Textfeld mit einer Zeichenfolge erzeugt werden kann.; Außerdem verfügt die Klasse »javafx.scene.control.Button« wie die Klasse »javafx.scene.control.TextField« über setText- und setOnAction-Methoden.; Weitere Informationen können bei Bedarf der JavaSE -Dokumentation entnommen werden, werden aber zur Bearbeitung dieser Aufgabe nicht benötigt.

/ Übungsaufgabe

Erstellen Sie ein Programm, das zwei Textfelder anzeigt und bei der Betätigung einer Tastfläche das Doppelte der Zahl aus dem ersten Textfeld in das zweite schreibt.

/ Übungsaufgabe

Erstellen Sie ein Programm, das drei Textfelder anzeigt und bei der Betätigung einer Tastfläche die Summe der Zahlen der ersten beiden Textfelder in das dritte schreibt.

/ Übungsaufgabe

Ergänzen Sie die Lösung der vorigen Übungsaufgabe um ein Programm, das eine weitere Tastfläche zur Berechnung des Produktes der beiden Zahlen enthält.

/ Übungsaufgabe

Erstellen Sie ein Programm, das zwei Textfelder anzeigt und bei der Eingabe eines Textes in ein Textfeld in dem anderen Textfeld die zweifache Verkettung des eingegebenen Text mit sich selbst ausgibt. Wird in das eine Textfeld beispielsweise »abc« eingegeben, so soll die Ausgabe »abcabcabc« erscheinen.

/ Übungsaufgabe *

Erstellen Sie ein Programm, das zählt, wie oft in einem Textfeld die Eingabetaste gedrückt wurde.

/ Übungsaufgabe *

Erstellen Sie ein Programm, das zählt, wie oft eine Tastfläche angeklickt wurde.

/ Zusatzaufgabe *

Programmieren Sie einen Taschenrechner. Eine gute Vorgehensweise, wäre es, einen vorhandenen Taschenrechner als Vorbild zu nehmen, und zu versuchen, dessen Funktionen nachzuprogrammierern. Dabei sollte aber mit den Funktionen begonnen werden, deren Umsetzung am einfachsten ist.

Namen lokaler Variablen in Blockausdrücken *

Der Blockausdruck befindet sich im Gültigkeitsbereich der Stelle seiner Verwendung. Deswegen kann in dem folgenden Programm beispielsweise die Variable »sb« im Blockausdruck verwendet werden. Es dürfen jedoch im Blockausdruck nur solche Variablen aus der Umgebung verwendet werden, die nach ihrer Initialisierung nicht verändert werden (es darf keine Zuweisung geben, deren linke Seite die Variable ist), sie müssen also praktisch »final« sein, auch wenn sie nicht unbedingt mit »final« deklariert worden sein müssen.

Main.java

public class Main extends javafx.application.Application
{
  public void start( final javafx.stage.Stage stage ) 
  { final javafx.scene.control.TextField text = new javafx.scene.control.TextField( "text"  );
    int variable = 25;
    text.setOnAction( object -> { java.lang.System.out.println( variable ); });
    final javafx.scene.Scene scene = new javafx.scene.Scene( text );
    stage.setScene( scene );
    stage.show(); }}

java.lang.System.out

»final java.lang.StringBuilder sb« verbietet aber nicht »sb.append( "d" )«, es verbietet nur »sb =«.

Main.java

public class Main extends javafx.application.Application
{
  public void start( final javafx.stage.Stage stage ) 
  { final javafx.scene.control.TextField text = new javafx.scene.control.TextField( "text"  );
    final java.lang.StringBuilder sb = new java.lang.StringBuilder( "abc" );
    text.setOnAction( object ->{ sb.append( "d" ); java.lang.System.out.println( sb ); });
    final javafx.scene.Scene scene = new javafx.scene.Scene( text );
    stage.setScene( scene );
    stage.show(); }}

java.lang.System.out

abcd
abcdd
abcddd
abcdddd
abcddddd

Die Startmethode in der GUI-Programmierung *

Die Startmethode der meisten GUI-Programme ist nach dem Muster „Erzeugen, Verdrahten und Schluß“ aufgebaut.

Zuerst werden einmal die benötigten GUI-Objekte erzeugt („Erzeugen“) und konfiguriert.
Während der Erzeugung werden die GUI-Objekte auch wie benötigt verdrahtet („Verdrahten“).
Dann wird die soeben aufgebaute Benutzeroberfläche sichtbar geschaltet und danach wird nichts mehr von der Start-Methode getan („Schluß“). (Vorgänge werden ab jetzt durch Benutzeraktivitäten ausgelöst.)

Java läßt bei GUI-Programmen den Prozeß beim Ende der Startmethode noch weiterlaufen. Daher verschwindet die Benutzeroberfläche also am Ende der Startmethode nicht.

Verdrahtung *

Wir verstehen unter Verdrahtung, daß ein Objekt A Kenntnis von einem anderen Objekt B erhält. Das Objekt A kann sich diese Information dann merken und auf diese Weise das Objekt B später bei Bedarf erreichen.

„A ist mit B verdrahtet“ bedeutet also so viel wie „A kennt B“ (oder manchmal auch „B kennt A“ – die Details muß man dem Zusammenhang entnehmen).

A und B sind verdrahtet

.-------------.          .-------------.
| A           |--------->| B           |
|             |          |             |
'-------------'          '-------------'

In der Sprechweise von UML nennt man die Verbindung (den „Draht“) auch eine Assoziation und die Verdrahtung „Herstellung einer Assoziation“.

In unserem Programm erfolgt eine Verdrahtung eines Textfeldes »text« mit einem Blockobjekt durch die Methode »setOnAction«.

Das Textfeldobjekt »text« und das Blockobjekt werden verdrahtet

    text.setOnAction( object ->{ java.lang.System.out.println( "block" ); });

Das Textfeld »text« kann sich das Blockobjekt auch über die Dauer der Ausführung von »setOnAction« hinaus für eine spätere Verwendung merken.

Das Textfeldobjekt »text« und das Blockobjekt sind verdrahtet

.-------------.          .-----------------------------------------------.
| text        |--------->| { java.lang.System.out.println( "block" ); }  |
|             |          |                                               |
'-------------'          '-----------------------------------------------'

Nach der Verdrahtung kennt das Textfeld das Blockobjekt und kann den im Blockobjekt enthaltenen Block so jederzeit ausführen.

In UML wird der durch eine Verdrahtung erzeugte „Draht“ auch als eine „Assoziation“ bezeichnet.

Bei der Verdrahtung wird ein Objektgraph aufgebaut, das heißt eine Struktur aus miteinander verbundenen Objekten. Das Geschehen nach der Verdrahtung ergibt sich dann aus dem Zusammenwirken der Objekte dieses Graphen.

Die Verdrahtungung erfolgt vor allem für zwei Zwecke, die im folgenden beschrieben werden.

Verdrahtung zur Aggregation *

Aggregation: Ein GUI-Objekt »I« („Inhalt“) soll innerhalb eines anderen GUI-Objektes »B« („Behälter“) angezeigt werden. Dafür muß »B« »I« natürlich kennen. Also muß eine Leitung von »B« zu »I« gelegt werden. Dies kann dadurch geschehen, daß »B« bereits im Erzeugungsausdruck das Objekt »I« als Argument übergeben wird. Statt dessen kann aber auch nach der Erzeugung eine Methode von »B« aufgerufen werden, welche das Objekt »I« als Argument akzeptiert.

Verdrahtung vom Behälter zum Inhalt

.-------------.          .-------------.
| Behaelter   |--------->| Inhalt      |
|             |          |             |
'-------------'          '-------------'

Verdrahtung vom Behälter zum Inhalt in einem Erzeugungsausdruck

final javafx.scene.Scene scene = new javafx.scene.Scene( text );

Verdrahtung vom Behälter zum Inhalt in einem Methodenaufruf

    stage.setScene( scene );

Verdrahtung zur Ereignisweiterleitung *

Ereignisweiterleitung: Ein Objekt oder eine Methode »E« („Empfänger“) soll festlegen, was bei einem bestimmten Ereignis (einer bestimmten Benutzereingabe) passiert. Dann muß eine Leitung von einem Objekt »S« („Sender“), welches von diesem Ereigns weiß, zu »E« gelegt werden. Dazu wird meist eine Methode von »S« aufgerufen werden, welche das Objekt »E« als Argument akzeptiert.

Verdrahtung vom Sender zum Empfänger

.---------------------.          .------------------------.
| Ereignissender      |--------->| Ereignisempfaenger     |
|                     |          |                        |
'---------------------'          '------------------------'

Das Textfeldobjekt »text« und das Blockobjekt werden verdrahtet

          text.setOnAction( object ->{ java.lang.System.out.println( "block" ); });  /*
          '--'              '---------------------------------------------------'     *
     Ereignissender                          Ereignisempfänger                        */