Constructor vs initialize() Method in OpenJFX

1. Overview

OpenJFX, formerly known as JavaFX, is a free and open-source platform for creating cross-platform software applications. It is the intended backward-compatible and modern replacement for Swing to address its shortcomings. It includes a wide range of modules for capabilities such as GUI controls, graphics, media, web, FXML, and so on.

In this article, we’ll compare the standard constructor method of POJO and the JavaFX-specific initialize() method. First, we’ll grasp the JavaFX controller lifecycle, and then we’ll compare it against a constructor.

Finally, we’ll look at some of the gotchas, pitfalls, and best practices that we can employ in a JavaFX software.

2. Constructor vs. initialize()

Before we dive into the comparison, let’s first examine how JavaFX objects are created when we create a simple controller class.

2.1. JavaFX Controller Lifecycle

When we declare an FXML view and, optionally, implement a constructor or initialize() method in a JavaFX controller, the constructor is called first:

public class MainController implements Initializable {

    private final String appName;

    @FXML
    private Label appNameLabel;

    public MainController(String name) {
        this.appName = name;
    }

    @Override
    public void initialize(URL location, ResourceBundle res) {
        this.appNameLabel.setText(this.appName); 
    }
}

In the snippet, we bind the appNameLabel view to its corresponding FXML file. This specific operation happens before the initialize() method is called. More specifically, FXMLLoader parses the view files and injects the appropriate views into the controller fields:

Once the fields are injected successfully, we can safely access them in the initialize method for operations like registering event handlers and styling. In essence, the injection doesn’t happen in initialize but after the constructor is called. So, the fields aren’t available for use in the constructor:

During the construction, the views are essentially null. If we try to access the FXML views in a constructor, the program will throw NullPointerException.

So, initialize() provides a safe way to post-process FXML views and set them up at the beginning of program execution. Afterwards, the scene is rendered when the views are ready. Therefore, we can put the UI initialization logic in the initialize method.

3. When to Use Constructor

Technically, we can bypass the constructor and solely use initialize(), but using a constructor is still useful.

3.1. Dependency Injection

We can initialize the internal state or context of a controller that isn’t dependent on the FXML views. In addition, we can also use the constructor for dependency injection unrelated to FXML view injection, like services and data repositories:

public class ProfileController implements Initializable {

    private final UserService userService;
    private User currentUser;

    @FXML
    private Label usernameLabel;

    public ProfileController(UserService userService) {
        this.currentUser = userService.getCurrentUser();
    }

    @Override
    public void initialize(URL location, ResourceBundle resources) {
        usernameLabel.setText("Welcome, " + this.currentUser.getName());
    }
}

Inside the constructor, we’re carrying out dependency injection for UserService.

3.2. Internal State

Moreover, we can also use a constructor for things like logging and setting up metrics components. In short, we can use a constructor for low-level setup and setters for contextual data:

public class MainController implements Initializable {

    private final Logger logger;
    private final MetricsCollector metrics;

    @FXML
    private Label statusLabel;

    public MainController() {
        this.logger = Logger.getLogger(DashboardController.class.getName());
        this.metrics = new MetricsCollector("dashboard-controller");

        logger.info("DashboardController created");
        metrics.incrementCounter("controller.instances");
    }

    @Override
    public void initialize(URL location, ResourceBundle resources) {
        statusLabel.setText("App is ready!");
        logger.info("UI initialized successfully");
    }
}

4. Pitfalls

There are a few pitfalls we should keep in mind when using initialize().

4.1. Initializable and @FXML Conflict

We can implement initialize() in two ways. The first one is by implementing the Initializable interface. The second one is by annotating initialize() with @FXML annotation:

public class MainController implements Initializable {

    @FXML
    public void initializable() {}

    // Throws an error
    @override
    public void initialize(URL location, ResourceBundle res) {}
}

Both work the same way, but only one can exist in a class. Therefore, if the annotated variant exists, then overriding initialize() method will throw an error.

4.2. Handling FXML Exceptions

The initialize method isn’t called if one FXML view fails to load. Therefore, we should gracefully handle the exceptions or provide fallbacks just in case:

try {
    FXMLLoader loader = new FXMLLoader(getClass().getResource("app-label.fxml"));
    Parent root = loader.load();
    stage.setScene(new Scene(root));
} catch (IOException e) {
    // Log and provide fallback
    System.err.println("View failed to load: " + e.getMessage());
    stage.setScene(new Scene(new Label("UI failed to load")));
}

4.3. Avoid Heavy Logic in initialize()

The initialize() method runs in a JavaFX thread. So, if we hit the database or do CPU-intensive work in initialize(), it will block the UI thread. It will result in a frozen UI or be marked as “unresponsive” by the OS.

The best practice is to limit initialize() to UI, and offload heavy lifting to Task or Service.

5. Conclusion

In this article, we saw how a constructor differs from initialize() in JavaFX. We learned about how the JavaFX controller lifecycle works and how FXML fields are injected by the JavaFX context using a simple example.

Finally, we explored when a constructor should be preferred to initialize() and a few pitfalls to keep in mind when using initialize().

As always, our code examples are available over on GitHub.