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.
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, mitshow()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.

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.

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.

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.
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.

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.
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.

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.

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.

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.

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.

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.
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.

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.
