JavaFX für GUI-Entwicklung

JavaFX: Mehrere Scenes einrichten und wechseln

Alle Videos des Tutorials JavaFX für GUI-Entwicklung
Denis Panjuta
Von Denis Panjuta Zuletzt aktualisiert am

Ein Programm, das nur eine einzige Ansicht kennt, wird schnell unübersichtlich, sobald der Nutzer etwas Schrittweises erledigen soll, etwa bei einem Installationsassistenten. JavaFX löst dieses Problem mit mehreren Scenes innerhalb eines einzigen Fensters. In dieser Anleitung baust du zwei Szenen auf, die du per Button hin und her wechselst. Als Ausgangspunkt dient eine bestehende JavaFX-Anwendung mit einer Stage und einer Scene.

JavaFX für GUI-Entwicklung – 06 Verwendung mehrerer Scenes

Das Video wird erst beim Abspielen von YouTube geladen – dabei werden Daten (u. a. deine IP-Adresse) an YouTube bzw. Google übertragen. Mehr dazu in der Datenschutzerklärung

Wichtigste Erkenntnisse

  • Eine Stage ist das Fenster, eine Scene ist der Inhalt, der darin angezeigt wird. Zu jedem Zeitpunkt sieht der Nutzer nur eine Scene.
  • Die Stage speicherst du in einer globalen Variablen, damit alle Methoden darauf zugreifen können.
  • Jede Scene erhält ein eigenes Layout, in diesem Fall eine VBox, die ihre Elemente untereinander anordnet.
  • Mit setScene() tauschst du die sichtbare Szene aus, mit show() aktualisierst du die Anzeige des Fensters.
  • Der Event-Handler entscheidet anhand von event.getSource(), welcher Button geklickt wurde, und löst dadurch den passenden Szenenwechsel aus.

Schritt-für-Schritt-Anleitung

Globale Variablen anlegen

Beginne damit, die Variablen für alle Bausteine oberhalb der Methode start() zu deklarieren. Du brauchst eine Stage für das Fenster, zwei Scenes, zwei Buttons und zwei Labels. Die Stage nennst du am besten fenster, die Scenes szene1 und szene2. Diese Variablen stehen dann in der gesamten Klasse zur Verfügung.

Stage fenster;
Scene szene1, szene2;
Button button1, button2;
Label label1, label2;
JavaFX: Mehrere Scenes einrichten und wechseln

Benötigte Klassen importieren

Damit du Button und Label verwenden kannst, musst du die entsprechenden Klassen importieren. Mit der Tastenkombination Strg + Umschalt + O fügt die IDE die Importe automatisch hinzu. Achte darauf, dass du die Klassen aus javafx.scene.control und die VBox aus javafx.scene.layout verwendest.

import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
JavaFX: Mehrere Scenes einrichten und wechseln

Primary Stage in die globale Variable übernehmen

Die Methode start() erhält als Parameter die Primary Stage, also das Hauptfenster deiner Anwendung. Diesen Wert weist du der globalen Variablen fenster zu. Ab jetzt kannst du überall in der Klasse auf das Fenster zugreifen, ohne den Parameter weiterreichen zu müssen.

@Override
public void start(Stage primaryStage) {
    fenster = primaryStage;
}
JavaFX: Mehrere Scenes einrichten und wechseln

Label und Button der ersten Szene erstellen

Nun erzeugst du das Label für die erste Szene mit dem Text „Das ist die erste Szene“. Anschließend legst du einen Button an, der beschriftet wird mit „Zur zweiten Szene wechseln“. Der Button muss im Layout der ersten Szene liegen, deshalb ist er an dieser Stelle noch ein eigenständiges Objekt, das du später einfügst.

label1 = new Label("Das ist die erste Szene");
button1 = new Button("Zur zweiten Szene wechseln");

Action-Event und Event-Handler einrichten

Damit der Button beim Klick etwas auslöst, benötigst du die Methode setOnAction(). Als Übergabewert erwartet sie einen Event-Handler. Im Beispiel implementierst du die Schnittstelle EventHandler<ActionEvent> direkt in deiner Hauptklasse. Die IDE bietet dafür einen Quick Fix an, der die Methode handle() automatisch erzeugt. Anschließend übergibst du this an den Button.

public class Main extends Application implements EventHandler<ActionEvent> {

    // ...

    @Override
    public void handle(ActionEvent event) {
        // Hier folgt später die Logik für den Szenenwechsel
    }
}
button1.setOnAction(this);
JavaFX: Mehrere Scenes einrichten und wechseln

Ein Layout mit einer VBox anlegen

Ein Layout bestimmt, wie Elemente in einer Scene angeordnet werden. Eine VBox ordnet ihre Kinder vertikal untereinander an. Die Zahl im Konstruktor legt den Abstand zwischen den Elementen in Pixeln fest. Mit new VBox(30) erhältst du also 30 Pixel Abstand. Das Prinzip ist mit dem BorderPane aus einem früheren Tutorial vergleichbar: Du wählst ein Layout und füllst es mit Elementen.

VBox layout1 = new VBox(30);

Elemente dem Layout hinzufügen

Die Kinder eines Layouts holst du dir über getChildren(). Mit add() fügst du ein einzelnes Element hinzu, mit addAll() gleich mehrere auf einmal. Das spart Schreibarbeit, weil du Label und Button in einer einzigen Zeile übergeben kannst.

layout1.getChildren().addAll(label1, button1);
JavaFX: Mehrere Scenes einrichten und wechseln

Die erste Scene initialisieren und anzeigen

Jetzt verbindest du das Layout mit der Scene. Dabei legst du gleich die Größe fest, in diesem Fall 250 mal 250 Pixel. Danach setzt du die Scene in das Fenster und rufst show() auf. Die alte, leere Scene, die du zu Beginn angelegt hast, brauchst du nicht mehr. Mit dieser Zeile erscheint das Fenster mit dem Inhalt der ersten Szene.

szene1 = new Scene(layout1, 250, 250);
fenster.setScene(szene1);
fenster.show();
JavaFX: Mehrere Scenes einrichten und wechseln

Die zweite Szene nach dem gleichen Muster aufbauen

Die zweite Szene entsteht nach demselben Schema. Am einfachsten kopierst du den Code der ersten Szene und ersetzt alle Bezeichnungen. Aus label1 wird label2, aus button1 wird button2, aus layout1 wird layout2 und aus szene1 wird szene2. Der Text des Labels lautet nun „Das ist die zweite Szene“, der Button-Text „Zur ersten Szene wechseln“. Beachte, dass du den Button der zweiten Szene noch nicht mit einer Aktion verknüpfen musst, weil du die Logik im Event-Handler ergänzt.

JavaFX: Mehrere Scenes einrichten und wechseln

Den Wechsel zur zweiten Szene programmieren

Im Event-Handler prüfst du mit event.getSource(), welcher Button das Ereignis ausgelöst hat. Ist es button1, setzt du die szene2 und zeigst das Fenster erneut an. Damit siehst du den Wechsel in die zweite Szene. Mit einem Testlauf stellst du jedoch fest, dass du von dort aus nicht mehr zurückkommst, weil der zweite Button noch keine Funktion hat.

@Override
public void handle(ActionEvent event) {
    if (event.getSource() == button1) {
        fenster.setScene(szene2);
        fenster.show();
    }
}
JavaFX: Mehrere Scenes einrichten und wechseln

Den Rückweg zur ersten Szene ergänzen

Damit der zweite Button zurückführt, erweiterst du den Event-Handler um eine zweite Bedingung. Ist die Quelle des Ereignisses button2, setzt du szene1 und rufst erneut show() auf. Mit else if stellst du sicher, dass nur der jeweils passende Zweig ausgeführt wird. Außerdem muss der zweite Button den Handler ebenfalls kennen, weshalb du button2.setOnAction(this); nicht vergessen darfst.

} else if (event.getSource() == button2) {
    fenster.setScene(szene1);
    fenster.show();
}
JavaFX: Mehrere Scenes einrichten und wechseln

Konsolenausgabe zur Kontrolle hinzufügen

Damit du im Test nachvollziehen kannst, welche Szene gerade aktiv ist, gibst du in jedem Zweig eine Meldung in der Konsole aus. Das ist besonders hilfreich, wenn sich die Oberfläche später komplexer verhält und du den Ablauf prüfen möchtest.

System.out.println("Wechsle zu Szene 2");
System.out.println("Wechsle zu Szene 1");

Das Programm testen

Starte die Anwendung und klicke auf den Button der ersten Szene. Die Konsole zeigt die Meldung an, und das Fenster stellt die zweite Szene dar. Mit dem Button der zweiten Szene kehrst du zur ersten zurück. Du erkennst, dass es sich zwar um dasselbe Fenster handelt, die Inhalte jedoch unabhängig voneinander sind. Genau darin liegt der Nutzen mehrerer Scenes: Jede Szene kann eigene Steuerelemente besitzen, ohne dass sich die Szenen gegenseitig beeinflussen.

JavaFX: Mehrere Scenes einrichten und wechseln

Zusammenfassung – JavaFX: Mehrere Scenes einrichten und wechseln

Du hast gelernt, wie du mehrere Scenes in einem einzigen JavaFX-Fenster anlegst und zwischen ihnen wechselst. Die Stage speicherst du in einer globalen Variablen, jede Scene bekommt ein eigenes Layout, und der Event-Handler entscheidet über den Wechsel. Der Aufbau ist zunächst aufwendig, weil du für jeden Button den Handler einbinden und jede Bedingung von Hand abfragen musst. Für größere Anwendungen gibt es bessere Wege, die im nächsten Schritt deiner Lernreise behandelt werden.

FAQ

Muss ich die Stage immer in einer globalen Variablen speichern?Nein, du kannst die Stage auch als Parameter weitergeben. Eine globale Variable ist aber praktisch, wenn mehrere Methoden darauf zugreifen sollen.

Warum sehe ich nach dem Klick nicht sofort die neue Szene?Prüfe, ob du nach setScene() auch show() aufrufst. Ohne diesen Aufruf wird die Änderung nicht zuverlässig angezeigt.

Kann ich einen Button ohne Event-Handler verwenden?Ja, ein Button ohne setOnAction() tut beim Klick nichts. Er wird erst durch einen zugewiesenen Event-Handler funktionsfähig.

Warum verwende ich in der Bedingung == statt equals()?Hier vergleichst du Objektreferenzen, also prüfst du, ob es genau dasselbe Button-Objekt ist. Dafür ist == passend.

Was bringt die Ausgabe mit System.out.println?Sie hilft dir beim Testen, weil du in der Konsole sofort siehst, welcher Zweig ausgeführt wurde.

Denis Panjuta
Trainer Über Denis Panjuta Hi! Ich bin Denis Panjuta und habe einen Bachelor in Wirtschaftsingenieurswesen der HTWG Konstanz, wo ich auch meine Begeisterung fürs Programmieren entdeckte. Zurzeit lernen bereits über 16.000 Studenten von meinen Kursen. Alle Kurse von Denis Panjuta