JavaFX is the first choice for modern Java desktop application development, replacing Swing because it provides modern UI components, CSS style support, FXML separation interface and logic, built-in animation effects, hardware accelerated rendering and Scene Builder visual design tools; 1. Use Maven or manually configure the JavaFX SDK to build the project environment; 2. Create the main program that inherits the Application class and build the interface through Stage, Scene and Node; 3. Use FXML to define the UI structure and combine it with Controller to achieve MVC separation; 4. Use CSS to beautify the style and load it through getStylesheets(); 5. Follow best practices: use MVC/MVVM mode, Scene Builder is fast design, JavaFX attribute binding, and time-consuming tasks are performed in background threads to avoid blocking UI threads; 6. Optional Java modular system configuration module-info.java is configured to support reflection and FXML loading; finally, Java desktop application with clear structure, strong maintenance and visual modernity can be built.

Java has come a long way since the early days of AWT and Swing, and today, JavaFX stands as the modern standard for building rich, responsive desktop GUI applications in Java. While Swing is still in use, JavaFX offers a more flexible, powerful, and visually appealing framework—especially for applications that need animations, media support, or custom UI components.

If you're starting a new desktop project in Java, JavaFX is the way to go. Here's a practical guide to help you get up and running with modern Java GUI development using JavaFX.

Why JavaFX Over Swing?

Before diving in, it's worth understanding why JavaFX is preferred for new projects:

• Modern UI Components : JavaFX includes up-to-date controls (eg, date picker, web view, charts) out of the box.
• CSS Styleling : You can style your UI with CSS, just like a web app.
• FXML Support : Design your interface in XML (FXML) and separate logic from presentation.
• Built-in Animation & Effects : Easy-to-use APIs for transitions, transforms, and visual effects.
• Hardware Acceleration : Leverages GPU via Prism rendering engine for smoother performance.
• FXML Scene Builder : Drag-and-drop UI design with tools like Gluon Scene Builder.

Swing isn't dead, but JavaFX is clearly the future for Java desktop apps.

Setting Up JavaFX in Your Project

One of the biggest hurdles today is that JavaFX is no longer bundled with the JDK starting from Java 11. You need to add it as a separate dependency.

Option 1: Using Maven

Add the following dependencies to your pom.xml (replace VERSION with the latest):

 <dependencies>
    <dependency>
        <groupId>org.openjfx</groupId>
        <artifactId>javafx-controls</artifactId>
        <version>20.0.1</version>
    </dependency>
    <dependency>
        <groupId>org.openjfx</groupId>
        <artifactId>javafx-fxml</artifactId>
        <version>20.0.1</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-maven-plugin</artifactId>
            <version>0.0.8</version>
            <executions>
                <execution>
                    <id>default-cli</id>
                    <configuration>
                        <mainClass>com.example.HelloApplication</mainClass>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Option 2: Manual SDK (for IDEs like IntelliJ or Eclipse)

Download JavaFX SDK from http://ipnx.cn/link/eadd2c9c45ec261d4ae66276556fbd55 , then:

• In IntelliJ: Go to Project Structure → Libraries → Add JavaFX SDK
• Add VM options when running:

   --module-path /path/to/javafx-sdk-20/lib --add-modules javafx.controls,javafx.fxml

Pro tip: Use the JavaFX Maven plugin to avoid manually setting VM arguments every time.

Creating a Basic JavaFX Application

Every JavaFX app extends javafx.application.Application . Here's a minimum example:

 public class HelloApplication extends Application {
    @Override
    public void start(Stage stage) {
        Label label = new Label("Hello, JavaFX!");
        Scene scene = new Scene(new VBox(label), 300, 200);
        stage.setTitle("My App");
        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) {
        launch();
    }
}

Key components:

• Stage : The main window.
• Scene : Container for UI elements.
• Nodes : UI controls like Label , Button , VBox , etc.

Use layout panes ( VBox , HBox , GridPane , BorderPane ) to organize content.

Using FXML for Clean UI Design

For larger apps, avoid writing UI in Java code. Instead, use FXML —an XML-based language for defining your interface.

Example: hello-view.fxml

 <?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.control.*?>
<?import javafx.scene.layout.*?>

<VBox alignment="CENTER" spacing="20" xmlns="http://javafx.com/javafx">
    <Label text="Welcome!" />
    <Button text="Click Me" onAction="#onButtonClick" />
</VBox>

Controller Class

 public class HelloController {
    @FXML
    private void onButtonClick() {
        System.out.println("Button clicked!");
    }
}

Load FXML in Main App

 public class HelloApplication extends Application {
    @Override
    public void start(Stage stage) throws IOException {
        FXMLLoader fxmlLoader = new FXMLLoader(HelloApplication.class.getResource("hello-view.fxml"));
        Scene scene = new Scene(fxmlLoader.load(), 300, 200);
        stage.setTitle("FXML App");
        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) {
        launch();
    }
}

This separation keeps your UI and logic clean and maintainable.

Styling with CSS

JavaFX supports CSS for styling, which makes skinning your app much easier.

Create a file style.css :

 .root {
    -fx-background-color: #f0f0f0;
}

.label {
    -fx-font-size: 18px;
    -fx-text-fill: #333;
}

.button {
    -fx-font-size: 14px;
    -fx-background-color: #4a76a8;
    -fx-text-fill: white;
}

.button:hover {
    -fx-background-color: #3a5a78;
}

Then apply it in your scene:

 scene.getStylesheets().add(getClass().getResource("style.css").toExternalForm());

You can even use external themes like JMetro or Dark Bootstrap for poisoned looks.

Best Practices for Modern JavaFX Development

1. Use MVC or MVVM Pattern
   Keep UI (View), logic (Controller), and data (Model) separate. FXML Controller is a basic form of MVC.

2. Leverage Scene Builder
   Gluon Scene Builder lets you visually design FXML files—great for prototypeing.

3. Use JavaFX Properties and Bindings
   Bind UI elements to data models so they update automatically:

    label.textProperty().bind(viewModel.messageProperty());

4. Run Long Tasks on Background Threads
   Never block the JavaFX Application Thread. Use Task or Platform.runLater() :

    Task<Void> task = new Task<>() {
       @Override
       protected Void call() {
           // Long-running work
           return null;
       }
   };
   new Thread(task).start();

5. Modularize with Java 11 Modules (Optional)
   If using modules ( module-info.java ), include:

    javafx.controls;
   javafx.fxml;
   opens com.example to javafx.fxml;

   ---

   Final Thoughts

   JavaFX may not be as trendy as web or mobile frameworks, but it remains the best choice for building cross-platform desktop applications in Java. With tools like FXML, CSS, Scene Builder, and strong community support (via Gluon and OpenJFX), modern Java GUI development is more accessible than ever.

   Whether you're building internal tools, educational software, or full-featured desktop apps, JavaFX gives you the tools to do it right.

   Basically, stick to JavaFX, use FXML and CSS, manage threads properly, and keep your architecture clean—and you'll have a maintainedable, modern Java GUI app in no time.

   The above is the detailed content of A Guide to Modern Java GUI Development with JavaFX. For more information, please follow other related articles on the PHP Chinese website!