JavaFX事件处理器失效问题求助及事件封装方案咨询

Let's start with the core issue in your second code snippet—this is a common pitfall when refactoring UI code!

The Problem: Duplicate Component Instances #

Every time you call button1(), button2(), hbox(), or scene(), you're creating a new instance of that component. Here's the breakdown:

• When you bind your event handler to button1(), you're attaching it to one Button object.
• But when you build the scene with scene(), that triggers hbox(), which calls button1() again—making a totally separate Button that gets added to the UI.
• The button you click in the window isn't the same one the handler is attached to. So clicking it does nothing!

The Fix: Reuse Component Instances #

Instead of creating new components every time you call a method, store them as instance variables in your Testing class. This ensures you're always referencing the same objects:

public class Testing extends Application {
    // Store UI components as class members
    private Button button1;
    private Button button2;
    private HBox hbox;
    private Scene scene;

    @Override
    public void start(Stage stage) {
        // Initialize all components first
        setupUI();

        // Bind handler to the SAME button in the UI
        EventHandler<ActionEvent> aHandler = event -> button2.setText("Working");
        button1.addEventHandler(ActionEvent.ACTION, aHandler);

        stage.setScene(scene);
        stage.setTitle("Testing");
        stage.show();
    }

    private void setupUI() {
        button1 = new Button("First button");
        button2 = new Button("Second button");
        hbox = new HBox(40, button1, button2);
        scene = new Scene(hbox, 840, 400);
    }

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

If you prefer to keep the getter-style methods, use lazy initialization to return the same instance each time:

public class Testing extends Application {
    private Button button1;
    private Button button2;
    private HBox hbox;
    private Scene scene;

    @Override
    public void start(Stage stage) {
        EventHandler<ActionEvent> aHandler = event -> getButton2().setText("Working");
        getButton1().addEventHandler(ActionEvent.ACTION, aHandler);

        stage.setScene(getScene());
        stage.setTitle("Testing");
        stage.show();
    }

    public Button getButton1() {
        if (button1 == null) button1 = new Button("First button");
        return button1;
    }

    public Button getButton2() {
        if (button2 == null) button2 = new Button("Second button");
        return button2;
    }

    public HBox getHbox() {
        if (hbox == null) hbox = new HBox(40, getButton1(), getButton2());
        return hbox;
    }

    public Scene getScene() {
        if (scene == null) scene = new Scene(getHbox(), 840, 400);
        return scene;
    }

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

Now, let's cover how to move your event logic into its own class for better organization and reusability.

Option 1: Component-Specific Handler #

Create a handler class that accepts the target component (like your button2) via its constructor. This keeps the logic focused and reusable:

// Standalone event handler class
public class UpdateButtonTextHandler implements EventHandler<ActionEvent> {
    private final Button targetButton;
    private final String newText;

    public UpdateButtonTextHandler(Button targetButton, String newText) {
        this.targetButton = targetButton;
        this.newText = newText;
    }

    @Override
    public void handle(ActionEvent event) {
        targetButton.setText(newText);
    }
}

Then use it in your main app:

public class Testing extends Application {
    private Button button1;
    private Button button2;

    @Override
    public void start(Stage stage) {
        setupUI();

        // Attach the separate handler
        button1.addEventHandler(ActionEvent.ACTION, 
            new UpdateButtonTextHandler(button2, "Working"));

        Scene scene = new Scene(new HBox(40, button1, button2), 840, 400);
        stage.setScene(scene);
        stage.setTitle("Testing");
        stage.show();
    }

    private void setupUI() {
        button1 = new Button("First button");
        button2 = new Button("Second button");
    }

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

Option 2: Generic Handler for Flexible Logic #

If you want a handler that can run any custom logic, use a Runnable to pass in the action. This is great for reusing the same handler class across different use cases:

public class GenericActionHandler implements EventHandler<ActionEvent> {
    private final Runnable action;

    public GenericActionHandler(Runnable action) {
        this.action = action;
    }

    @Override
    public void handle(ActionEvent event) {
        action.run();
    }
}

Usage is concise and clean:

button1.addEventHandler(ActionEvent.ACTION, 
    new GenericActionHandler(() -> button2.setText("Working")));

This is essentially wrapping a lambda in a class, which is perfect if you want to keep your event code modular without repeating boilerplate.

内容的提问来源于stack exchange，提问作者Elizah