天景科技苑

这个屌丝很懒，什么也没留下！

热门标签

GUI ——（java的图形界面）快速入门_java gui

作者：天景科技苑 | 2024-07-20 15:12:11

踩

java gui

我们公司做了一个给用户上传医疗影像和心电图的工具，是用 java GUI 做的。所以先补充一下 GUI 的东西应对突如其来的紧急情况。

从我们公司的产品来看，GUI 虽然不美观，但是它仍然有它的优点，如果通过网页上传，只能用户去选择文件夹，但是如果通过 java GUI 界面，就可以在 GUI 工具中配置需要扫描的文件夹路径，这样省去了用户选择文件的步骤，更加简单易用。在医疗界，有些老阿姨，老伯伯不太会使用 web 网页，简单的步骤还是很有必要的。

这里有篇写的很好的 GUI 入门博客：（十六）Java GUI（窗口）编程_java 创建 gui 窗口-CSDN 博客

里面讲的挺仔细的，开始来学习学习。

GUI 简单介绍

GUI，即图形用户界面，是用户与程序交互的主要方式之一。Java 提供了一组 GUI 工具包，可以帮助开发者创建美观、易于使用的应用程序。GUI（图形用户界面）编程是开发一个应用程序的重要组成部分。它影响了用户与软件的交互方式，使人们能够通过直观的图形界面与程序进行操作。Java 作为一门广泛应用于各领域的编程语言，其 GUI 编程能力也非常强大。

下面，我将详细整理 Java GUI 编程的基本概念、组件、布局管理器以及事件处理等方面的知识。

Java GUI 编程基础

Java 提供了丰富的 GUI 组件库，用于创建各种图形用户界面。Java 开发 GUI 的主要框架是 AWT（Abstract Window Toolkit）和 Swing。Swing 是基于 AWT 构建的，因此 Swing 组件也可以与 AWT 组件兼容。AWT 代表抽象窗口工具包，是 Java 最早的 GUI 工具包。Swing 是 AWT 的改进版，提供了更多的组件和更好的外观。这两个工具包都包含一组组件，可以用于构建 GUI 应用程序。

Java GUI 编程的核心是事件处理。事件是用户与程序之间的交互，例如单击按钮或选择复选框。Java 提供了事件模型，开发者可以使用它来处理事件。事件模型由事件源、事件对象、事件监听器和事件处理器组成。事件源是发出事件的组件，事件对象是事件的描述，事件监听器是负责处理事件的对象，事件处理器是实际处理事件的方法。

Java GUI 编程需要开发者熟悉一些基本概念，例如布局管理器、组件和容器。布局管理器用于控制组件在容器中的位置和大小。Java 提供了多个布局管理器，包括边界布局、流布局和网格布局。组件是 GUI 的基本构建块，例如按钮、标签和文本框。容器是包含组件的对象，例如面板和对话框。

AWT 工具包

AWT 是 Java 中最早的 GUI 工具包，它提供了一组基础的 GUI 组件和窗口管理器，可以用于创建简单的 GUI 应用程序。以下是 AWT 工具包的一些常用组件和用法：

Frame（框架）

用于创建顶级窗口，可以添加其他组件。

public class MyFrame extends JFrame {
    public MyFrame(String frameName) {
        super(frameName);
        setSize(400, 300);
        setVisible(true);
    }

    public static void main(String[] args) {
        new MyFrame("My frame");
    }
}
1
2
3
4
5
6
7
8
9
10
11

Panel（面板）

用于创建中间容器，可以添加其他组件。

public class MyPanel extends JFrame {
    public MyPanel() {
        super("My Panel");
        setSize(400, 300);
        Panel panel = new Panel();
        panel.setBackground(Color.RED);
        add(panel);
        setVisible(true);
    }

    public static void main(String[] args) {
        new MyPanel();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Button（按钮）

用于创建按钮，可以添加事件监听器。

public class MyButton extends Frame implements ActionListener {
    public MyButton() {
        super("My Button");
        setSize(400, 300);
        Button button = new Button("Click me");
        button.addActionListener(this);
        add(button);
        setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        System.out.println("Button clicked");
    }

    public static void main(String[] args) {
        new MyButton();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Label（标签）

用于创建文本标签。

public class MyLabel extends Frame {
    public MyLabel() {
        super("My Label");
        setSize(400, 300);
        Label label = new Label("Hello, World!");
        add(label);
        setVisible(true);
    }

    public static void main(String[] args) {
        new MyLabel();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

TextField（文本框）

用于创建文本输入框，可以添加事件监听器。

public class MyTextField extends Frame implements ActionListener {
    private TextField textField;

    public MyTextField() {
        super("My TextField");
        setSize(400, 300);
        textField = new TextField();
        textField.addActionListener(this);
        add(textField);
        setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        System.out.println("Text entered: " + textField.getText());
        textField.setText("");
    }

    public static void main(String[] args) {
        new MyTextField();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

以上是 AWT 工具包中的一些常用组件和用法。虽然 AWT 工具包已经被更先进的 Swing 和 JavaFX 工具包所取代，但是了解和掌握 AWT 工具包仍然有助于理解 Java GUI 编程的基本原理和概念。

Swing 概述

Swing 是 Java 的一个扩展包，包含了丰富的 GUI 组件，用于创建图形用户界面。Swing 组件以 “J” 开头，例如 JFrame、JButton 等。与 AWT 相比，Swing 组件更加轻量级，具有更好的可定制性、可移植性和可扩展性。

要使用 Swing 组件，需要导入以下包：

import javax.swing.*;
1

创建一个简单的 Swing 窗口

我们从创建一个简单的 Swing 窗口开始。以下是一个创建空白窗口的示例代码：

public class SimpleSwingWindow {
    public static void main(String[] args) {
        // 创建一个 JFrame 实例
        JFrame frame = new JFrame("My Simple Swing Window");
        // 设置窗口关闭时的操作
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 设置窗口的大小
        frame.setSize(400, 300);
        // 设置窗口可见
        frame.setVisible(true);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

在上述代码中，我们首先创建了一个 JFrame 实例，并设置了窗口标题。然后，通过 setDefaultCloseOperation() 方法设置了关闭窗口时的操作，接下来设置了窗口的大小，最后，将窗口设置为可见。

Swing 组件

Swing 组件是构建 GUI 应用程序的基石。Swing 提供了丰富的组件，如按钮、文本框、标签等。

按钮（JButton）
JButton 是一个标准的按钮组件，用户可以点击它来触发某种操作。下面是一个创建按钮的示例：
```
JButton button = new JButton("Click me!");
1
```
标签（JLabel）
JLabel 是一个用于显示文本、图像或两者的组件。下面是一个创建文本标签的示例：
```
JLabel label = new JLabel("Hello, Swing!");
1
```
文本框（JTextField）
JTextField 是一个允许用户输入单行文本的组件。下面是一个创建文本框的示例：
```
JTextField textField = new JTextField(20);
1
```
文本区域（JTextArea）
JTextArea 是一个允许用户输入多行文本的组件。下面是一个创建文本区域的示例：
```
JTextArea textArea = new JTextArea(5, 20);
1
```
复选框（JCheckBox）
JCheckBox 是一个允许用户通过选中或取消选中来表示二进制选择的组件。下面是一个创建复选框的示例：
```
JCheckBox checkBox = new JCheckBox("Check me!");
1
```

单选按钮（JRadioButton）
JRadioButton 与 JCheckBox 类似，但一组单选按钮中只能选择一个。要将一组单选按钮关联在一起，需要使用 ButtonGroup。下面是一个创建单选按钮的示例：

JRadioButton radioButton1 = new JRadioButton("Option 1");
JRadioButton radioButton2 = new JRadioButton("Option 2");
ButtonGroup buttonGroup = new ButtonGroup();
buttonGroup.add(radioButton1);
buttonGroup.add(radioButton2);
1
2
3
4
5

下拉列表（JComboBox）
JComboBox 是一个允许用户从列表中选择一个选项的组件。下面是一个创建下拉列表的示例：
```
String[] options = {"Option 1", "Option 2", "Option 3"};
JComboBox<String> comboBox = new JComboBox<>(options);
1
2
```

以上只是 Swing 组件库中的一部分组件，还有很多其他组件可供开发者使用。

布局管理器

布局管理器（Layout Manager）负责管理组件在容器中的位置和大小。Swing 提供了多种布局管理器，如 BorderLayout、FlowLayout、GridLayout 和GridBagLayout等。

BorderLayout
BorderLayout 将容器划分为五个区域：NORTH、SOUTH、EAST、WEST 和 CENTER。 每个区域只能放置一个组件。以下是一个使用 BorderLayout 的示例：

JFrame frame = new JFrame("BorderLayout Example");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400, 300);

frame.setLayout(new BorderLayout());

frame.add(new JButton("North"), BorderLayout.NORTH);
frame.add(new JButton("South"), BorderLayout.SOUTH);
frame.add(new JButton("East"), BorderLayout.EAST);
frame.add(new JButton("West"), BorderLayout.WEST);
frame.add(new JButton("Center"), BorderLayout.CENTER);

frame.setVisible(true);
1
2
3
4
5
6
7
8
9
10
11
12
13

FlowLayout
FlowLayout 是最简单的布局管理器，它将组件按照添加顺序从左到右、从上到下排列。 以下是一个使用 FlowLayout 的示例：

JFrame frame = new JFrame("FlowLayout Example");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400, 300);

frame.setLayout(new FlowLayout());

frame.add(new JButton("Button 1"));
frame.add(new JButton("Button 2"));
frame.add(new JButton("Button 3"));

frame.setVisible(true);
1
2
3
4
5
6
7
8
9
10
11

GridLayout
GridLayout 将容器划分为指定数量的行和列，组件按照添加顺序从左到右、从上到下填充单元格。 以下是一个使用 GridLayout 的示例：

JFrame frame = new JFrame("GridLayout Example");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400, 300);

frame.setLayout(new GridLayout(3, 2));  //指定行数和列数

frame.add(new JButton("Button 1"));
frame.add(new JButton("Button 2"));
frame.add(new JButton("Button 3"));
frame.add(new JButton("Button 4"));
frame.add(new JButton("Button 5"));
frame.add(new JButton("Button 6"));

frame.setVisible(true);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

GridBagLayout
GridBagLayout 是最灵活的布局管理器，可以以任何方式布置组件。

事件处理

事件处理是 GUI 编程的核心。 在 Java 中，事件处理使用监听器（Listener）实现。监听器是一个实现了特定接口的对象，用于监听组件的事件。当事件发生时，监听器将执行相应的操作。

Java 提供了许多事件类型，如 ActionEvent、MouseEvent 和 KeyEvent 。我们可以使用事件监听器来处理这些事件。

ActionEvent

ActionEvent是 Swing 中的一个重要事件，可以用于响应用户的操作事件，例如按钮点击、菜单选择等。 以下是一些常用的ActionEvent处理方法：

添加ActionListener监听器

可以通过添加 ActionListener 监听器来监听用户的操作事件，例如按钮点击事件。以下是示例代码：

JButton button = new JButton("Click me");
button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        // 处理按钮点击事件
    }
});
1
2
3
4
5
6

获取事件源

可以使用 ActionEvent 的 getSource() 方法获取事件源，例如按钮组件。以下是示例代码：

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        Object source = e.getSource();
        if (source == button) {
            // 处理按钮点击事件
        }
    }
});
1
2
3
4
5
6
7
8

获取事件命令

可以使用 ActionEvent 的getActionCommand()方法获取事件命令，例如按钮上显示的文本。 以下是示例代码：

JButton button1 = new JButton("OK");
button1.setActionCommand("OK");
JButton button2 = new JButton("Cancel");
button2.setActionCommand("Cancel");
button1.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        String command = e.getActionCommand();
        if (command.equals("OK")) {
            // 处理OK按钮点击事件
        } else if (command.equals("Cancel")) {
            // 处理Cancel按钮点击事件
        }
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14

触发事件

可以使用 JButton 的doClick()方法手动触发按钮点击事件。以下是示例代码：

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        // 处理按钮点击事件
    }
});
// 手动触发按钮点击事件
button.doClick();
1
2
3
4
5
6
7

这里给出一个使用 ActionEvent 的示例程序，它创建一个窗口和一个按钮，并在单击按钮时显示一个对话框：

public class ActionEventExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("ActionEvent Example");
        JPanel panel = new JPanel();
        JButton button = new JButton("Click me!");
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JOptionPane.showMessageDialog(frame, "Hello, world!");
            }
        });
        panel.add(button);
        frame.add(panel);
        frame.pack();
        frame.setVisible(true);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个示例程序中，我们创建了一个 JFrame 对象和一个 JPanel 对象。我们创建了一个 JButton 对象，将其添加到面板中，并添加一个 ActionListener 对象。当用户单击按钮时，ActionListener 对象的 actionPerformed() 方法将被调用，并显示一个对话框，显示消息“Hello, world!”。

以上是一些常用的 ActionEvent 处理方法，可以根据实际需要选择合适的方法来处理用户的操作事件。

MouseEvent

MouseEvent 是 Swing 中的一个重要事件，可以用于响应鼠标事件，例如鼠标点击、移动、拖拽等。以下是一些常用的 MouseEvent 处理方法：

添加MouseListener监听器

可以通过添加 MouseListener 监听器来监听鼠标事件，例如鼠标单击事件。以下是示例代码：

JButton button = new JButton("Click me");
button.addMouseListener(new MouseAdapter() {
    public void mouseClicked(MouseEvent e) {
        // 处理鼠标单击事件
    }
});
1
2
3
4
5
6

鼠标单击事件

鼠标单击事件在鼠标按下并释放后触发，可以使用 MouseEvent 的getClickCount()方法获取点击次数。以下是示例代码：

button.addMouseListener(new MouseAdapter() {
    public void mouseClicked(MouseEvent e) {
        int clicks = e.getClickCount();
        if (clicks == 1) {
            // 处理单击事件
        } else if (clicks == 2) {
            // 处理双击事件
        }
    }
});
1
2
3
4
5
6
7
8
9
10

鼠标移动事件

鼠标移动事件在鼠标移动时触发，可以使用 MouseEvent 的getX()和getY()方法获取鼠标当前位置。以下是示例代码：

button.addMouseMotionListener(new MouseMotionAdapter() {
    public void mouseMoved(MouseEvent e) {
        int x = e.getX();
        int y = e.getY();
        // 处理鼠标移动事件
    }
});
1
2
3
4
5
6
7

鼠标拖拽事件

鼠标拖拽事件在鼠标按下并移动时触发，可以使用MouseEvent 的 getX()和getY()方法获取鼠标当前位置，也可以使用 MouseEvent 的getPoint()方法获取鼠标当前位置的坐标。以下是示例代码：

button.addMouseListener(new MouseAdapter() {
    public void mousePressed(MouseEvent e) {
        // 记录鼠标按下时的位置
        startX = e.getX();
        startY = e.getY();
    }
});
button.addMouseMotionListener(new MouseMotionAdapter() {
    public void mouseDragged(MouseEvent e) {
        int endX = e.getX();
        int endY = e.getY();
        // 计算鼠标移动距离
        int dx = endX - startX;
        int dy = endY - startY;
        // 更新组件位置
        button.setLocation(button.getX() + dx, button.getY() + dy);
        // 更新鼠标按下时的位置
        startX = endX;
        startY = endY;
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

以上是一些常用的MouseEvent处理方法，可以根据实际需要选择合适的方法来处理鼠标事件。同时，还可以通过其他MouseEvent方法获取更多鼠标事件相关信息，例如鼠标按钮、鼠标滚轮等。

KeyEvent

KeyEvent 是 Swing 中的一个重要事件，可以用于响应键盘事件，例如按键、释放、敲击等。以下是一些常用的 KeyEvent 处理方法：

添加 KeyListener 监听器

可以通过添加 KeyListener 监听器来监听键盘事件，例如按键事件。以下是示例代码：

JTextField textField = new JTextField();
textField.addKeyListener(new KeyAdapter() {
    public void keyPressed(KeyEvent e) {
        // 处理按键事件
    }
});
1
2
3
4
5
6

获取键码

可以使用 KeyEvent 的getKeyCode()方法获取键码，例如按下的是哪个键。以下是示例代码：

textField.addKeyListener(new KeyAdapter() {
    public void keyPressed(KeyEvent e) {
        int keyCode = e.getKeyCode();
        if (keyCode == KeyEvent.VK_ENTER) {
            // 处理回车键按下事件
        }
    }
});
1
2
3
4
5
6
7
8

获取字符

可以使用 KeyEvent 的getKeyChar()方法获取字符，例如按下的是哪个字符。以下是示例代码：

textField.addKeyListener(new KeyAdapter() {
    public void keyTyped(KeyEvent e) {
        char c = e.getKeyChar();
        if (c == 'a') {
            // 处理按下a键事件
        }
    }
});
1
2
3
4
5
6
7
8

触发事件

可以使用 JTextField 的setText()方法手动触发文本框内容的改变事件。以下是示例代码：

textField.addKeyListener(new KeyAdapter() {
    public void keyReleased(KeyEvent e) {
        // 处理键释放事件
    }
});
// 手动触发文本框内容的改变事件
textField.setText(textField.getText());
1
2
3
4
5
6
7

以上是一些常用的 KeyEvent 处理方法，可以根据实际需要选择合适的方法来处理键盘事件。同时，还可以通过其他 KeyEvent 方法获取更多事件相关信息，例如事件时间、按键状态等。

EventQueue.invokeLater 更新 GUI 界面

在 Swing 中，所有的 GUI 操作都必须在事件调度线程（Event Dispatch Thread）中执行。如果需要在其他线程中更新 GUI 界面，可以使用 EventQueue.invokeLater()方法，将更新操作加入事件队列中，在事件调度线程中执行。以下是一个使用 EventQueue.invokeLater()的示例代码：
```
EventQueue.invokeLater(new Runnable() {
  public void run() {
      // 在事件调度线程中执行更新操作
  }
});
1
2
3
4
5
```

GUI 多线程编程 —— SwingWorker

在 GUI 编程中，长时间运行的任务会阻塞 GUI 线程，导致 GUI 不响应。因此，我们需要使用多线程来避免这种情况。

下面是一个使用 SwingWorker 的示例程序，它创建一个窗口和一个按钮，并在单击按钮时使用 SwingWorker 来执行长时间运行的任务：

public class SwingWorkerExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("SwingWorker示例");
        JPanel panel = new JPanel();
        JButton button = new JButton("Click me!");
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                new SwingWorker<Void, Integer>() {
                    @Override
                    protected Void doInBackground() throws Exception {
                        for (int i = 0; i < 100; i++) {
                            Thread.sleep(100);
                            publish(i);
                        }
                        return null;
                    }
                    @Override
                    protected void process(List<Integer> chunks) {
                        for (int i : chunks) {
							System.out.println(i);
						}
					}
				}.execute();
			}
		});
		panel.add(button);
		frame.add(panel);
		frame.pack();
		frame.setVisible(true);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

在这个示例程序中，我们创建了一个 JFrame 对象和一个 JPanel 对象。我们创建了一个 JButton 对象，并添加一个 ActionListener 对象。当用户单击按钮时，我们创建了一个 SwingWorker 对象，并使用 doInBackground() 方法执行长时间运行的任务。在这个示例程序中，我们只是休眠 100 毫秒，并迭代 100 次，然后使用 publish()方法发布进度值。 SwingWorker 对象还有一个 process()方法，可以在 GUI 线程中更新进度。在这个示例程序中，我们使用 process()方法输出进度值。

自定义组件

我们可以使用 Java 提供的组件来构建 GUI，如 JButton、JLabel 和 JTextField 。但是，有时候我们需要创建自定义组件来满足特定的需求。

下面是一个使用 JComponent 的示例程序，它创建了一个自定义的组件，显示一个白色的矩形：

public class ColorRectangle extends JComponent {
    private int width, height;
    private Color color;
    public ColorRectangle(int w, int h) {
        width = w;
        height = h;
        color = Color.WHITE;
    }
    public void setColor(Color c) {
        color = c;
        repaint();
    }
    public Dimension getPreferredSize() {
        return new Dimension(width, height);
    }
    public void paintComponent(Graphics g) {
        g.setColor(color);
        g.fillRect(0, 0, width, height);
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("自定义组件示例");
        JPanel panel = new JPanel();
        ColorRectangle component = new ColorRectangle(500, 500);
        panel.add(component);
        frame.add(panel);
        frame.pack();
        frame.setVisible(true);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在这个示例程序中，我们创建了一个 JFrame 对象和一个 JPanel 对象。我们创建了一个自定义组件 ColorRectangle，并将其添加到面板中。我们重写了 ColorRectangle 的 paintComponent() 方法，以绘制一个红色的矩形。最后，我们将面板添加到窗口中，并将窗口设置为可见。

JavaFX 概述

JavaFX 是 Java 的第三个 GUI 工具包，它是为 Java SE 8 及更高版本开发的。JavaFX 提供了许多现代化的 GUI 组件，如 TableView、TreeTableView、TreeView 等。JavaFX 还支持 CSS 样式表和 FXML 文件，使 GUI 设计更加灵活，它用于构建丰富、交互式的图形用户界面和媒体应用程序。相对于 Swing，JavaFX 提供了更现代化的 UI 设计、更好的性能、更丰富的媒体支持和更容易的可视化效果。

以下是一些 JavaFX GUI 编程中常用的类和组件：

Stage（舞台）
Stage 是 JavaFX 中的顶级容器，表示应用程序的主窗口。可以使用 Stage 类创建和管理应用程序的主窗口，例如设置标题、大小、位置、图标等。
Scene（场景）
Scene 是 JavaFX 中的容器，表示应用程序的一个场景或一个视图。可以在 Scene 中添加和管理应用程序的 UI 组件，例如按钮、标签、文本框等。
Layouts（布局）
JavaFX 提供了多种布局管理器来帮助开发者设计和管理 UI 界面的布局。例如，HBox 和 VBox 可以用于水平和垂直布局，BorderPane 可以用于边框式布局，GridPane 可以用于网格布局等。
Controls（控件）
JavaFX 提供了多种 UI 控件，例如按钮、标签、文本框、下拉框、列表框、滑块等，可以用于构建应用程序的用户界面。
Effects（效果）
JavaFX 提供了多种 UI 效果，例如阴影、模糊、颜色调整等，可以用于改善应用程序的视觉效果。
Media（媒体）
JavaFX 提供了多种媒体支持，例如音频、视频、动画等，可以用于创建交互式的媒体应用程序。

下面是一个简单的 JavaFX 示例程序，它创建一个窗口和一个按钮：

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

    public void start(Stage stage) {
        Button button = new Button("Click me!");
        button.setOnAction(new EventHandler<ActionEvent>() {
            public void handle(ActionEvent e) {
                System.out.println("Button clicked!");
            }
        });
        VBox layout = new VBox(button);
        Scene scene = new Scene(layout);
        stage.setScene(scene);
        stage.setTitle("JavaFX Example");
        stage.show();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在这个示例程序中，我们创建了一个 Stage 对象，将其命名为“JavaFX Example”，并创建了一个 Button 对象，将其命名为“Click me!”

我们将一个 EventHandler 对象添加到按钮上，以便在单击按钮时执行某些操作（在这种情况下，我们只是打印一条消息）。我们创建了一个 VBox 布局，将按钮添加到其中，并创建了一个 Scene 对象，将布局添加到其中。最后，我们将场景设置为窗口的场景，并将窗口设置为可见。

如果您认为对您有帮助，欢迎关注我的公众号，分享前沿技术与码农日常
在这里插入图片描述

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/天景科技苑/article/detail/857364