如何将匿名Java类重写为非匿名类？

了解匿名类，并从Oracle获得此信息。我希望有人能告诉我，如果我不使用匿名类，这会是什么样子。如果换一个新的班级，我会怎么做

import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class HelloWorld extends Application {
    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {
        primaryStage.setTitle("Hello World!");
        Button btn = new Button();
        btn.setText("Say 'Hello World'");
        btn.setOnAction(new EventHandler<ActionEvent>() {

            @Override
            public void handle(ActionEvent event) {
                System.out.println("Hello World!");
            }
        });

        StackPane root = new StackPane();
        root.getChildren().add(btn);
        primaryStage.setScene(new Scene(root, 300, 250));
        primaryStage.show();
    }
}

导入javafx.event.ActionEvent；
导入javafx.event.EventHandler；
导入javafx.scene.scene；
导入javafx.scene.control.Button；
导入javafx.scene.layout.StackPane；
导入javafx.stage.stage；
公共类HelloWorld扩展了应用程序{
公共静态void main（字符串[]args）{
发射（args）；
}
@凌驾
公共无效开始（阶段primaryStage）{
setTitle（“你好，世界！”）；
按钮btn=新按钮（）；
btn.setText（“说‘你好，世界’”）；
btn.setOnAction（新的EventHandler
只需在某处创建一个新的非匿名类。我在
HelloWorld
中作为一个嵌套类来创建它：

public class HelloWorld extends Application {
    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {
        primaryStage.setTitle("Hello World!");
        Button btn = new Button();
        btn.setText("Say 'Hello World'");
        btn.setOnAction(new MyEventHandler());

        StackPane root = new StackPane();
        root.getChildren().add(btn);
        primaryStage.setScene(new Scene(root, 300, 250));
        primaryStage.show();
    }

    public class MyEventHandler implements EvenHandler<ActionEven>
    {
        @Override
        public void handle(ActionEvent event) {
            System.out.println("Hello World!");
        }
    }
}

公共类HelloWorld扩展了应用程序{
公共静态void main（字符串[]args）{
发射（args）；
}
@凌驾
公共无效开始（阶段primaryStage）{
setTitle（“你好，世界！”）；
按钮btn=新按钮（）；
btn.setText（“说‘你好，世界’”）；
btn.setOnAction（新的MyEventHandler（））；
StackPane root=新的StackPane（）；
root.getChildren（）.add（btn）；
原始阶段。设置场景（新场景（根，300250））；
primaryStage.show（）；
}
公共类MyEventHandler实现了EvenHandler
{
@凌驾
公共无效句柄（ActionEvent事件）{
System.out.println（“你好，世界！”）；
}
}
}
只需在某个地方创建一个新的非匿名类。我在
HelloWorld
中作为一个嵌套类来创建它：

public class HelloWorld extends Application {
    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {
        primaryStage.setTitle("Hello World!");
        Button btn = new Button();
        btn.setText("Say 'Hello World'");
        btn.setOnAction(new MyEventHandler());

        StackPane root = new StackPane();
        root.getChildren().add(btn);
        primaryStage.setScene(new Scene(root, 300, 250));
        primaryStage.show();
    }

    public class MyEventHandler implements EvenHandler<ActionEven>
    {
        @Override
        public void handle(ActionEvent event) {
            System.out.println("Hello World!");
        }
    }
}

公共类HelloWorld扩展了应用程序{
公共静态void main（字符串[]args）{
发射（args）；
}
@凌驾
公共无效开始（阶段primaryStage）{
setTitle（“你好，世界！”）；
按钮btn=新按钮（）；
btn.setText（“说‘你好，世界’”）；
btn.setOnAction（新的MyEventHandler（））；
StackPane root=新的StackPane（）；
root.getChildren（）.add（btn）；
原始阶段。设置场景（新场景（根，300250））；
primaryStage.show（）；
}
公共类MyEventHandler实现了EvenHandler
{
@凌驾
公共无效句柄（ActionEvent事件）{
System.out.println（“你好，世界！”）；
}
}
}

我不知道该怎么办

创建一个实现所需接口的新类。1
将代码从匿名类移动到新类
无论在何处使用匿名类，都可以通过该类的新实例对其进行更改
将此应用于提供的示例：

class FooEventHandler implements EventHandler<ActionEvent>() {
    @Override
    public void handle(ActionEvent event) {
        System.out.println("Hello World!");
    }
}

public class HelloWorld extends Application {
    //...
    @Override
    public void start(Stage primaryStage) {
        //...
        btn.setOnAction(new FooEventHandler());
        //...
    }
}

类FooEventHandler实现EventHandler（）{
@凌驾
公共无效句柄（ActionEvent事件）{
System.out.println（“你好，世界！”）；
}
}
公共类HelloWorld扩展了应用程序{
//...
@凌驾
公共无效开始（阶段primaryStage）{
//...
setOnAction（新的FooEventHandler（））；
//...
}
}

1：注意，实现接口的类将遵循您编写的任何简单类的规则，这意味着它可以是顶级类、内部类或
静态
内部类

我不知道该怎么办

创建一个实现所需接口的新类。1
将代码从匿名类移动到新类
无论在何处使用匿名类，都可以通过该类的新实例对其进行更改
将此应用于提供的示例：

class FooEventHandler implements EventHandler<ActionEvent>() {
    @Override
    public void handle(ActionEvent event) {
        System.out.println("Hello World!");
    }
}

public class HelloWorld extends Application {
    //...
    @Override
    public void start(Stage primaryStage) {
        //...
        btn.setOnAction(new FooEventHandler());
        //...
    }
}

类FooEventHandler实现EventHandler（）{
@凌驾
公共无效句柄（ActionEvent事件）{
System.out.println（“你好，世界！”）；
}
}
公共类HelloWorld扩展了应用程序{
//...
@凌驾
公共无效开始（阶段primaryStage）{
//...
setOnAction（新的FooEventHandler（））；
//...
}
}

1：请注意，实现接口的类将遵循您编写的任何简单类的规则，这意味着它可以是顶级类、内部类或
静态的
内部类。
EventHandler
类是无状态的，因此该类的所有实例在功能上都是等效的。我们只需要一个插件执行
handle
操作的类的实例，因为此方法的功能仅取决于传递给它的参数，而不取决于对象的状态，因为它没有任何参数。因此，它应该是单实例。每次调用
setOnAction
为了避免这种情况，可以考虑在私有静态最终字段中存储<代码> EvenHandler 实现的实例，并使用静态工厂方法将其重用如下：

public class HandlerProvider{
private static final EvenHandler<ActionEvent> EVENT_HANDLER=new ActionEventHandler();

public static EvenHandler<ActionEvent> getEventHandler(){
return EVENT_HANDLER;
}
private static class ActionEventHandler implements EvenHandler<ActionEvent>
    {
        @Override
        public void handle(ActionEvent event) {
            //your action goes here
        }
    }
}

公共类HandlerProvider{
private static final EvenHandler EVENT_HANDLER=new ActionEventHandler（）；
公共静态事件处理程序getEventHandler（）{
返回事件处理程序；
}
私有静态类ActionEventHandler实现EvenHandler
{
@凌驾
公共无效句柄（ActionEvent事件）{
//你的行动就在这里
}
}
}

通过这种方式，您可以避免在每次方法调用时创建不必要的对象。
EventHandler类是无状态的，因此该类的所有实例在功能上都是等效的。我们只需要该类的一个实例来执行
handle
操作，因为该方法的功能仅依赖于参数传递给它，它不依赖于对象的状态，因为它没有任何。因此，它应该是一个单独的。使用匿名类将创建一个新的实例，每次调用到“代码> SETONACTION< /CARC>时。要避免这一点，可以考虑存储<代码> E的实例。