javafx

学习JavaFX可以按如下步骤展开：

学习基础的Java编程语言。

在开始学习JavaFX之前，你需要先了解Java编程语言的基础知识，例如数据类型、类、对象、方法、控制流语句等。如果你已经熟悉Java，可以跳过这一步。

学习JavaFX的基本概念和API。

JavaFX是一个用于构建富客户端应用程序的框架，它包含了许多 UI 组件和特效。为了学习和使用 JavaFX，你需要了解 JavaFX 的基本概念，例如舞台(stage)、场景(scene)、节点(node)和事件(event)，以及 JavaFX 的基本 API。

你可以通过以下方式来学习 JavaFX 的基本概念和 API：

阅读 JavaFX 官方文档；
学习 JavaFX 教程和示例代码。

学习 JavaFX 布局和控件。

JavaFX 提供了很多预定义的布局容器和控件，例如 BorderPane、HBox、VBox、Button、Label、TextField 等。你需要学习如何组合和嵌套这些布局和控件来构建复杂的界面。

你可以通过以下方式来学习 JavaFX 的布局和控件：

阅读 JavaFX 官方文档中的布局和控件部分；
学习 JavaFX 教程和示例代码。

学习 JavaFX 动画和特效。

JavaFX 提供了很多动画和特效，例如缩放、旋转、淡入淡出、呼吸等。这些特效可以帮助你增强你的 UI 界面的交互性和视觉效果。

你可以通过以下方式来学习 JavaFX 的动画和特效：

阅读 JavaFX 官方文档中的动画和特效部分；
学习 JavaFX 教程和示例代码。

实践项目和练习。

学习 JavaFX 最好的方式是通过实践项目和练习来加深理解。你可以自己设计和实现一些小型的应用程序或游戏，也可以参考一些 JavaFX 项目和示例代码。

学习 JavaFX 高级特性和框架。

JavaFX 还提供了一些高级特性和框架，例如 CSS 样式表、FXML 布局、MVC 模式、工具栏和菜单栏等。如果你想更深入的学习 JavaFX，可以学习这些高级特性和框架。

你可以通过以下方式来学习 JavaFX 的高级特性和框架：

阅读 JavaFX 官方文档中的高级特性和框架部分；
学习 JavaFX 教程和示例代码。

总的来说，学习 JavaFX 是一个系统学习的过程，需要有一定的耐心和毅力。希望以上几个步骤可以帮助你开始学习 JavaFX。

Stage

在JavaFX中，Stage是最顶层的UI容器，表示一个窗口或者全屏显示。每个JavaFX应用程序都需要至少一个舞台（Stage），在该舞台上显示应用程序的用户界面。

Stage有以下几个主要的属性和方法：

title：窗口的标题文本；

width 和 height：窗口的宽度和高度；

x 和 y：窗口的位置坐标；

scene：窗口中包含的场景（Scene）对象；

show()：显示窗口；

hide()：隐藏窗口；

close()：关闭窗口。
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class MyApplication extends Application {

    @Override
    public void start(Stage primaryStage) throws Exception {
        // 创建一个根节点，并添加一个标签
        StackPane root = new StackPane();
        Label label = new Label("Hello, World!");
        root.getChildren().add(label);

        // 创建一个场景，并将根节点添加到场景中
        Scene scene = new Scene(root, 300, 200);

        // 将场景设置到舞台上，并设置舞台的标题文本
        primaryStage.setScene(scene);
        primaryStage.setTitle("My Application");

        // 显示窗口
        primaryStage.show();
    }

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

Application

在JavaFX中，Application类是JavaFX应用程序的入口点，它继承自javafx.application.Application。该类包含了一些重要的生命周期方法，可以让我们轻松地创建和管理JavaFX应用程序。

Application类有以下几个主要的生命周期方法：

init()：该方法在启动应用程序时被调用，通常用于初始化应用程序的状态；
start()：该方法在应用程序启动后被调用，它用于创建场景（Scene）对象并将其添加到舞台（Stage）上；
stop()：该方法在应用程序关闭前被调用，它通常用于释放资源和保存状态。

除了上述生命周期方法之外，Application类还包含了一些其他的方法，例如getHostServices()、getParameters()等，可以用于获取应用程序的一些信息和服务。

Pane

在JavaFX中，Pane是一种非常常用的布局容器，用于定位、排列子节点。Pane可以作为一个空的容器使用，也可以直接将子节点添加到Pane中。当子节点被添加到Pane中时，默认情况下，它们会覆盖掉原来在同一位置的所有节点。

Pane有许多不同的具体实现类，包括:

    StackPane: 叠放布局容器，可以让多个子节点堆叠在一起，并控制其顺序。
    HBox: 水平方向布局容器，可以按照从左到右的顺序排列子节点，每个子节点之间的间距是可配置的。
    VBox: 垂直方向布局容器，可以按照从上到下的顺序排列子节点，每个子节点之间的间距是可配置的。
    GridPane: 网格布局容器，可以按照行和列对子节点进行定位，每个格子里面的子节点大小是可变的。
    AnchorPane: 锚点布局容器，可以通过设置子节点的上下左右锚点来灵活定位子节点的位置。

StackPane

在JavaFX中，StackPane是一种布局容器，用于将多个子节点叠加在一起。通常情况下，最后添加的子节点会放在最上面，排列顺序与添加顺序相反。

StackPane有以下几个主要的属性和方法：

alignment：子节点在容器中的对齐方式；
getChildren()：获取该容器中所有的子节点，并支持add()、remove()等操作；
setMargin()：设置子节点的外边距（Margin）；
setPadding()：设置容器的内边距（Padding）。

接下来，我们可以通过一个简单的示例来演示StackPane的使用。在这个示例中，我们创建了一个根节点为StackPane的场景，然后向其中添加了两个按钮，一个放置在另一个之上。

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class MyApplication extends Application {

    @Override
    public void start(Stage primaryStage) throws Exception {
        // 创建一个根节点为StackPane的场景
        StackPane root = new StackPane();
        Scene scene = new Scene(root, 300, 200);

        // 添加两个按钮
        Button button1 = new Button("Button 1");
        Button button2 = new Button("Button 2");
        root.getChildren().addAll(button1, button2);

        // 设置button2在button1上面
        StackPane.setAlignment(button1, javafx.geometry.Pos.CENTER);
        StackPane.setAlignment(button2, javafx.geometry.Pos.CENTER);
        StackPane.setMargin(button2, new javafx.geometry.Insets(0, 0, 30, 0));

        // 将场景设置到舞台上，并设置舞台的标题文本
        primaryStage.setScene(scene);
        primaryStage.setTitle("My Application");

        // 显示窗口
        primaryStage.show();
    }

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

在上述代码中，我们首先创建了一个根节点为StackPane的场景。然后，我们创建了两个按钮，并使用getChildren()方法将它们添加到root中。接着，我们使用StackPane.setAlignment()方法和StackPane.setMargin()方法分别设置了button2的居中对齐和距离button1的距离。最后，我们将场景设置到舞台Stage上并显示窗口。

当你运行该应用程序时，会看到一个带有两个按钮的窗口，其中button2被叠加在button1上面，稍微向下偏移一些。

HBox

在JavaFX中，HBox是一种布局容器，用于按照水平方向排列子节点。HBox会将其子节点横向地排列在一条线上，并根据每个子节点的宽度和高度自动调整其大小和位置。可以通过设置spacing属性来控制子节点之间的间距。

HBox类提供了许多有用的方法，例如:

getChildren()：获取HBox中添加的所有子节点。
setSpacing(double value)：设置子节点之间的间距。
setAlignment(Pos value)：设置子节点在HBox中的对齐方式，包括CENTER、TOP_LEFT、BOTTOM_RIGHT等。
setPadding(Insets value)：设置HBox的内边距，即子节点与容器之间的距离。

以下是一个简单的示例，展示了如何使用HBox来排列两个按钮：

在这个例子中，我们创建了两个按钮btn1和btn2，然后创建一个HBox容器，将这两个按钮添加到HBox中，并设置了子节点之间的间距为10像素。最后，我们将HBox作为场景的根节点，并将场景显示在舞台上。

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;

public class HBoxExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        Button btn1 = new Button("Button 1");
        Button btn2 = new Button("Button 2");

        HBox hbox = new HBox();
        hbox.getChildren().addAll(btn1, btn2);
        hbox.setSpacing(10.0);

        Scene scene = new Scene(hbox, 300, 250);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

}
public class HBoxExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        Button btn1 = new Button("Button 1");
        Button btn2 = new Button("Button 2");

        HBox hbox = new HBox();
        hbox.getChildren().addAll(btn1, btn2);
        hbox.setSpacing(10.0);

        Scene scene = new Scene(hbox, 300, 250);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

}

VBox

在JavaFX中，VBox是一种布局容器，用于按照垂直方向排列子节点。VBox会将其子节点纵向地排列在一条线上，并根据每个子节点的宽度和高度自动调整其大小和位置。可以通过设置spacing属性来控制子节点之间的间距。

VBox类提供了许多有用的方法，例如：

getChildren()：获取VBox中添加的所有子节点。
setSpacing(double value)：设置子节点之间的间距。
setAlignment(Pos value)：设置子节点在VBox中的对齐方式，包括CENTER、TOP_LEFT、BOTTOM_RIGHT等。
setPadding(Insets value)：设置VBox的内边距，即子节点与容器之间的距离。

以下是一个简单的示例，展示了如何使用VBox来排列两个标签和一个文本框：

在这个例子中，我们创建了两个标签lbl1和lbl2以及一个文本框textField，并将它们添加到VBox容器中。然后设置了子节点之间的间距、垂直方向对齐方式和内边距。最后，我们将VBox作为场景的根节点，并将场景显示在舞台上。

import javafx.application.Application;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class VBoxExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        Label lbl1 = new Label("Enter your name:");
        TextField textField = new TextField();
        Label lbl2 = new Label("Welcome to JavaFX!");

        VBox vbox = new VBox();
        vbox.getChildren().addAll(lbl1, textField, lbl2);
        vbox.setSpacing(10.0);
        vbox.setAlignment(Pos.CENTER);
        vbox.setPadding(new Insets(20.0));

        Scene scene = new Scene(vbox, 300, 250);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

}

GridPane

在JavaFX中，GridPane是一种布局容器，用于按照网格方式排列子节点。GridPane可以将其子节点排列在行和列的交叉处，并根据每个子节点的大小自动调整其位置和大小。可以使用GridPane来创建表格、面板、表单等等。

GridPane类提供了许多有用的方法，例如：

add(Node child, int columnIndex, int rowIndex)：将一个子节点添加到GridPane中的指定单元格中。
getColumnConstraints()和getRowConstraints()：获取GridPane的列和行约束，用于设置列和行的宽度和高度。
setAlignment(Pos value)：设置GridPane中所有子节点的对齐方式，包括TOP_LEFT、BOTTOM_RIGHT等。
setHgap(double value)和setVgap(double value)：设置GridPane中相邻列和行之间的水平和垂直间距。

以下是一个简单的示例，展示了如何使用GridPane来创建一个2x2的网格，并将标签和按钮添加到其中：

import javafx.application.Application;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.GridPane;
import javafx.stage.Stage;

public class GridPaneExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        Label lbl1 = new Label("Label 1");
        Label lbl2 = new Label("Label 2");
        Button btn1 = new Button("Button 1");
        Button btn2 = new Button("Button 2");

        GridPane gridPane = new GridPane();
        gridPane.add(lbl1, 0, 0);
        gridPane.add(lbl2, 1, 0);
        gridPane.add(btn1, 0, 1);
        gridPane.add(btn2, 1, 1);
        gridPane.setAlignment(Pos.CENTER);
        gridPane.setHgap(10);
        gridPane.setVgap(10);

        Scene scene = new Scene(gridPane, 300, 250);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

}

AnchorPane

JavaFX中的AnchorPane（锚定面板）是一种布局容器，它可以让开发者使用相对位置来放置子节点。在AnchorPane中，我们可以通过设置子节点的上、下、左、右锚定来指定其相对位置。

下面是一个简单的例子，演示了如何使用AnchorPane来布局多个Button：

在这个例子中，我们创建了一个AnchorPane，并添加了四个Button。然后，我们使用setTopAnchor()、setBottomAnchor()、setLeftAnchor()和setRightAnchor()方法来指定每个Button的相对位置。

在AnchorPane布局中，子节点的相对位置可以是相对于父节点（如我们在上面的例子中所做的），也可以是相对于其他子节点。如果你想要更高级的布局，可以使用FXML文件或编程方式来动态设置锚点。

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.AnchorPane;
import javafx.stage.Stage;

public class AnchorPaneExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        AnchorPane anchorPane = new AnchorPane();

        Button button1 = new Button("Button 1");
        AnchorPane.setTopAnchor(button1, 10.0);
        AnchorPane.setLeftAnchor(button1, 10.0);

        Button button2 = new Button("Button 2");
        AnchorPane.setTopAnchor(button2, 50.0);
        AnchorPane.setRightAnchor(button2, 10.0);

        Button button3 = new Button("Button 3");
        AnchorPane.setBottomAnchor(button3, 10.0);
        AnchorPane.setLeftAnchor(button3, 10.0);

        Button button4 = new Button("Button 4");
        AnchorPane.setBottomAnchor(button4, 10.0);
        AnchorPane.setRightAnchor(button4, 10.0);

        anchorPane.getChildren().addAll(button1, button2, button3, button4);

        Scene scene = new Scene(anchorPane, 300, 250);

        primaryStage.setTitle("AnchorPane Example");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

}

SplitPane 是一个 JavaFX 布局控件，用于将窗口或面板分割成两个或多个可调整大小的区域。SplitPane 控件通常用于实现一个拆分视图，例如拆分编辑器、文件资源管理器，或者是将多个 UI 元素排列在一起。

SplitPane 可以自动调整大小（默认情况下是开启的），所以即使您将其大小设置为固定值，用户仍然可以使用鼠标拖动分隔条来改变 SplitPane 中每个区域的大小。您可以使用 setResizableWithParent 方法禁用节点调整大小，如果第二个参数设置为 false，那么节点不会随着 SplitPane 大小的改变而调整大小。

以下是一个 SplitPane 示例代码：

FlowPane

在JavaFX中，FlowPane是一个用于自动布局的控件，它可以将子节点按顺序排列，并在需要时自动换行。FlowPane通常用于显示一组相关的UI元素，比如标签、按钮或图像等。

FlowPane继承自Pane类，因此它拥有Pane类的所有功能。FlowPane使用wrapText属性来控制换行，当wrapText为true时，如果子节点的宽度大于FlowPane的宽度，则自动换行。FlowPane还提供了许多其他控制布局和外观的属性和方法。

下面是一些常用的FlowPane属性和方法：

setHgap(double value)和setVgap(double value)：设置FlowPane内子节点之间的水平和垂直间距。
setPadding(Insets value)：设置FlowPane的内边距。
setPrefWrapLength(double value)：设置FlowPane的首选宽度（当wrapText为true时）。
getChildren()：获取FlowPane中的所有子节点。
setOrientation(Orientation value)：设置FlowPane排列子节点的方向（水平或垂直）。

下面是一个简单的例子，演示了如何使用FlowPane来布局三个Button，它们会自动换行：

在这个例子中，我们创建了一个FlowPane，并添加了三个Button。由于我们没有设置wrapText属性和首选宽度，FlowPane会自动换行以避免子节点的过度堆叠。

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.FlowPane;
import javafx.stage.Stage;

public class FlowPaneExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        FlowPane flowPane = new FlowPane();

        Button button1 = new Button("Button 1");
        Button button2 = new Button("Button 2");
        Button button3 = new Button("Button 3");

        flowPane.getChildren().addAll(button1, button2, button3);

        Scene scene = new Scene(flowPane, 300, 200);

        primaryStage.setTitle("FlowPane Example");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

}

BorderPane

BorderPane 布局管理器是一个非常常用的布局管理器，它将父容器分成五个区域：顶部、底部、左侧、右侧和中心。每个区域只能放置一个子节点，并且中心区域会被自动拉伸以填充剩余空间。您可以使用 setTop、setBottom、setLeft、setRight 和 setCenter 方法将 UI 元素添加到不同的区域中。例如：

BorderPane borderPane = new BorderPane();

// 添加顶部元素
borderPane.setTop(new Label("这是顶部"));

// 添加底部元素
borderPane.setBottom(new Label("这是底部"));

// 添加左侧元素
borderPane.setLeft(new Label("这是左侧"));

// 添加右侧元素
borderPane.setRight(new Label("这是右侧"));

// 添加中心元素
borderPane.setCenter(new Label("这是中心"));

TilePane

TilePane 布局管理器将子节点排列在多行或单行中，类似于 FlowPane。但与 FlowPane 不同的是，它会尝试使用相等的大小和间距来排列元素，以产生均匀的布局。您可以使用 setHgap 和 setVgap 方法设置元素之间的水平和垂直间距。例如：

TilePane tilePane = new TilePane();

// 设置水平间距和垂直间距
tilePane.setHgap(10);
tilePane.setVgap(10);

// 添加标签和按钮到瓷砖面板中
tilePane.getChildren().add(new Label("这是第一个标签"));
tilePane.getChildren().add(new Button("这是第一个按钮"));
tilePane.getChildren().add(new Label("这是第二个标签"));
tilePane.getChildren().add(new Button("这是第二个按钮"));

Platform

Platform 是 JavaFX 提供的一个类，它包含了许多有用的静态方法，用于执行与 JavaFX 平台或本地系统相关的操作。

以下是一些 Platform 类常用的静态方法及其作用：

runLater()：在 JavaFX 应用程序线程上运行指定的 Runnable 对象。
isFxApplicationThread()：返回当前线程是否为 JavaFX 应用程序线程。
setImplicitExit(boolean)：设置当前 JavaFX 应用程序是否随着所有 JavaFX 窗口的关闭而终止。

此外，Platform 还提供了许多其他有用的方法，例如：

toFxImage(BufferedImage)：将 BufferedImage 对象转换为 JavaFX 中的 Image 对象。
startup(Runnable)：在 JavaFX Application 线程中启动指定的 Runnable，并等待其完成。
exit()：退出 JavaFX 应用程序。

使用这些方法，我们可以更方便地编写 JavaFX 应用程序，并实现一些常见的操作，例如在应用程序线程上运行代码、检查当前线程是否为应用程序线程等。

Control

在JavaFX中，Control是一个极其重要的类，它是所有UI控件类（如Button、Label、TextField等）的基类。Control类提供了许多用于图形界面表示的属性和方法，包括焦点、可见性、不透明度、样式、布局、事件处理等。

下面是一些常用的Control属性和方法：

    isFocused()：如果此控件当前具有输入焦点，则返回true。
    setFocusTraversable(boolean value)：设置此控件是否可以获得键盘输入焦点（默认为true）。
    setVisible(boolean value)：设置此控件是否可见。
    setOpacity(double value)：设置此控件的不透明度（值从0.0到1.0之间）。
    setId(String value)：设置此控件的ID。
    getStyleClass()：获取此控件的样式类列表。
    setPrefSize(double width, double height)：设置此控件的首选大小。
    setLayoutX(double value)和setLayoutY(double value)：设置此控件相对于其父容器的布局位置。
    setOnAction(EventHandler<ActionEvent> value)：为此控件设置一个操作事件处理程序。

除此之外，Control类还有许多其他控制UI的方法和属性，例如设置内边距、布局约束、光标的形状等等。通过继承Control类，我们可以在JavaFX中创建自定义的控件，并使用Control类提供的属性和方法来为这些控件添加UI功能。

Button

在JavaFX中，Button是一种用户界面控件，通常用于触发操作。可以使用Button控件来执行各种任务，例如登录、注册、保存等等。

Button类提供了许多有用的方法，例如：

setText(String text)：设置Button上显示的文本。
setOnAction(EventHandler value)：设置Button被点击时的处理程序。
setGraphic(Node value)：设置Button上显示的图形或图标。
setDisable(boolean value)：设置Button是否可用。

以下是一个简单的示例，演示了如何创建Button控件并使用setOnAction()方法来设置按钮的处理程序：

在这个例子中，我们创建了一个Button控件，将其文本设置为“Click me”，并使用setOnAction()方法将一个lambda表达式作为按钮的处理程序。当用户点击按钮时，程序将在控制台上输出“Hello, world!”。

另外，我们创建了一个StackPane布局容器，并将按钮添加到该容器中。最后，我们创建了一个场景，并将其显示在舞台上。

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class ButtonExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        Button btn = new Button();
        btn.setText("Click me");
        btn.setOnAction(e -> System.out.println("Hello, world!"));

        StackPane root = new StackPane();
        root.getChildren().add(btn);

        Scene scene = new Scene(root, 300, 250);

        primaryStage.setTitle("Button Example");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

}

Label

在JavaFX中，Label类表示一个简单的文本标签。它可以用于显示静态文本或者动态文本，例如显示应用程序的名称、版本号、欢迎语等。

Label类有以下几个主要的属性和方法：

text：标签的文本内容；
font：标签文本的字体；
textFill：标签文本的颜色；
wrapText：是否自动换行；
setText(String text)：设置标签的文本内容；
setFont(Font font)：设置标签文本的字体；
setTextFill(Paint fill)：设置标签文本的颜色；
setWrapText(boolean wrapText)：设置是否自动换行。

import javafx.application.Application;
import javafx.geometry.Insets;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.layout.StackPane;
import javafx.scene.paint.Color;
import javafx.scene.text.Font;
import javafx.stage.Stage;

/**
 * Label
 */
public class MyApplication extends Application {

    @Override
    public void start(Stage primaryStage) throws Exception {
        // 创建一个标签，并设置其文本、字体、颜色等属性
        Label label = new Label("Hello, World!");
        label.setFont(Font.font("Arial", 12));
        label.setTextFill(Color.BLUE);

        // 创建一个根节点，并将标签添加到其中
        StackPane root = new StackPane();
        root.setPadding(new Insets(10));
        root.getChildren().add(label);

        // 创建一个场景，并将根节点添加到场景中
        Scene scene = new Scene(root, 300, 200);

        // 将场景设置到舞台上，并设置舞台的标题文本
        primaryStage.setScene(scene);
        primaryStage.setTitle("My Application");

        // 显示窗口
        primaryStage.show();
    }

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

TextField

在JavaFX中，TextField是一种用户输入控件，允许用户输入单行文本。可以使用TextField控件来接收用户输入的数据，例如用户名、密码、搜索关键字等等。

TextField类提供了许多有用的方法，例如：

getText()：获取TextField中的文本。
setText(String text)：设置TextField中的文本。
setPromptText(String prompt)：设置TextField中的提示文本，当TextField没有文本时，会显示该提示文本。
setEditable(boolean value)：设置TextField是否可编辑。
setPrefColumnCount(int value)：设置TextField的首选列数，即控件默认的宽度。

以下是一个简单的示例，演示了如何创建TextField控件并使用getText()方法获取用户输入的文本：

在这个例子中，我们创建了一个标签lbl、一个TextField控件和一个按钮btn。然后将它们添加到VBox容器中，并设置场景的根节点为该容器。当用户点击按钮时，程序将使用getText()方法获取TextField中的文本，并在控制台上输出欢迎消息。

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class TextFieldExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        Label lbl = new Label("Enter your name:");
        TextField textField = new TextField();
        Button btn = new Button("Submit");

        btn.setOnAction(e -> {
            String name = textField.getText();
            System.out.println("Hello, " + name);
        });

        VBox vbox = new VBox();
        vbox.getChildren().addAll(lbl, textField, btn);

        Scene scene = new Scene(vbox, 300, 250);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

}

JavaFX 中的 ListView 类是一个用于显示列表数据的控件，它可以将列表数据显示为垂直滚动的元素集合。与 ComboBox 和 ChoiceBox 类似，ListView 也采用了 MVC（Model-View-Controller）模式，其中列表数据存储在模型类中，用户通过视图类（即 ListView）来查看、选取和编辑列表。

以下是一个简单的 ListView 示例程序：

上述示例中，我们创建了一个 ListView 控件，并且使用 FXCollections.observableArrayList() 方法将字符串数组包装成可观察的列表。然后，我们获取了选中的项，添加了选中事件监听器。最后，我们将 ListView 添加到根布局 StackPane 中，并将其显示在窗口上。

需要注意的是，ListView 支持自定义单元格显示样式，也支持多选和单选模式，可以通过设置相应的属性来实现。另外，ListView 还可以与 TableView 类一起使用，用于实现更复杂的列表数据显示和编辑功能。

import javafx.application.Application;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.Scene;
import javafx.scene.control.ListView;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class ListViewExample extends Application {

    @Override
    public void start(Stage primaryStage) throws Exception {
        // 创建 ListView 控件并设置数据
        ListView<String> listView = new ListView<>();
        ObservableList<String> items = FXCollections.observableArrayList("Apple", "Banana", "Cherry", "Kiwi", "Orange");
        listView.setItems(items);

        // 获取选中的项
        String selectedItem = listView.getSelectionModel().getSelectedItem();

        // 添加选中事件监听器
        listView.getSelectionModel().selectedItemProperty().addListener((observable, oldValue, newValue) -> {
            System.out.println("Selected item: " + newValue);
        });

        // 设置根布局并添加组件
        StackPane root = new StackPane();
        root.getChildren().add(listView);

        // 创建场景并显示窗口
        Scene scene = new Scene(root, 300, 200);
        primaryStage.setTitle("ListView Example");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

Pos

在JavaFX中，Pos枚举类表示节点的对齐位置。可以将Pos值作为参数传递给布局容器中的方法，以指示子节点在容器中的对齐方式。

Pos枚举类提供了许多有用的值，例如：

TOP_LEFT：左上方对齐。
TOP_CENTER：顶部居中对齐。
TOP_RIGHT：右上方对齐。
CENTER_LEFT：左侧居中对齐。
CENTER：垂直和水平居中对齐。
CENTER_RIGHT：右侧居中对齐。
BOTTOM_LEFT：左下方对齐。
BOTTOM_CENTER：底部居中对齐。
BOTTOM_RIGHT：右下方对齐。

以下是一个简单的示例，演示了如何使用Pos枚举类指定Label节点的对齐方式：

在这个例子中，我们创建了两个标签label1和label2，并分别将它们的对齐方式设置为TOP_LEFT和CENTER。然后我们创建了一个垂直Box容器vbox，并将标签添加到其中。最后，我们将vbox的对齐方式设置为CENTER，并将其作为场景的根节点。

需要注意的是，使用Pos枚举类指定对齐方式只适用于支持对齐操作的布局容器。例如，VBox和HBox都支持此功能，但FlowPane则不支持。

import javafx.application.Application;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class PosExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        Label label1 = new Label("Label 1");
        label1.setAlignment(Pos.TOP_LEFT);

        Label label2 = new Label("Label 2");
        label2.setAlignment(Pos.CENTER);

        VBox vbox = new VBox();
        vbox.getChildren().addAll(label1, label2);
        vbox.setAlignment(Pos.CENTER);

        Scene scene = new Scene(vbox, 300, 250);

        primaryStage.setTitle("Pos Example");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

}

FileChooser 和DirectoryChooser区别

FileChooser和DirectoryChooser都是JavaFX中提供的用于文件操作的类，它们分别用于选择文件和选择目录。虽然它们的功能有所不同，但它们的使用方法类似，都是通过对话框的形式让用户进行选择，并返回所选文件或目录的路径。

FileChooser类提供了一个常见的文件选择对话框，使得用户可以选择需要打开的文件、保存文件等。我们可以设置初始目录（initial directory）和可接受的文件类型（file filters），以便控制文件选择器的行为。

DirectoryChooser类提供了一个用于选择目录的对话框，允许用户选择计算机上的目录，方便地打开和浏览文件系统中的目录，更加简单、可靠地实现JavaFX应用程序的目录操作。

DirectoryChooser

JavaFX中的DirectoryChooser类提供了一个用于选择目录的对话框。它允许用户选择计算机上的目录，以供JavaFX应用程序使用。使用DirectoryChooser类可以方便地打开和浏览文件系统中的目录，从而更加简单、可靠地实现JavaFX应用程序的文件操作。

以下是一个简单的示例代码，演示如何使用JavaFX的DirectoryChooser类，在JavaFX应用程序中打开和选择目录：

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.DirectoryChooser;
import javafx.stage.Stage;
import java.io.File;

public class DirectoryChooserDemo extends Application {

    @Override
    public void start(Stage stage) {
        Button button = new Button("Open Directory");
        DirectoryChooser directoryChooser = new DirectoryChooser();
        button.setOnAction(e -> {
            File selectedDirectory = directoryChooser.showDialog(stage);
            if (selectedDirectory != null) {
                System.out.println(selectedDirectory.getAbsolutePath());
            }
        });
        StackPane root = new StackPane(button);
        Scene scene = new Scene(root, 300, 250);
        stage.setTitle("DirectoryChooser Demo");
        stage.setScene(scene);
        stage.show();
    }

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

FileChooser

JavaFX中的FileChooser类提供了一个用于选择文件的对话框。它允许用户选择计算机上的文件，以供JavaFX应用程序使用。使用FileChooser类可以方便地打开和浏览文件系统中的文件，从而更加简单、可靠地实现JavaFX应用程序的文件操作。

以下是一个简单的示例代码，演示如何使用JavaFX的FileChooser类，在JavaFX应用程序中打开和选择文件：

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.FileChooser;
import javafx.stage.Stage;
import java.io.File;

public class FileChooserDemo extends Application {

    @Override
    public void start(Stage stage) {
        Button button = new Button("Open File");
        FileChooser fileChooser = new FileChooser();
        button.setOnAction(e -> {
            File selectedFile = fileChooser.showOpenDialog(stage);
            if (selectedFile != null) {
                System.out.println(selectedFile.getAbsolutePath());
            }
        });
        StackPane root = new StackPane(button);
        Scene scene = new Scene(root, 300, 250);
        stage.setTitle("FileChooser Demo");
        stage.setScene(scene);
        stage.show();
    }

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

Modality

JavaFX中的Modality是一个枚举类型，可用于指定窗口的模态行为。它定义了三种不同的模态行为：APPLICATION_MODAL、WINDOW_MODAL和NONE。

    APPLICATION_MODAL：这是最高级别的模态行为，表示只有当前应用程序窗口被关闭后，才能继续使用其他窗口。即在弹出的窗口关闭之前，不能操作应用程序的其他窗口。
    WINDOW_MODAL：这种模态行为表示对于同一窗口的其他子窗口是阻塞的，但是不会阻塞其他窗口。即在弹出的窗口关闭之前，不能操作其它窗口，但是可以操作该窗口的父窗口或兄弟窗口。
    NONE：这种模态行为表示不是模态的，即在弹出窗口的同时也可以操作应用程序的其他窗口。
通过设置Modality，可以控制JavaFX应用程序中窗口的行为方式，从而实现更好的用户体验。
在上面的示例代码中，我们创建一个主窗口，当用户单击按钮时，将会弹出一个模态对话框。我们使用initOwner()方法将模态对话框的拥有者设置为主窗口，并使用initModality()方法将其模态行为设置为APPLICATION_MODAL。

总之，Modality是JavaFX中用于指定窗口模态行为的枚举类型。通过设置Modality，可以控制JavaFX应用程序中窗口的行为方式，从而实现更好的用户体验。可以根据不同的场景需求，选择合适的模态行为。

WindowEvent

在JavaFX中，WindowEvent表示与窗口相关的事件。WindowEvent包含了窗口的打开、关闭、激活、最小化、最大化、图标化等事件。这些事件是由窗口管理器负责处理的。当窗口上发生这些事件时，JavaFX会生成相应的WindowEvent事件，并将其传递给窗口上的所有监听器，从而允许应用程序处理这些事件。

JavaFX中提供了一组window相关的事件，常用的有：

WINDOW_SHOWN: 窗口被显示
WINDOW_HIDDEN: 窗口被隐藏
WINDOW_CLOSE_REQUEST: 用户请求关闭窗口（但不一定是实际关闭窗口）
WINDOW_CLOSED: 窗口已经关闭
WINDOW_MINIMIZED: 窗口被最小化
WINDOW_MAXIMIZED: 窗口被最大化
WINDOW_RESTORED: 窗口被恢复

在上面的代码中，我们创建了一个简单的窗口，并添加了一个“关闭窗口”的按钮。当用户单击按钮时，将触发WINDOW_CLOSE_REQUEST事件，我们添加了一个WindowEvent的监听器，当接收到WINDOW_CLOSE_REQUEST事件时，会输出一条消息到控制台。

总之，WindowEvent是JavaFX中表示窗口相关事件的类，通过使用WindowEvent，JavaFX开发人员可以更容易地处理窗口的打开、关闭、最小化、最大化等事件，从而实现更加灵活和友好的用户交互体验。

import javafx.application.Application;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;
import javafx.stage.WindowEvent;

public class MyApplication extends Application {

    @Override
    public void start(Stage primaryStage) {
        Button closeButton = new Button("Close Window");
        closeButton.setOnAction(event -> primaryStage.fireEvent(new WindowEvent(primaryStage, WindowEvent.WINDOW_CLOSE_REQUEST)));

        StackPane root = new StackPane(closeButton);
        Scene scene = new Scene(root, 300, 250);

        primaryStage.setScene(scene);
        primaryStage.setTitle("My Application");
        primaryStage.show();

        // 为主窗口添加关闭事件处理器
        primaryStage.setOnCloseRequest(new EventHandler<WindowEvent>() {
            public void handle(WindowEvent we) {
                System.out.println("Window is closing");
            }
        });
    }

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

Screen

JavaFX的Screen类提供了一种用于描述屏幕的方式，可以用于显示信息和处理窗口的位置和大小等操作。它是JavaFX中一个非常重要的辅助类，因为JavaFX应用程序通常需要访问多个屏幕或监视器。

Screen类提供了一些方法来获取当前系统中的所有屏幕以及每个屏幕的属性，例如分辨率、dpi、可见性、尺寸等等。其中，最重要的属性是bounds属性，它返回一个矩形对象，表示整个屏幕的大小和位置。

此外，Screen类还提供了一个getPrimary方法，它返回默认的主屏幕。这在多个屏幕的环境中特别有用，因为它允许开发人员选择在哪个屏幕上创建JavaFX应用程序的主窗口。

以下是一个简单的示例代码，演示如何使用JavaFX的Screen类获取当前系统中的所有屏幕，并输出每个屏幕的分辨率和位置等信息：

总之，Screen类是JavaFX中极其重要的一个类，它提供了获取屏幕信息和处理多个屏幕的能力。使用它可以让JavaFX应用程序更好地适应多屏幕环境，并且可以通过JavaFX应用程序知道用户屏幕的配置，以便更好地呈现内容和用户体验。

package com.example.javafxproject;

import javafx.application.Application;
import javafx.collections.ObservableList;
import javafx.geometry.Rectangle2D;
import javafx.scene.Scene;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Screen;
import javafx.stage.Stage;

public class ScreenDemo extends Application {

    @Override
    public void start(Stage stage) {
        ObservableList<Screen> screens = Screen.getScreens();
        for (Screen screen : screens) {
            Rectangle2D bounds = screen.getBounds();
            Rectangle rect = new Rectangle(bounds.getWidth(), bounds.getHeight());
            rect.setFill(Color.LIGHTGRAY);
            Pane pane = new Pane();
            pane.getChildren().addAll(rect);
            Scene scene = new Scene(pane, bounds.getWidth(), bounds.getHeight());
            Stage newStage = new Stage();
            newStage.setX(bounds.getMinX());
            newStage.setY(bounds.getMinY());
            newStage.setWidth(bounds.getWidth());
            newStage.setHeight(bounds.getHeight());
            newStage.setTitle("Screen " + screens.indexOf(screen));
            newStage.setScene(scene);
            newStage.show();
            System.out.println("Screen " + screens.indexOf(screen));
            System.out.println("\tBounds: " + bounds);
            System.out.println("\tVisual Bounds: " + screen.getVisualBounds());
            System.out.println("\tDPI: " + screen.getDpi());
          //  System.out.println("\tOrientation: " + screen.getOrientation());
        }
    }

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

SimpleBooleanProperty

JavaFX 的 SimpleBooleanProperty 是一个可观察的布尔属性，它继承自 BooleanProperty 接口和 ObservableValue 接口。通过使用 SimpleBooleanProperty，我们可以创建一个布尔值并追踪其更改，当属性的值发生变化时，我们可以在应用程序中自动进行响应。

下面是 SimpleBooleanProperty 的简单示例：

上述示例中，我们创建了一个初始值为 false 的 SimpleBooleanProperty，并添加了一个属性更改监听器。我们接着更新了该属性的值，并输出了当前的属性值。

需要注意的是，在更改属性的值时，我们必须使用 set() 方法而不能直接修改属性的值，这样才能确保应用程序正确地检测到属性值的更改。

使用 SimpleBooleanProperty，我们可以方便地实现许多 UI 控件的行为，例如开关按钮、复选框等，同时也可以用作模型和控制器之间的通信机制。

import javafx.beans.property.SimpleBooleanProperty;

public class SimpleBooleanPropertyExample {
    public static void main(String[] args) {
        // 创建一个 SimpleBooleanProperty 对象，并设置初始值为 false
        SimpleBooleanProperty booleanProperty = new SimpleBooleanProperty(false);

        // 添加属性更改监听器
        booleanProperty.addListener((observable, oldValue, newValue) -> {
            System.out.println("Boolean property changed: " + oldValue + " -> " + newValue);
        });

        // 更改属性的值
        booleanProperty.set(true);

        // 输出当前属性值
        System.out.println("Current boolean property value: " + booleanProperty.get());
    }
}

Group

在这个示例中，我们首先创建了一个 Group 对象，并向其中添加了两个矩形。然后，我们将 Group 添加到场景中，并将场景设置为 primaryStage 的场景。最后，我们显示 primaryStage 窗口。

需要注意的是，由于 Group 不会对其子节点进行任何布局处理，因此它们可能会重叠在一起或超出 Group 的边界。如果你需要对子节点进行布局处理，则可能需要使用其他布局容器类，如 VBox、HBox 或 GridPane 等。

Group 是 JavaFX 中的一个布局容器类，它不会对其子节点进行任何布局处理。相反，它只是简单地将所有子节点放在一起，使它们共享同一个父节点。这使得 Group 成为放置一些不需要进行布局处理的节点的好选择，例如用于显示静态图像或文本的节点。

  public void start(Stage primaryStage) {
        // 创建一个 Group
        Group group = new Group();

        // 往 Group 中添加两个矩形
        Rectangle rect1 = new Rectangle(50, 50, 100, 100);
        rect1.setFill(Color.RED);
        Rectangle rect2 = new Rectangle(100, 100, 100, 100);
        rect2.setFill(Color.BLUE);
        group.getChildren().addAll(rect1, rect2);

        // 创建一个场景，并将 Group 添加到其中
        Scene scene = new Scene(group, 300, 250);

        // 设置场景并显示窗口
        primaryStage.setTitle("Group Demo");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

TextArea

JavaFX 的 TextArea 类是一个文本区域控件，可以用于显示和编辑多行文本。TextArea 继承自 TextInputControl 类，提供丰富的 API 用于操作和获取文本内容、选择文本范围、设置光标位置等。同时，TextArea 支持文本选择、拖拽、撤销和重做等功能。

上述示例中创建了一个 TextArea 控件，并设置了文本内容、选择文本范围、插入和删除文本、设置光标位置等。最后将 TextArea 添加到根布局 StackPane 中，创建场景并显示窗口。

需要注意的是，TextArea 支持多行文本显示和编辑，可以通过设置行数和列数来控制文本区域的大小。同时，TextArea 还支持滚动条和换行等属性的设置，可以进一步扩展其功能。

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.TextArea;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class TextAreaExample extends Application {

    @Override
    public void start(Stage primaryStage) throws Exception {
        // 创建一个 TextArea 控件
        TextArea textArea = new TextArea();

        // 设置文本内容
        textArea.setText("Hello, World! This is a TextArea.");

        // 获取文本内容
        String text = textArea.getText();

        // 选择文本范围
        textArea.selectRange(0, 5);

        // 插入文本
        textArea.insertText(6, "JavaFX ");

        // 删除文本
        textArea.deleteText(13, 20);

        // 设置光标位置
        textArea.positionCaret(10);

        // 创建根布局并添加组件
        StackPane root = new StackPane();
        root.getChildren().add(textArea);

        // 创建场景并显示窗口
        Scene scene = new Scene(root, 300, 200);
        primaryStage.setTitle("TextArea Example");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

Rectangle

Rectangle 是 JavaFX 中的一个基本形状类，用于绘制一个矩形。它提供了多种构造方法和属性来控制矩形的大小、位置、颜色、边框等。

Rectangle rect = new Rectangle(50, 50, 100, 100);
rect.setFill(Color.WHITE);
rect.setStroke(Color.RED);
rect.setStrokeWidth(5);
rect.setArcWidth(20);
rect.setArcHeight(20);

ScheduledService

ScheduledService 是 JavaFX 中的一个类，用于创建定时任务（周期性或延迟）并在 JavaFX 应用程序线程中执行它们。它继承自 Service 类，并在此基础上增加了定时执行的功能。

TODO

posted @ 2022-08-12 18:38 三号小玩家阅读(701) 评论(0) 收藏举报

刷新页面返回顶部

三号小玩家