Java 中文官方教程 2022 版（十五）

原文：docs.oracle.com/javase/tutorial/reallybigindex.html

文本组件 API

原文：docs.oracle.com/javase/tutorial/uiswing/components/textapi.html

本节列出了文本组件共享的常用 API 部分。这些 API 大部分由JTextComponent类定义。文本组件特性讨论了如何使用部分 API。

JComponent 类描述了文本组件从JComponent继承的 API。有关特定文本组件相关的 API 信息，请参阅该组件的操作页面：文本字段、密码字段、格式化文本字段、文本区域或编辑器窗格和文本窗格。

有关文本 API 的完整详细信息，请参阅JTextComponent的 API 文档以及text package中各种类和接口的文档。

本节列出的 API 包括以下类别：

设置属性
选择操作
在模型和视图之间转换位置
文本编辑命令
表示文档的类和接口
处理文档
操作插入符和选择高亮器
读取和写入文本

设置属性

这些方法在JTextComponent类中定义。

方法	描述
void setEditable(boolean) boolean isEditable()	设置或指示用户是否可以编辑文本组件中的文本。
void setDragEnabled(boolean) boolean getDragEnabled()	设置或获取`dragEnabled`属性，必须为 true 才能在此组件上启用拖放处理。默认值为 false。有关更多详细信息，请参阅拖放和数据传输。
void setDisabledTextColor(Color) Color getDisabledTextColor()	设置或获取文本组件被禁用时用于显示文本的颜色。
void setMargin(Insets) Insets getMargin()	设置或获取文本与文本组件边框之间的边距。

操作选择

这些方法在JTextComponent类中定义。

方法	描述
String getSelectedText()	获取当前选定的文本。
void selectAll() void select(int, int)	选择所有文本或选择起始和结束范围内的文本。

| void setSelectionStart(int) void setSelectionEnd(int)

int getSelectionStart()

int getSelectionEnd() | 通过索引设置或获取当前选择的范围。 |

void setSelectedTextColor(Color) Color getSelectedTextColor()	设置或获取选定文本的颜色。
void setSelectionColor(Color) Color getSelectionColor()	设置或获取选定文本的背景颜色。

在模型和视图之间转换位置

这些方法在JTextComponent类中定义。

方法	描述
int viewToModel(Point)	将视图坐标系中的指定点转换为文本中的位置。
Rectangle modelToView(int)	将文本中指定位置转换为视图坐标系中的矩形。

文本编辑命令

类或方法	描述

| void cut() void copy()

void paste()

void replaceSelection(String)

(在JTextComponent中) | 使用系统剪贴板剪切、复制和粘贴文本，或分别用参数指定的字符串替换所选文本。 |

EditorKit	提供文本组件的视图工厂、文档、插入符号和操作，以及读取和写入特定格式的文档。
DefaultEditorKit	`EditorKit`的具体子类，提供基本的文本编辑功能。
StyledEditorKit	`Default EditorKit`的子类，为带样式文本提供额外的编辑功能。
字符串 xxxx操作 (在`DefaultEditorKit`中)	默认编辑器工具支持的所有操作的名称。请参见将文本操作与菜单和按钮关联。

(在DefaultEditorKit中) | 实现各种文本编辑命令的内部类。 |

(在StyledEditorKit中) | 实现各种编辑命令以处理带样式文本的内部类。 |

Action[] getActions() (在`JTextComponent`中)	获取此组件支持的操作。如果组件使用编辑器工具包，则此方法从编辑器工具包获取操作数组。
InputMap getInputMap() (在`JComponent`中)	获取将键绑定到操作的输入映射。参见将文本操作与键绑定。
void put(KeyStroke, Object) (在`InputMap`中)	将指定的键绑定到指定的操作。通常通过名称指定操作，对于标准编辑操作，使用字符串常量表示，如`DefaultEditorKit.backwardAction`。

代表文档的类和接口

接口或类	描述
文档	定义所有文档必须实现的 API 的接口。
抽象文档	`Document`接口的抽象超类实现。这是 Swing 文本包提供的所有文档的超类。
纯文本文档	实现`Document`接口的类。这是纯文本组件（文本字段、密码字段和文本区域）的默认文档。此外，在加载纯文本或未知格式的文本时，编辑器窗格和文本窗格使用此类。
样式文档	`Document`子接口。定义支持带样式文本的文档必须实现的 API。`JTextPane`要求其文档必须是这种类型。
默认样式文档	实现`StyledDocument`接口的类。`JTextPane`的默认文档。

处理文档

类或方法	描述
DocumentFilter	所有文档过滤器的超类。您可以使用文档过滤器来更改从文档中插入或移除的内容，而无需自己实现文档。参见实现文档过滤器。
void setDocumentFilter(DocumentFilter) (在`AbstractDocument`中)	设置文档过滤器。

| void setDocument(Document) Document getDocument() |

(在JTextComponent中) | 设置或获取文本组件的文档。|

Document createDefaultModel() (在`JTextField`中)	创建一个默认的 PlainDocument 模型。覆盖此方法以创建自定义文档，而不是默认的`PlainDocument`。

| void addDocumentListener(DocumentListener) void removeDocumentListener(DocumentListener) |

(在Document中) | 添加或移除文档监听器。参见监听文档变化。|

| void addUndoableEditListener(UndoableEditListener) void removeUndoableEditListener(UndoableEditlistener) |

(在Document中) | 添加或移除可撤销编辑监听器。可撤销编辑监听器用于实现撤销和重做。|

| int getLength() Position getStartPosition() |

Position getEndPosition()

String getText(int, int) |

(在Document中) | 返回有关文档的各种描述信息的Document方法。|

| Object getProperty(Object) void putProperty(Object, Object)

(在Document中)

void setDocumentProperties(Dictionary)

Dictionary getDocumentProperties()

(在AbstractDocument中) | 一个Document维护一组属性，您可以使用这些方法来操作。 |

操纵插入符和选择高亮器

这些方法在JTextComponent类中定义。

接口、类或方法	描述
插入符	定义表示文档内插入点的对象的 API 的接口。
DefaultCaret	所有文本组件使用的默认插入符。
void setCaret(Caret) Caret getCaret()	设置或获取文本组件使用的插入符对象。
void setCaretColor(Color) Color getCaretColor()	设置或获取插入符的颜色。

| void setCaretPosition(int) void moveCaretPosition(int)

int getCaretPosition() | 设置或获取文档内插入符的当前位置。 |

void addCaretListener(CaretListener) void removeCaretListener(CaretListener)	向文本组件添加或移除插入符监听器。
NavigationFilter	所有导航过滤器的超类。导航过滤器允许您修改即将发生在文本组件中的插入符更改。
void setNavigationFilter(NavigationFilter)	将导航过滤器附加到文本组件。
Highlighter	定义用于突出显示当前选择的对象的 API 的接口。
DefaultHighlighter	所有文本组件使用的默认高亮器。
void setHighlighter(Highlighter) Highlighter getHighlighter()	设置或获取文本组件使用的高亮器。

读取和写入文本

方法	描述

| void read(Reader, Object) void write(Writer)

(在JTextComponent中) | 读取或写入文本。 |

| void read(Reader, Document, int) void read(InputStream, Document, int)

(在EditorKit中) | 从流中读取文本到文档中。 |

| void write(Writer, Document, int, int) void write(OutputStream, Document, int, int)

(在EditorKit中) | 将文本从文档写入流中。 |

如何使用各种组件

原文：docs.oracle.com/javase/tutorial/uiswing/components/componentlist.html

每个页面描述了如何使用特定类型的 Swing 组件。

如何制作小程序
如何使用按钮、复选框和单选按钮
如何使用颜色选择器
如何使用组合框
如何制作对话框
如何使用编辑窗格和文本窗格
如何使用文件选择器
如何使用格式化文本字段
如何制作框架（主窗口）
如何使用内部框架
如何使用标签
如何使用分层窗格
如何使用列表
如何使用菜单
如何使用面板
如何使用密码字段
如何使用进度条
如何使用根窗格
如何使用滚动窗格
如何使用分隔符
如何使用滑块
如何使用微调器
如何使用分割窗格
如何使用选项卡窗格
如何使用表格
如何使用文本区域
如何使用文本字段
如何使用工具栏
如何使用工具提示
如何使用树

如何制作 Applets

原文：docs.oracle.com/javase/tutorial/uiswing/components/applet.html

本节涵盖了JApplet 一个使 applets 能够使用 Swing 组件的类。JApplet是java.applet.Applet的子类，该类在 Java Applets 教程中有介绍。如果你以前从未编写过常规 applet，我们建议你在继续本节之前阅读该教程。该教程中提供的信息也适用于 Swing applets，但本节会解释一些例外情况。

任何包含 Swing 组件的 applet 必须使用JApplet的子类来实现。这里是一个帮助 Java 走红的 applet 的 Swing 版本一个动画 applet（在其最著名的配置中）展示了我们的吉祥物 Duke 在做空翻：

//<![CDATA[ var attributes = { archive: 'https://docs.oracle.com/javase/tutorialJWS/samples/uiswing/TumbleItemProject/TumbleItem.jar', codebase: 'https://docs.oracle.com/javase/tutorialJWS/samples/uiswing/TumbleItemProject', code:'components.TumbleItem', width:'600', height:'95' }; var parameters = { permissions:'sandbox', nimgs:'17', offset:'-57', img: 'images/tumble', maxwidth:'120' }; deployJava.runApplet(attributes, parameters, '1.7'); //]]>

注意： 如果你看不到 applet 运行，你需要安装至少Java SE Development Kit (JDK) 7版本。

你可以在TumbleItem.java中找到这个 applet 的主要源代码。

本节讨论以下主题：

JApplet 提供的功能
Applets 中的线程
在 Swing Applet 中使用图像
在 HTML 页面中嵌入 Applet
JApplet API
Applet 示例

`JApplet` 提供的功能

因为JApplet是一个顶层的 Swing 容器，每个 Swing applet 都有一个根窗格。根窗格存在的最明显效果是支持添加菜单栏和需要使用内容窗格。

如使用顶层容器中所述，每个顶层容器（如JApplet）都有一个内容窗格。内容窗格使得 Swing applets 与常规 applets 有以下不同之处：

你将组件添加到 Swing applet 的内容窗格，而不是直接添加到 applet。向内容窗格添加组件展示了如何操作。
你在 Swing applet 的内容窗格上设置布局管理器，而不是直接在 applet 上设置。
Swing applet 的内容窗格的默认布局管理器是BorderLayout。这与Applet的默认布局管理器FlowLayout不同。
您不应该直接在JApplet对象中放置绘图代码。请参考执行自定义绘图了解如何在小程序中执行自定义绘图的示例。

小程序中的线程

Swing 组件应该在事件分派线程上创建、查询和操作，但浏览器不会从该线程调用小程序的“里程碑”方法。因此，“里程碑”方法——init、start、stop和destroy应该使用SwingUtilities方法invokeAndWait（或者如果适用，invokeLater），以便引用 Swing 组件的代码在事件分派线程上执行。有关这些方法和事件分派线程的更多信息，请参考 Swing 中的并发。

这里是一个init方法的示例：

public void init() {
    //Execute a job on the event-dispatching thread:
    //creating this applet's GUI.
    try {
        javax.swing.SwingUtilities.invokeAndWait(new Runnable() {
            public void run() {
                createGUI();
            }
        });
    } catch (Exception e) {
        System.err.println("createGUI didn't successfully complete");
    }
}

private void createGUI() {
    JLabel label = new JLabel(
                       "You are successfully running a Swing applet!");
    label.setHorizontalAlignment(JLabel.CENTER);
    label.setBorder(BorderFactory.createMatteBorder(1,1,1,1,Color.black));
    getContentPane().add(label, BorderLayout.CENTER);
}

invokeLater方法不适用于这个实现，因为它允许init在初始化完成之前返回，这可能会导致难以调试的小程序问题。

TumbleItem中的init方法更复杂，如下面的代码所示。与第一个示例一样，这个init方法的实现使用SwingUtilities.invokeAndWait在事件分派线程上执行 GUI 创建代码。这个init方法设置了一个 Swing 定时器来触发动画更新的动作事件。此外，init使用javax.swing.SwingWorker创建一个后台任务，加载动画图像文件，让小程序立即呈现 GUI，而不必等待所有资源加载完毕。

private void createGUI() {
    ...
    animator = new Animator();
    animator.setOpaque(true);
    animator.setBackground(Color.white);
    setContentPane(animator);
    ...
}

public void init() {
    loadAppletParameters();

    //Execute a job on the event-dispatching thread:
    //creating this applet's GUI.
    try {
        javax.swing.SwingUtilities.invokeAndWait(new Runnable() {
            public void run() {
                createGUI();
            }
        });
    } catch (Exception e) { 
        System.err.println("createGUI didn't successfully complete");
    }

    //Set up the timer that will perform the animation.
    timer = new javax.swing.Timer(speed, this);
    timer.setInitialDelay(pause);
    timer.setCoalesce(false);
    timer.start(); //Start the animation.

    //Background task for loading images.
    SwingWorker worker = (new SwingWorker<ImageIcon[], Object>() {
            public ImageIcon[] doInBackground() {
                final ImageIcon[] innerImgs = new ImageIcon[nimgs];
            *...//Load all the images...*
            return imgs;
        }
        public void done() {
            //Remove the "Loading images" label.
            animator.removeAll();
            loopslot = -1;
            try {
                imgs = get();
            } *...//Handle possible exceptions*
        }

    }).execute();
}

您可以在TumbleItem.java中找到小程序的源代码。要找到小程序所需的所有文件，请参阅示例索引。

在 Swing 小程序中使用图像

Applet类提供了getImage方法来将图片加载到小程序中。getImage方法创建并返回一个代表加载图片的Image对象。因为 Swing 组件使用Icon而不是Image来引用图片，所以 Swing 小程序往往不使用getImage。相反，Swing 小程序创建ImageIcon的实例，从图像文件加载图标。ImageIcon具有一个节省代码的好处：它自动处理图像跟踪。更多信息请参考如何使用图标。

Duke 做空翻的动画需要 17 张不同的图片。该小程序使用每张图片一个ImageIcon，并在其init方法中加载这些图片。由于图片加载可能需要很长时间，这些图标是在一个SwingWorker对象实现的单独线程中加载的。以下是代码：

public void init() {
    ...
    imgs = new ImageIcon[nimgs];
    (new SwingWorker<ImageIcon[], Object>() {
        public ImageIcon[] doInBackground() {
            //Images are numbered 1 to nimgs,
            //but fill array from 0 to nimgs-1.
            for (int i = 0; i < nimgs; i++) {
                imgs[i] = loadImage(i+1);
            }
            return imgs;
        }
        ...
    }).execute();

}
...
protected ImageIcon loadImage(int imageNum) {
    String path = dir + "/T" + imageNum + ".gif";
    int MAX_IMAGE_SIZE = 2400;  //Change this to the size of
                                 //your biggest image, in bytes.
    int count = 0;
    BufferedInputStream imgStream = new BufferedInputStream(
       this.getClass().getResourceAsStream(path));
    if (imgStream != null) {
        byte buf[] = new byte[MAX_IMAGE_SIZE];
        try {
            count = imgStream.read(buf);
            imgStream.close();
        } catch (java.io.IOException ioe) {
            System.err.println("Couldn't read stream from file: " + path);
            return null;
        }
        if (count <= 0) {
            System.err.println("Empty file: " + path);
            return null;
        }
        return new ImageIcon(Toolkit.getDefaultToolkit().createImage(buf));
    } else {
        System.err.println("Couldn't find file: " + path);
        return null;
    }
}

loadImage 方法为指定的动画帧加载图像。它使用 getResourceAsStream 方法而不是通常的 getResource 方法来获取图像。生成的代码不太美观，但是对于从 JAR 文件加载图像到使用 Java Plug-in™ 软件执行的小程序来说，getResourceAsStream 比 getResource 更有效。有关更多详细信息，请参见将图像加载到小程序中。

在 HTML 页面中嵌入小程序

您可以使用 applet 标签部署一个简单的小程序。或者，您可以使用部署工具包。以下是翻筋斗的杜克小程序的代码：

<script src="https://www.java.com/js/deployJava.js" type="text/javascript">
</script><script type="text/javascript">
//<![CDATA[
    var attributes = { archive: 'https://docs.oracle.com/javase/tutorialJWS/samples/uiswing/TumbleItemProject/TumbleItem.jar',
                       codebase: 'https://docs.oracle.com/javase/tutorialJWS/samples/uiswing/TumbleItemProject',
                       code:'components.TumbleItem', width:'600', height:'95' };
    var parameters = { permissions:'sandbox', nimgs:'17', offset:'-57',
                       img: 'images/tumble', maxwidth:'120' };
    deployJava.runApplet(attributes, parameters, '1.7');
//]]>
</script><noscript>A browser with Javascript enabled is required for this page to operate properly.</noscript>

有关更多信息，请参见部署小程序中的 Java 小程序课程。

小程序 JApplet API

下表列出了 JApplet 添加到小程序 API 中的有趣方法。它们让您访问根窗格提供的功能。您可能使用的其他方法由 Component 和 Applet 类定义。请参见组件方法以获取常用的 Component 方法列表，并参见 Java 小程序以获取有关使用 Applet 方法的帮助。

方法	目的
void setContentPane(Container) Container getContentPane()	设置或获取小程序的内容窗格。内容窗格包含小程序的可见 GUI 组件，应该是不透明的。
void setRootPane(JRootPane) JRootPane getRootPane()	创建、设置或获取小程序的根窗格。根窗格管理小程序的内部，包括内容窗格、玻璃窗格等。
void setJMenuBar(JMenuBar) JMenuBar getJMenuBar()	设置或获取小程序的菜单栏以管理小程序的一组菜单。
void setGlassPane(Component) Component getGlassPane()	设置或获取小程序的玻璃窗格。您可以使用玻璃窗格拦截鼠标事件。
void setLayeredPane(JLayeredPane) JLayeredPane getLayeredPane()	设置或获取 applet 的分层窗格。您可以使用 applet 的分层窗格将组件放在其他组件的前面或后面。

Applet 示例

这个表格展示了 Swing applet 的示例以及这些示例在哪里描述。

示例	描述位置	备注
`TumbleItem`	本页	一个动画 applet

如何使用按钮、复选框和单选按钮

原文：docs.oracle.com/javase/tutorial/uiswing/components/button.html

要创建一个按钮，你可以实例化从AbstractButton类继承的许多类之一。下表显示了你可能想要使用的 Swing 定义的AbstractButton子类：

类	摘要	描述位置
`JButton`	一个常见的按钮。	如何使用通用按钮 API 和如何使用 JButton 功能
`JCheckBox`	一个复选框按钮。	如何使用复选框
`JRadioButton`	一组单选按钮中的一个。	如何使用单选按钮
`JMenuItem`	菜单中的一个项目。	如何使用菜单
`JCheckBoxMenuItem`	具有复选框的菜单项。	如何使用菜单和如何使用复选框
`JRadioButtonMenuItem`	具有单选按钮的菜单项。	如何使用菜单和如何使用单选按钮
`JToggleButton`	实现`JCheckBox`和`JRadioButton`继承的切换功能。可以实例化或子类化以创建两状态按钮。	在一些示例中使用

注意： 如果你想将一组按钮收集到一行或一列中，那么你应该查看工具栏。

首先，本节解释了AbstractButton定义的基本按钮 API，因此所有 Swing 按钮都具有共同的特性。接下来，它描述了JButton添加到AbstractButton的少量 API。之后，本节将向您展示如何使用专门的 API 来实现复选框和单选按钮。

如何使用通用按钮 API

这里是一个显示三个按钮的应用程序的图片：

试试这个：

点击“启动”按钮以使用Java™ Web Start运行按钮演示（下载 JDK 7 或更高版本）。或者，要自行编译和运行示例，请参考示例索引。
点击左侧按钮。

它禁用了中间按钮（以及自身，因为它不再有用），并启用了右侧按钮。
点击右侧按钮。

它启用了中间按钮和左侧按钮，并禁用了自身。

正如ButtonDemo示例所示，Swing 按钮可以同时显示文本和图像。在ButtonDemo中，每个按钮的文本相对于其图像有不同的位置。每个按钮文本中的下划线字母显示了助记符 每个按钮的键盘替代键。在大多数外观中，用户可以通过按下 Alt 键和助记符来点击按钮。例如，Alt-M 将点击 ButtonDemo 中的 Middle 按钮。

当按钮被禁用时，外观会自动生成按钮的禁用外观。但是，您可以提供一个图像来替换正常图像。例如，您可以提供左侧和右侧按钮使用的图像的灰色版本。

如何实现事件处理取决于您使用的按钮类型以及如何使用它。通常，您会实现一个 action listener，每当用户点击按钮时都会通知它。对于复选框，通常会使用一个 item listener，当复选框被选中或取消选中时会通知它。

下面是ButtonDemo.java中创建上一个示例中按钮并响应按钮点击的代码。粗体代码是如果按钮没有图像时将保留的代码。

*//In initialization code:*
    ImageIcon leftButtonIcon = createImageIcon("images/right.gif");
    ImageIcon middleButtonIcon = createImageIcon("images/middle.gif");
    ImageIcon rightButtonIcon = createImageIcon("images/left.gif");

    b1 = new JButton("Disable middle button", leftButtonIcon);
    b1.setVerticalTextPosition(AbstractButton.CENTER);
    b1.setHorizontalTextPosition(AbstractButton.LEADING); //aka LEFT, for left-to-right locales
    b1.setMnemonic(KeyEvent.VK_D);
    b1.setActionCommand("disable");

    b2 = new JButton("Middle button", middleButtonIcon);
    b2.setVerticalTextPosition(AbstractButton.BOTTOM);
    b2.setHorizontalTextPosition(AbstractButton.CENTER);
    b2.setMnemonic(KeyEvent.VK_M);

    b3 = new JButton("Enable middle button", rightButtonIcon);
    //Use the default text position of CENTER, TRAILING (RIGHT).
    b3.setMnemonic(KeyEvent.VK_E);
    b3.setActionCommand("enable");
    b3.setEnabled(false);

    //Listen for actions on buttons 1 and 3.
    b1.addActionListener(this);
    b3.addActionListener(this);

    b1.setToolTipText("Click this button to disable "
                      + "the middle button.");
    b2.setToolTipText("This middle button does nothing "
                      + "when you click it.");
    b3.setToolTipText("Click this button to enable the "
                      + "middle button.");
    ...
}

public void actionPerformed(ActionEvent e) {
    if ("disable".equals(e.getActionCommand())) {
        b2.setEnabled(false);
        b1.setEnabled(false);
        b3.setEnabled(true);
    } else {
        b2.setEnabled(true);
        b1.setEnabled(true);
        b3.setEnabled(false);
    }
} 

protected static ImageIcon createImageIcon(String path) {
    java.net.URL imgURL = ButtonDemo.class.getResource(path);
    *...//error handling omitted for clarity...*
    return new ImageIcon(imgURL);
}

如何使用 JButton 功能

普通按钮 JButton 对象比 AbstractButton 类提供的功能稍多一点：你可以将 JButton 设置为默认按钮。

一个顶级容器中最多只能有一个默认按钮。默认按钮通常具有突出的外观，并且当顶级容器具有键盘焦点并且用户按下 Return 或 Enter 键时会被点击。这里是一个对话框的图片，实现在 ListDialog 示例中，其中设置按钮是默认按钮：

您可以通过在顶层容器的根窗格上调用setDefaultButton方法来设置默认按钮。以下是为ListDialog示例设置默认按钮的代码：

*//In the constructor for a JDialog subclass:*
getRootPane().setDefaultButton(setButton);

默认按钮功能的确切实现取决于外观。例如，在 Windows 外观中，默认按钮会更改为具有焦点的按钮，以便按 Enter 键单击具有焦点的按钮。当没有按钮具有焦点时，您最初指定为默认按钮的按钮再次成为默认按钮。

如何使用复选框

JCheckBox类提供了对复选框按钮的支持。您还可以使用JCheckBoxMenuItem类将复选框放入菜单中。因为JCheckBox和JCheckBoxMenuItem继承自AbstractButton，Swing 复选框具有本节前面讨论的所有常规按钮特性。例如，您可以指定要在复选框中使用的图像。

复选框类似于单选按钮，但它们的选择模型不同，按照惯例。一组复选框中的任意数量可以选择零个、一些或全部。另一方面，一组单选按钮只能选择一个按钮。

这是一个使用四个复选框自定义卡通的应用程序的图片：

试试这个：

单击启动按钮以使用Java™ Web Start运行 CheckBox Demo（下载 JDK 7 或更高版本）。或者，要自行编译和运行示例，请参考示例索引。
单击下巴按钮或按下 Alt-c。

下巴复选框变为未选中状态，下巴从图片中消失。其他复选框保持选中状态。此应用程序有一个项目侦听器，用于监听所有复选框。每次项目侦听器接收到事件时，应用程序会加载反映复选框当前状态的新图片。

每次单击复选框都会生成一个项目事件和一个操作事件。通常，您只监听项目事件，因为它们让您确定单击是选择还是取消选择复选框。以下是来自CheckBoxDemo.java的代码，用于创建上一个示例中的复选框并对单击做出反应。

*//In initialization code:*
    chinButton = new JCheckBox("Chin");
    chinButton.setMnemonic(KeyEvent.VK_C); 
    chinButton.setSelected(true);

    glassesButton = new JCheckBox("Glasses");
    glassesButton.setMnemonic(KeyEvent.VK_G); 
    glassesButton.setSelected(true);

    hairButton = new JCheckBox("Hair");
    hairButton.setMnemonic(KeyEvent.VK_H); 
    hairButton.setSelected(true);

    teethButton = new JCheckBox("Teeth");
    teethButton.setMnemonic(KeyEvent.VK_T); 
    teethButton.setSelected(true);

    //Register a listener for the check boxes.
    chinButton.addItemListener(this);
    glassesButton.addItemListener(this);
    hairButton.addItemListener(this);
    teethButton.addItemListener(this);
...
public void itemStateChanged(ItemEvent e) {
    ...
    Object source = e.getItemSelectable();

    if (source == chinButton) {
        *//...make a note of it...*
    } else if (source == glassesButton) {
        *//...make a note of it...*
    } else if (source == hairButton) {
        *//...make a note of it...*
    } else if (source == teethButton) {
        *//...make a note of it...*
    }

    if (e.getStateChange() == ItemEvent.DESELECTED)
        *//...make a note of it...*
    ...
    updatePicture();
}

如何使用单选按钮

单选按钮是一组按钮，按照惯例，一次只能选择一个按钮。Swing 版本支持使用JRadioButton和ButtonGroup类的单选按钮。要将单选按钮放入菜单中，请使用JRadioButtonMenuItem类。显示一组中的一个选择的其他方式包括组合框和列表。单选按钮看起来类似于复选框，但是按照惯例，复选框不限制同时选择的项目数量。

因为JRadioButton继承自AbstractButton，Swing 单选按钮具有所有通常的按钮特性，如本节前面讨论的。例如，您可以指定在单选按钮中显示的图像。

下面是一个应用程序的图片，使用五个单选按钮让您选择显示哪种宠物：

试试这个：

点击启动按钮以使用Java™ Web Start运行 RadioButton Demo（下载 JDK 7 或更高版本）。或者，要自行编译和运行示例，请参考示例索引。
点击Dog按钮或按下 Alt-d 键。

Dog按钮被选中，使Bird按钮变为未选中。图片从鸟变为狗。这个应用程序有一个监听所有单选按钮的 action listener。每次 action listener 接收到事件时，应用程序会显示刚刚点击的单选按钮的图片。

每当用户点击单选按钮（即使它已经被选中），按钮都会触发一个 action event。还会发生一个或两个 item events 一个来自刚刚被选中的按钮，另一个来自失去选择的按钮（如果有的话）。通常，你会使用一个 action listener 来处理单选按钮的点击。

下面是RadioButtonDemo.java中创建单选按钮并响应点击的代码，这是前面示例中的单选按钮。

*//In initialization code:*
    //Create the radio buttons.
    JRadioButton birdButton = new JRadioButton(birdString);
    birdButton.setMnemonic(KeyEvent.VK_B);
    birdButton.setActionCommand(birdString);
    birdButton.setSelected(true);

    JRadioButton catButton = new JRadioButton(catString);
    catButton.setMnemonic(KeyEvent.VK_C);
    catButton.setActionCommand(catString);

    JRadioButton dogButton = new JRadioButton(dogString);
    dogButton.setMnemonic(KeyEvent.VK_D);
    dogButton.setActionCommand(dogString);

    JRadioButton rabbitButton = new JRadioButton(rabbitString);
    rabbitButton.setMnemonic(KeyEvent.VK_R);
    rabbitButton.setActionCommand(rabbitString);

    JRadioButton pigButton = new JRadioButton(pigString);
    pigButton.setMnemonic(KeyEvent.VK_P);
    pigButton.setActionCommand(pigString);

    //Group the radio buttons.
    ButtonGroup group = new ButtonGroup();
    group.add(birdButton);
    group.add(catButton);
    group.add(dogButton);
    group.add(rabbitButton);
    group.add(pigButton);

    //Register a listener for the radio buttons.
    birdButton.addActionListener(this);
    catButton.addActionListener(this);
    dogButton.addActionListener(this);
    rabbitButton.addActionListener(this);
    pigButton.addActionListener(this);
...
public void actionPerformed(ActionEvent e) {
    picture.setIcon(new ImageIcon("images/" 
                                  + e.getActionCommand() 
                                  + ".gif"));
}

对于每组单选按钮，您需要创建一个ButtonGroup实例，并将每个单选按钮添加到其中。ButtonGroup会在用户选择组中的另一个按钮时取消先前选中的按钮。

通常应该初始化一组单选按钮，以便其中一个被选中。但是，API 不强制执行此规则一组单选按钮可以没有初始选择。一旦用户做出选择，从那时起将仅选择一个按钮。

按钮 API

以下表格列出了常用的与按钮相关的 API。您可能调用的其他方法，如 setFont 和 setForeground，在 JComponent 类的 API 表中列出。

使用按钮的 API 分为以下几类：

设置或获取按钮的内容
微调按钮的外观
实现按钮的功能
复选框构造函数
单选按钮构造函数
切换按钮构造函数
常用的按钮组构造函数/方法

设置或获取按钮的内容

方法或构造函数	目的

| JButton(Action) JButton(String, Icon)

JButton(String)

JButton(Icon)

JButton() | 创建一个 JButton 实例，并将其初始化为具有指定的文本/图像/操作。 |

| void setAction(Action) Action getAction()

根据 `Action` 实例的值设置或获取按钮的属性。

| void setText(String) String getText()

设置或获取按钮显示的文本。您可以使用 HTML 格式，如在 Swing 组件中使用 HTML 中所述。

| void setIcon(Icon) Icon getIcon()

设置或获取按钮在未选中或按下时显示的图像。

| void setDisabledIcon(Icon) Icon getDisabledIcon()

设置或获取按钮在禁用时显示的图像。如果您没有指定禁用图像，则外观和感觉会通过操作默认图像来创建一个。

| void setPressedIcon(Icon) Icon getPressedIcon()

设置或获取按钮在被按下时显示的图像。

| void setSelectedIcon(Icon) Icon getSelectedIcon()

void setDisabledSelectedIcon(Icon)

Icon getDisabledSelectedIcon()

设置或获取按钮在选定时显示的图像。如果您没有指定禁用选定图像，则外观和感觉会通过操作选定图像来创建一个。

| setRolloverEnabled(boolean) boolean isRolloverEnabled()

void setRolloverIcon(Icon)

Icon getRolloverIcon()

void setRolloverSelectedIcon(Icon)

Icon getRolloverSelectedIcon()

使用`setRolloverIcon(someIcon)`使按钮在鼠标悬停在其上时显示指定图标。`setRolloverSelectedIcon`方法允许您在按钮选定时指定悬停图标，这对于两状态按钮（如切换按钮）非常有用。设置悬停图标会自动调用`setRollover(true)`，启用悬停效果。

调整按钮外观

方法或构造函数	目的

| void setHorizontalAlignment(int) void setVerticalAlignment(int)

int getHorizontalAlignment()

int getVerticalAlignment() | 设置或获取按钮内容应该放置在按钮的何处。AbstractButton 类允许水平对齐的以下任一值：RIGHT、LEFT、CENTER（默认）、LEADING 和 TRAILING。对于垂直对齐：TOP、CENTER（默认）和 BOTTOM。 |

| void setHorizontalTextPosition(int) void setVerticalTextPosition(int)

int getHorizontalTextPosition()

int getVerticalTextPosition() | 设置或获取按钮文本应该放置在何处，相对于按钮的图像。AbstractButton 类允许水平位置的以下任一值：LEFT、CENTER、RIGHT、LEADING 和 TRAILING（默认）。对于垂直位置：TOP、CENTER（默认）和 BOTTOM。 |

void setMargin(Insets) Insets getMargin()	设置或获取按钮边框与其内容之间的像素数。
void setFocusPainted(boolean) boolean isFocusPainted()	设置或获取按钮在获得焦点时是否应该呈现不同外观。
void setBorderPainted(boolean) boolean isBorderPainted()	设置或获取按钮边框是否应该被绘制。

| void setIconTextGap(int) int getIconTextGap()

设置或获取文本和此按钮中显示的图标之间的间距。

实现按钮的功能

方法或构造函数	目的

| void setMnemonic(int) char getMnemonic()

设置或获取通过按下按钮的键盘替代方法。`setMnemonic`方法的一种形式接受一个字符参数；然而，Swing 团队建议您改用一个`int`参数，指定一个`KeyEvent.VK_X`常量。

| void setDisplayedMnemonicIndex(int) int getDisplayedMnemonicIndex()

设置或获取文本中应该被装饰以表示助记符的字符的提示。请注意，并非所有外观和感觉都支持此功能。

| void setActionCommand(String) String getActionCommand()

设置或获取按钮执行的动作的名称。

| void addActionListener(ActionListener) ActionListener removeActionListener()

添加或移除监听按钮触发的动作事件的对象。

| void addItemListener(ItemListener) ItemListener removeItemListener()

添加或移除监听按钮触发的项目事件的对象。

| void setSelected(boolean) boolean isSelected()

设置或获取按钮是否被选中。仅适用于具有开/关状态的按钮，如复选框。

| void doClick() void doClick(int)

以编程方式执行“点击”操作。可选参数指定按钮看起来被按下的时间（以毫秒为单位）。
void setMultiClickThreshhold(long) long getMultiClickThreshhold()

复选框构造函数

构造函数	目的

| JCheckBox(操作) JCheckBox(字符串)

JCheckBox(字符串, 图标, 布尔值)

JCheckBox() | 创建一个JCheckBox实例。字符串参数指定复选框应显示的文本（如果有）。同样，Icon参数指定应使用的图像，而不是外观的默认复选框图像。将布尔参数指定为true会将复选框初始化为选中状态。如果省略布尔参数或为false，则复选框最初未选中。 |

| JCheckBoxMenuItem(操作) JCheckBoxMenuItem(字符串)

JCheckBoxMenuItem(字符串, 布尔值)

JCheckBoxMenuItem(图标)

JCheckBoxMenuItem(字符串, 图标)

JCheckBoxMenuItem(字符串, 图标, 布尔值)

JCheckBoxMenuItem() | 创建一个JCheckBoxMenuItem实例。参数的解释方式与JCheckBox构造函数的参数相同，只是任何指定的图标会显示在普通复选框图标的旁边。 |

单选按钮构造函数

构造函数	目的

| JRadioButton(操作) JRadioButton(字符串)

JRadioButton(字符串, 布尔值)

JRadioButton(图标)

JRadioButton(图标, 布尔值)

JRadioButton(字符串, 图标)

JRadioButton(字符串, 图标, 布尔值)

JRadioButton() | 创建一个JRadioButton实例。字符串参数指定了单选按钮应显示的文本（如果有）。同样，Icon参数指定了应该使用的图像，而不是外观的默认单选按钮图像。将布尔参数指定为true会将单选按钮初始化为选中状态，取决于ButtonGroup对象的批准。如果布尔参数不存在或为false，则单选按钮最初未选中。 |

| JRadioButtonMenuItem(操作) JRadioButtonMenuItem(字符串)

JRadioButtonMenuItem(图标)

JRadioButtonMenuItem(字符串, 图标)

JRadioButtonMenuItem() | 创建一个JRadioButtonMenuItem实例。参数的解释方式与JRadioButton构造函数的参数相同，只是任何指定的图标会显示在普通单选按钮图标之外。 |

切换按钮构造函数

构造函数	目的

| JToggleButton(操作) JToggleButton(字符串)

JToggleButton(String, boolean)

JToggleButton(Icon)

JToggleButton(Icon, boolean)

JToggleButton(String, Icon)

JToggleButton(String, Icon, boolean)

JToggleButton() | 创建一个 JToggleButton 实例，类似于 JButton，但具有两种状态。通常，您应该使用 JRadioButton 或 JCheckBox 而不是直接实例化 JToggleButton，但在您不希望出现典型的单选按钮或复选框外观时，JToggleButton 可能会有用。字符串参数指定切换按钮应显示的文本（如果有）。同样，Icon 参数指定应使用的图像。将布尔参数指定为 true 会将切换按钮初始化为选定状态。如果省略布尔参数或为 false，则切换按钮最初未选定。 |

常用的按钮组构造函数/方法

构造函数或方法	目的
ButtonGroup()	创建一个 `ButtonGroup` 实例。
void add(AbstractButton) void remove(AbstractButton)	将按钮添加到组中，或从组中移除按钮。
public ButtonGroup getGroup() (在 `DefaultButtonModel` 中)	获取控制按钮的 `ButtonGroup`（如果有）。例如：`ButtonGroup group = ((DefaultButtonModel)button.getModel()).getGroup();`
公共 ButtonGroup clearSelection()	清除 ButtonGroup 中选定按钮的状态。ButtonGroup 中的按钮都不会被选中。

使用不同类型按钮的示例

以下示例使用按钮。另请参阅使用工具栏的示例，其中列出了将 JButton 对象添加到 JToolBar 中的程序。

示例	描述位置	备注
`ButtonDemo`	如何使用常见按钮 API	使用助记符和图标。指定按钮文本位置，相对于按钮图标。使用动作命令。
`ButtonHtmlDemo`	在 Swing 组件中使用 HTML	一个使用 HTML 格式的 ButtonDemo 版本。
`ListDialog`	如何使用 JButton 功能	实现一个带有两个按钮的对话框，其中一个是默认按钮。
`DialogDemo`	如何制作对话框	具有与单选按钮状态相关联的“显示”按钮行为。使用匿名的内部类实现动作监听器。
`ProgressBarDemo`	如何监视进度	使用命名的内部类实现按钮的动作监听器。
`CheckBoxDemo`	如何使用复选框	使用复选框按钮确定应显示哪 16 幅图像。
`ActionDemo`	如何使用动作	使用复选框菜单项来设置程序的状态。
`RadioButtonDemo`	如何使用单选按钮	使用单选按钮确定应显示哪五幅图像。
`DialogDemo`	如何制作对话框	包含几组单选按钮，用于确定要弹出哪个对话框。
`MenuDemo`	如何使用菜单	包含单选按钮菜单项和复选框菜单项。
`ColorChooserDemo2`	如何使用颜色选择器	`CrayonPanel` 中的蜡笔实现为切换按钮。
`ScrollDemo`	如何使用滚动窗格	cm 按钮是一个切换按钮。

您可以从以下文档中了解更多关于 JavaFX 按钮组件的信息：

如何使用 ButtonGroup 组件

原文：docs.oracle.com/javase/tutorial/uiswing/components/buttongroup.html

ButtonGroup组件管理一组按钮的选中/未选中状态。对于该组，ButtonGroup实例保证一次只能选择一个按钮。

最初，由ButtonGroup实例管理的所有按钮都未被选中。

如何使用 ButtonGroup 功能

你可以将ButtonGroup与任何继承自AbstractButton的对象一起使用。通常，按钮组包含JRadioButton, JRadioButtonMenuItem或JToggleButton的实例。将JButton或JMenuItem的实例放入按钮组中是没有意义的，因为JButton和JMenuItem没有实现选择/取消选择按钮状态。

通常，编写使用ButtonGroup组件的代码时，通常会遵循以下步骤。

子类化JFrame
与布局管理器一起调用ContextPane
声明和配置一组单选按钮或切换按钮
实例化一个ButtonGroup对象
调用该 buttongroup 对象上的add方法，以便将每个按钮添加到组中。

有关详细信息和代码示例，请参阅如何使用单选按钮。它展示了如何使用ButtonGroup组件将一组单选按钮设置到一个 JPanel 中。

ButtonGroup API

常用的 Button Group 构造函数/方法

构造函数或方法	目的
ButtonGroup()	创建一个`ButtonGroup`实例。
void add(AbstractButton) void remove(AbstractButton)	将按钮添加到组中，或从组中移除按钮。
public ButtonGroup getGroup() (在`DefaultButtonModel`中)	获取控制按钮的`ButtonGroup`（如果有）。例如：`ButtonGroup group = ((DefaultButtonModel)button.getModel()).getGroup();`
public ButtonGroup clearSelection()	清除 ButtonGroup 中选定按钮的状态。ButtonGroup 中的按钮都未被选中。

ButtonGroup 示例

以下演示应用程序使用 ButtonGroup 组件将单选按钮分组显示在窗口上。

示例	描述位置	注意事项
`RadioButtonDemo`	如何使用单选按钮	使用单选按钮确定应显示哪五幅图像。

如何使用颜色选择器

原文：docs.oracle.com/javase/tutorial/uiswing/components/colorchooser.html

使用JColorChooser类使用户可以从调色板中选择颜色。颜色选择器是一个组件，您可以将其放置在程序 GUI 中的任何位置。JColorChooser API 还可以轻松地弹出包含颜色选择器的对话框（模态或非模态）。

这是一个使用颜色选择器设置横幅文本颜色的应用程序的图片：

试试这个：

单击“启动”按钮以使用Java™ Web Start运行 ColorChooser 演示（下载 JDK）。或者，要自行编译和运行示例，请参考示例索引。

该程序的源代码位于ColorChooserDemo.java中。

颜色选择器包括标有选择文本颜色的框内的所有内容。这是 Java 外观和感觉中标准颜色选择器的样子。它包含两部分，一个选项卡窗格和一个预览面板。选项卡窗格中的三个选项卡选择选择器面板。选项卡窗格下方的预览面板显示当前选定的颜色。

这是创建JColorChooser实例并将其添加到容器的示例代码：

public class ColorChooserDemo extends JPanel ... {
    public ColorChooserDemo() {
        super(new BorderLayout());
        banner = new JLabel("Welcome to the Tutorial Zone!",
                            JLabel.CENTER);
        banner.setForeground(Color.yellow);
        . . .
        tcc = new JColorChooser(banner.getForeground());
        . . .
        add(tcc, BorderLayout.PAGE_END);
    }

在上一个代码片段中，JColorChooser构造函数接受一个Color参数，该参数指定了选择器的初始选定颜色。如果您没有指定初始颜色，则颜色选择器将显示Color.white。请查看Color API 文档以获取可用的颜色常量列表。

颜色选择器使用ColorSelectionModel的实例来包含和管理当前选择。颜色选择模型在用户更改颜色时触发更改事件。示例程序向颜色选择模型注册了更改侦听器，以便能够更新窗口顶部的横幅。以下代码注册并实现了更改侦听器：

tcc.getSelectionModel().addChangeListener(this);
. . .
public void stateChanged(ChangeEvent e) {
    Color newColor = tcc.getColor();
    banner.setForeground(newColor);
}

有关更改侦听器和更改事件的一般信息，请参阅如何编写更改侦听器。

像示例程序中使用的基本颜色选择器对于许多程序来说已经足够了。然而，颜色选择器 API 允许您通过提供自己设计的预览面板、向其添加自定义选择器面板或移除颜色选择器中的现有选择器面板来自定义颜色选择器。此外，JColorChooser类提供了两个方法，使得在对话框中使用颜色选择器变得简单。

本节的其余部分讨论以下主题：

另一个示例：ColorChooserDemo2
在对话框中显示颜色选择器
移除或替换预览面板
创建自定义选择器面板
颜色选择器 API
使用颜色选择器的示例

另一个示例：ColorChooserDemo2

现在让我们转向 ColorChooserDemo2，这是前一个演示程序的修改版本，使用了更多的JColorChooserAPI。

试试这个：

点击启动按钮以使用Java™ Web Start运行 ColorChooser Demo（下载 JDK）。或者，要自己编译和运行示例，请参考示例索引。

这里是 ColorChooserDemo2 的图片：

该程序自定义了横幅文本颜色选择器的方式如下：

移除预览面板
移除所有默认的选择器面板
添加一个自定义选择器面板

移除或替换预览面板涵盖了第一个自定义。创建自定义选择器面板讨论了后两个。

该程序还添加了一个按钮，点击后会在对话框中打开一个颜色选择器，您可以用它来设置横幅的背景颜色。

在对话框中显示颜色选择器

JColorChooser类提供了两个类方法，使得在对话框中使用颜色选择器变得简单。ColorChooserDemo2 使用其中一个方法，showDialog，当用户点击显示颜色选择器...按钮时，会显示背景颜色选择器的对话框。以下是示例中用于在对话框中打开背景颜色选择器的单行代码：

Color newColor = JColorChooser.showDialog(
                     ColorChooserDemo2.this,
                     "Choose Background Color",
                     banner.getBackground());

第一个参数是对话框的父级，第二个是对话框标题，第三个是初始选择的颜色。

对话框在三种情况下消失：用户选择颜色并点击确定按钮，用户使用取消按钮取消操作，或用户使用框架控件关闭对话框。如果用户选择了颜色，showDialog 方法将返回新颜色。如果用户取消操作或关闭窗口，则该方法返回 null。以下是根据 showDialog 返回值更新横幅背景颜色的示例代码：

if (newColor != null) {
    banner.setBackground(newColor);
}

showDialog 创建的对话框是模态的。如果你想要一个非模态对话框，可以使用 JColorChooser 的 createDialog 方法来创建对话框。这个方法还允许你为对话框窗口中的确定和取消按钮指定动作监听器。使用 JDialog 的 show 方法来显示这个方法创建的对话框。有关使用此方法的示例，请参见指定其他编辑器中的如何使用表格部分。

移除或替换预览面板

默认情况下，颜色选择器显示一个预览面板。ColorChooserDemo2 使用以下代码移除文本颜色选择器的预览面板：

tcc.setPreviewPanel(new JPanel());

这将有效地移除预览面板，因为普通的 JPanel 没有大小和默认视图。要将预览面板恢复为默认设置，请使用 setPreviewPanel 的参数为 null。

要提供自定义预览面板，还要使用 setPreviewPanel。你传递给该方法的组件应该继承自 JComponent，指定一个合理的大小，并提供当前颜色的自定义视图。要在用户更改颜色选择器中的颜色时收到通知，预览面板必须像之前描述的那样在颜色选择器的颜色选择模型上注册为更改监听器。

创建自定义选择器面板

默认颜色选择器提供五个选择器面板：

色板用于从一组色板中选择颜色。
HSV 用于使用色调-饱和度-亮度颜色表示选择颜色。在 JDK 7 之前，这被称为 HSB，代表色调-饱和度-亮度。
HSL 用于使用色调-饱和度-亮度颜色表示选择颜色。这是 JDK 7 中的新功能。
RGB 用于使用红-绿-蓝颜色模型选择颜色。
CMYK 用于使用过程颜色或四色模型选择颜色。这是 JDK 7 中的新功能。

你可以通过使用 addChooserPanel 添加自己设计的选择器面板来扩展默认颜色选择器，或者通过使用 removeChooserPanel 删除选择器面板来限制它。

如果要删除所有默认的选择器面板并添加一个或多个自定义面板，可以通过单个调用setChooserPanels来实现。ColorChooserDemo2 使用此方法将默认选择器面板替换为CrayonPanel的实例，一个自定义选择器面板。以下是来自该示例的setChooserPanels调用：

//Override the chooser panels with our own.
AbstractColorChooserPanel panels[] = { new CrayonPanel() };
tcc.setChooserPanels(panels);

代码很简单：它创建一个包含CrayonPanel的数组。接下来，代码调用setChooserPanels将数组的内容设置为颜色选择器的选择器面板。

CrayonPanel是AbstractColorChooserPanel的子类，并重写了其超类中定义的五个抽象方法：

void buildChooser()

创建包含选择器面板的 GUI。示例创建四个切换按钮每个代表一个蜡笔并将它们添加到选择器面板中。

void updateChooser()

每当显示选择器面板时，将调用此方法。此方法的实现选择代表当前选定颜色的切换按钮。

public void updateChooser() {
    Color color = getColorFromModel();
    if (Color.red.equals(color)) {
        redCrayon.setSelected(true);
    } else if (Color.yellow.equals(color)) {
        yellowCrayon.setSelected(true);
    } else if (Color.green.equals(color)) {
        greenCrayon.setSelected(true);
    } else if (Color.blue.equals(color)) {
        blueCrayon.setSelected(true);
    }
}

String getDisplayName()

返回选择器面板的显示名称。该名称用于选择器面板的选项卡上。以下是示例getDisplayName方法：

public String getDisplayName() {
    return "Crayons";
}

Icon getSmallDisplayIcon()

返回一个小图标来表示此选择器面板。目前未使用。将来的颜色选择器版本可能会使用此图标或大图标来表示此选择器面板在显示中的位置。此方法的示例实现返回null。

Icon getLargeDisplayIcon()

返回一个大图标来表示此选择器面板。目前未使用。将来的颜色选择器版本可能会使用此图标或小图标来表示此选择器面板在显示中的位置。此方法的示例实现返回null。

颜色选择器 API

以下表格列出了常用的JColorChooser构造函数和方法。您可能调用的其他方法在 The JComponent Class 的 API 表中列出。使用颜色选择器的 API 分为以下几类：

创建和显示颜色选择器
自定义颜色选择器 GUI
设置或获取当前颜色

创建和显示颜色选择器

方法或构造函数	目的

| JColorChooser() JColorChooser(Color)

JColorChooser(ColorSelectionModel) | 创建一个颜色选择器。默认构造函数创建一个初始颜色为Color.white的颜色选择器。使用第二个构造函数指定不同的初始颜色。当存在ColorSelectionModel参数时，为颜色选择器提供颜色选择模型。 |

Color showDialog(Component, String, Color)	创建并显示一个颜色选择器在模态对话框中。`Component`参数是对话框的父级，`String`参数指定对话框标题，`Color`参数指定选择器的初始颜色。

| [JDialog createDialog(Component, String, boolean, JColorChooser, ActionListener,

ActionListener)](https://docs.oracle.com/javase/8/docs/api/javax/swing/JColorChooser.html#createDialog-java.awt.Component-java.lang.String-boolean-javax.swing.JColorChooser-java.awt.event.ActionListener-java.awt.event.ActionListener-) | 为指定的颜色选择器创建对话框。与showDialog一样，Component参数是对话框的父级，String参数指定对话框标题。其他参数如下：boolean指定对话框是否为模态，JColorChooser是要在对话框中显示的颜色选择器，第一个ActionListener是为确定按钮，第二个是为取消按钮。 |

自定义颜色选择器的 GUI

方法	目的
void setPreviewPanel(JComponent) JComponent getPreviewPanel()	设置或获取用于预览颜色选择的组件。要移除预览面板，请使用`new JPanel()`作为参数。要指定默认预览面板，请使用`null`。
void setChooserPanels(AbstractColorChooserPanel[]) AbstractColorChooserPanel[] getChooserPanels()	设置或获取颜色选择器中的选择面板。
void addChooserPanel(AbstractColorChooserPanel) AbstractColorChooserPanel removeChooserPanel(AbstractColorChooserPanel)	向颜色选择器添加选择器面板或从中移除选择器面板。
void setDragEnabled(boolean) boolean getDragEnabled()	设置或获取`dragEnabled`属性，该属性必须为 true 才能在此组件上启用拖放处理。默认值为 false。有关更多详细信息，请参阅拖放和数据传输。

设置或获取当前颜色

方法	目的

| void setColor(Color) void setColor(int, int, int)

void setColor(int)

Color getColor() | 设置或获取当前选择的颜色。setColor方法的三个整数版本将这三个整数一起解释为 RGB 颜色。setColor方法的单个整数版本将整数分成四个 8 位字节，并按以下方式解释整数为 RGB 颜色： |

void setSelectionModel(ColorSelectionModel) ColorSelectionModel getSelectionModel()	设置或获取颜色选择器的选择模型。该对象包含当前选择，并在选择更改时向注册的侦听器触发更改事件。

使用颜色选择器的示例

此表显示使用JColorChooser的示例以及这些示例的描述位置。

示例	描述位置	注意事项
ColorChooserDemo	此部分	使用标准颜色选择器。
ColorChooserDemo2	此部分	在使用`showDialog`创建的对话框中使用一个自定义颜色选择器和一个标准颜色选择器。
TableDialogEditDemo	如何使用表格	展示如何在表格中使用颜色选择器作为自定义单元格编辑器。该示例中使用的颜色选择器是通过`createDialog`创建的。
BasicDnD	DnD 简介	使用不在对话框中的颜色选择器；演示了 Swing 组件的默认拖放功能，包括颜色选择器。

如何使用组合框

原文：docs.oracle.com/javase/tutorial/uiswing/components/combobox.html

一个JComboBox，允许用户选择多个选择项之一，可以有两种非常不同的形式。默认形式是不可编辑的组合框，其中包含一个按钮和一个值的下拉列表。第二种形式称为可编辑的组合框，其中包含一个与之相邻的小按钮的文本字段。用户可以在文本字段中键入一个值或单击按钮以显示下拉列表。以下是 Java 外观中两种形式的组合框的样子：



不可编辑的组合框，在按钮被点击前（顶部）和之后	可编辑的组合框，在箭头按钮被点击前和之后

组合框需要很少的屏幕空间，它们的可编辑（文本字段）形式对于让用户快速选择一个值而不限制用户在显示的值上是有用的。其他可以显示多个选择项之一的组件包括单选按钮和列表组。单选按钮组通常是用户最容易理解的，但当空间有限或有多个选择项可用时，组合框可能更合适。列表并不是非常吸引人，但当项目数量较大（比如超过 20 个）或选择多个项目可能是有效的时，它们比组合框更合适。

由于可编辑和不可编辑的组合框非常不同，因此本节将它们分开处理。本节涵盖以下主题：

使用不可编辑的组合框
处理组合框上的事件
使用可编辑的组合框
提供自定义渲染器
组合框 API
使用组合框的示例

使用不可编辑的组合框

此处显示的应用程序使用不可编辑的组合框来选择宠物图片：

试试这个：

单击“启动”按钮以使用Java™ Web Start运行 ComboBox Demo（下载 JDK 7 或更高版本）。或者，要自行编译和运行示例，请参考示例索引。
从组合框中选择一个动物名称以查看其图片。
将此程序的操作和 GUI 与使用单选按钮的程序进行比较：运行 RadioButtonDemo（需要版本 6）。您可能还想比较源代码：ComboBoxDemo.java vs. RadioButtonDemo.java。

下面的代码取自ComboBoxDemo.java，创建一个不可编辑的组合框并设置它：

String[] petStrings = { "Bird", "Cat", "Dog", "Rabbit", "Pig" };

//Create the combo box, select item at index 4.
//Indices start at 0, so 4 specifies the pig.
JComboBox petList = new JComboBox(petStrings);
petList.setSelectedIndex(4);
petList.addActionListener(this);

这个组合框包含一个字符串数组，但您也可以使用图标。要将其他内容放入组合框或自定义组合框中的项目外观，您需要编写自定义渲染器。可编辑的组合框还需要一个自定义编辑器。请参考提供自定义渲染器以获取信息和示例。

前面的代码在组合框上注册了一个动作监听器。要查看动作监听器的实现并了解组合框支持的其他类型的监听器，请参考处理组合框上的事件。

无论使用哪个构造函数，组合框都使用组合框模型来包含和管理其菜单中的项目。当您使用数组或向量初始化组合框时，组合框会为您创建一个默认的模型对象。与其他 Swing 组件一样，您可以通过实现自定义模型（实现ComboBoxModel接口的对象）来部分自定义组合框。

注意：

在为组合框实现自定义模型时要小心。JComboBox中更改组合框菜单中项目的方法，如insertItemAt，仅在数据模型实现MutableComboBoxModel接口（ComboBoxModel的子接口）时才有效。请参考 API 表以查看受影响的方法。

还要注意的另一件事是，即使对于不可编辑的组合框，也要确保您的自定义模型在组合框的数据或状态更改时触发 list data events。即使数据永远不会更改的不可变组合框模型，在选择更改时也必须触发列表数据事件（CONTENTS_CHANGED事件）。一个简单的方法是将您的组合框模型作为AbstractListModel的子类，以获得列表数据事件触发代码。

处理组合框上的事件

这是在ComboBoxDemo.java中注册和实现组合框上动作监听器的代码：

public class ComboBoxDemo ... implements ActionListener {
    . . .
        petList.addActionListener(this) {
    . . .
    public void actionPerformed(ActionEvent e) {
        JComboBox cb = (JComboBox)e.getSource();
        String petName = (String)cb.getSelectedItem();
        updateLabel(petName);
    }
    . . .
}

此动作侦听器从组合框中获取新选择的项目，使用它来计算图像文件的名称，并更新标签以显示图像。当用户从组合框菜单中选择项目时，组合框会触发一个动作事件。有关实现动作侦听器的一般信息，请参阅如何编写动作侦听器。

组合框还会生成项目事件，当任何项目的选择状态发生变化时会触发这些事件。在组合框中一次只能选择一个项目，因此当用户进行新选择时，先前选择的项目将取消选择。因此，每次用户从菜单中选择不同项目时都会触发两个项目事件。如果用户选择相同项目，则不会触发项目事件。使用addItemListener在组合框上注册项目侦听器。如何编写项目侦听器提供了有关实现项目侦听器的一般信息。

尽管JComboBox继承了用于注册低级事件的方法例如焦点、键盘和鼠标事件但我们建议不要在组合框上监听低级事件。原因在于：组合框是一个复合组件 它由两个或更多其他组件组成。组合框本身会触发高级事件，如动作事件。其子组件会触发低级事件，如鼠标、键盘和焦点事件。低级事件和触发它们的子组件是与外观相关的。为了避免编写与外观相关的代码，您应该只在复合组件（如组合框）上监听高级事件。有关事件的信息，包括有关高级和低级事件的讨论，请参阅编写事件侦听器。

使用可编辑的组合框

这是一个演示应用程序的图片，该应用程序使用可编辑的组合框来输入用于格式化日期的模式。

试试这个：

点击“启动”按钮以使用Java™ Web Start运行 ComboBox2 演示（下载 JDK 7 或更高版本）。或者，要自行编译和运行示例，请参考示例索引。
通过从组合框菜单中选择一个新模式来输入新模式。程序会重新格式化当前日期和时间。
通过键入一个新模式并按 Enter 来输入新模式。程序会再次重新格式化当前日期和时间。

以下代码取自ComboBoxDemo2.java，创建并设置了组合框：

String[] patternExamples = {
         "dd MMMMM yyyy",
         "dd.MM.yy",
         "MM/dd/yy",
         "yyyy.MM.dd G 'at' hh:mm:ss z",
         "EEE, MMM d, ''yy",
         "h:mm a",
         "H:mm:ss:SSS",
         "K:mm a,z",
         "yyyy.MMMMM.dd GGG hh:mm aaa"
};
. . .
JComboBox patternList = new JComboBox(patternExamples);
patternList.setEditable(true);
patternList.addActionListener(this);

此代码与前一个示例非常相似，但需要解释几句。粗体代码明确打开编辑以允许用户输入值。这是必要的，因为默认情况下，组合框不可编辑。此特定示例允许在组合框上进行编辑，因为其菜单不提供所有可能的日期格式化模式，只提供常用模式的快捷方式。

可编辑的组合框在用户从菜单中选择项目和用户键入 Enter 时会触发动作事件。请注意，当用户在组合框中输入值时，菜单保持不变。如果需要，您可以轻松编写一个动作侦听器，每次用户键入唯一值时都向组合框的菜单添加一个新项目。

请参阅国际化以了解有关格式化日期和其他类型数据的更多信息。

提供自定义渲染器

组合框使用渲染器来显示其菜单中的每个项目。如果组合框不可编辑，则还使用渲染器来显示当前选定的项目。另一方面，可编辑的组合框使用编辑器来显示所选项目。组合框的渲染器必须实现ListCellRenderer接口。组合框的编辑器必须实现ComboBoxEditor。本节展示了如何为不可编辑的组合框提供自定义渲染器。

默认渲染器知道如何渲染字符串和图标。如果您将其他对象放入组合框中，默认渲染器将调用toString方法提供要显示的字符串。您可以通过实现自己的ListCellRenderer来自定义组合框及其项目的渲染方式。

这是一个使用具有自定义渲染器的组合框的应用程序的图片：

单击“启动”按钮以使用Java™ Web Start运行 CustomComboBox 演示（下载 JDK 7 或更高版本）。或者，要自行编译和运行示例，请参考示例索引。

此示例的完整源代码位于CustomComboBoxDemo.java中。要获取所需的图像文件，请参考示例索引。

示例中的以下语句创建了ComboBoxRenderer（一个自定义类）的实例，并将该实例设置为组合框的渲染器：

JComboBox petList = new JComboBox(intArray);
. . .
ComboBoxRenderer renderer = new ComboBoxRenderer();
renderer.setPreferredSize(new Dimension(200, 130));
petList.setRenderer(renderer);
petList.setMaximumRowCount(3);

最后一行设置了组合框的最大行数，这决定了菜单显示时可见的项目数量。如果组合框中的项目数量大于其最大行数，则菜单会有滚动条。菜单中的图标对于一个菜单来说相当大，因此我们的代码将行数限制为 3。这是ComboBoxRenderer的实现，一个将图标和文本并排放置的渲染器：

class ComboBoxRenderer extends JLabel
                       implements ListCellRenderer {
    . . .
    public ComboBoxRenderer() {
        setOpaque(true);
        setHorizontalAlignment(CENTER);
        setVerticalAlignment(CENTER);
    }

    /*
     * This method finds the image and text corresponding
     * to the selected value and returns the label, set up
     * to display the text and image.
     */
    public Component getListCellRendererComponent(
                                       JList list,
                                       Object value,
                                       int index,
                                       boolean isSelected,
                                       boolean cellHasFocus) {
        //Get the selected index. (The index parameter isn't
        //always valid, so just use the value.)
        int selectedIndex = ((Integer)value).intValue();

        if (isSelected) {
            setBackground(list.getSelectionBackground());
            setForeground(list.getSelectionForeground());
        } else {
            setBackground(list.getBackground());
            setForeground(list.getForeground());
        }

        //Set the icon and text.  If icon was null, say so.
        ImageIcon icon = images[selectedIndex];
        String pet = petStrings[selectedIndex];
        setIcon(icon);
        if (icon != null) {
            setText(pet);
            setFont(list.getFont());
        } else {
            setUhOhText(pet + " (no image available)",
                        list.getFont());
        }

        return this;
    }
    . . .
}

作为ListCellRenderer，ComboBoxRenderer实现了一个名为getListCellRendererComponent的方法，该方法返回一个组件，其paintComponent方法用于显示组合框及其每个项目。显示图像和图标的最简单方法是使用标签。因此，ComboBoxRenderer是标签的子类并返回自身。getListCellRendererComponent的实现配置了渲染器以显示当前选定的图标及其描述。

这些参数被传递给getListCellRendererComponent：

JList list 用于在幕后显示项目的列表对象。示例使用此对象的颜色来设置前景色和背景色。
Object value 要渲染的对象。在本例中是一个Integer。
int index 要渲染的对象的索引。
boolean isSelected 指示要渲染的对象是否被选中。示例使用它来确定使用哪些颜色。
boolean cellHasFocus 指示要渲染的对象是否具有焦点。

请注意，组合框和列表使用相同类型的渲染器 ListCellRenderer。如果对于您的程序有意义，您可以通过在组合框和列表之间共享渲染器来节省一些时间。

组合框 API

以下表列出了常用的JComboBox构造函数和方法。您最有可能在JComboBox对象上调用的其他方法是从其超类继承的方法，例如setPreferredSize。请参阅 The JComponent API 以查看常用继承方法的表格。

使用组合框的 API 分为两类：

设置或获取组合框菜单中的项目
自定义组合框的操作

设置或获取组合框菜单中的项目

方法	目的

| JComboBox() JComboBox(ComboBoxModel)

JComboBox(Object[])

JComboBox(Vector) | 创建一个具有指定项目的组合框菜单。使用默认构造函数创建的组合框初始时没有项目在菜单中。其他每个构造函数都从其参数初始化菜单：一个模型对象，一个对象数组或一个Vector对象。

void addItem(Object) void insertItemAt(Object, int)	将指定对象添加或插入到组合框菜单中。插入方法将指定对象放在指定索引处，因此在该索引处当前对象之前插入它。这些方法要求组合框的数据模型是`MutableComboBoxModel`的实例。
Object getItemAt(int) Object getSelectedItem()	从组合框菜单中获取一个项目。

| void removeAllItems() void removeItemAt(int)

void removeItem(Object) | 从组合框菜单中移除一个或多个项目。这些方法要求组合框的数据模型是MutableComboBoxModel的实例。

int getItemCount()	获取组合框菜单中项目的数量。
void setModel(ComboBoxModel) ComboBoxModel getModel()	设置或获取提供组合框菜单中项目的数据模型。
void setAction(Action) Action getAction()	设置或获取与组合框关联的`Action`。有关更多信息，请参阅如何使用操作。

自定义组合框的操作

方法或构造函数	目的
void addActionListener(ActionListener)	向组合框添加动作监听器。当用户从组合框菜单中选择项目时，或者在可编辑的组合框中，当用户按下 Enter 键时，将调用监听器的`actionPerformed`方法。
void addItemListener(ItemListener)	向组合框添加项目监听器。当任何组合框项目的选择状态发生变化时，将调用监听器的`itemStateChanged`方法。
void setEditable(boolean) boolean isEditable()	设置或获取用户是否可以在组合框中输入。
void setRenderer(ListCellRenderer) ListCellRenderer getRenderer()	设置或获取负责在组合框中绘制所选项目的对象。仅当组合框不可编辑时才使用渲染器。如果组合框是可编辑的，则编辑器用于绘制所选项目。
void setEditor(ComboBoxEditor) ComboBoxEditor getEditor()	设置或获取负责在组合框中绘制和编辑所选项目的对象。仅当组合框可编辑时才使用编辑器。如果组合框不可编辑，则使用渲染器来绘制所选项目。

使用组合框的示例

这个表格展示了使用JComboBox的示例以及这些示例的描述位置。

示例	描述位置	注释
`ComboBoxDemo`	这一部分	使用不可编辑的组合框。
`ComboBoxDemo2`	这一部分	使用可编辑的组合框。
`CustomComboBoxDemo`	这一部分	为组合框提供自定义渲染器。
`TableRenderDemo`	如何使用表格（将组合框用作编辑器）	展示了如何将组合框用作表格单元格编辑器。

如何制作对话框

原文：docs.oracle.com/javase/tutorial/uiswing/components/dialog.html

对话框窗口是一个独立的子窗口，用于在主 Swing 应用程序窗口之外显示临时通知。大多数对话框向用户呈现错误消息或警告，但对话框也可以呈现图像、目录树或与管理它们的主要 Swing 应用程序兼容的任何内容。

为了方便起见，几个 Swing 组件类可以直接实例化和显示对话框。要创建简单的标准对话框，您可以使用 JOptionPane 类。ProgressMonitor 类可以显示操作的进度对话框。另外两个类，JColorChooser 和 JFileChooser，也提供标准对话框。要打开打印对话框，您可以使用打印 API。要创建自定义对话框，请直接使用 JDialog 类。

简单对话框的代码可以很简洁。例如，这是一个信息对话框：

以下是创建和显示它的代码：

JOptionPane.showMessageDialog(frame, "Eggs are not supposed to be green.");

本节的其余部分涵盖以下主题：

对话框概述
对话框示例
JOptionPane 功能
创建和显示简单对话框
自定义按钮文本
从对话框获取用户输入
停止自动关闭对话框
对话框 API
使用对话框的示例

对话框概述

每个对话框都依赖于一个 Frame 组件。当该 Frame 被销毁时，其依赖的对话框也会被销毁。当 Frame 最小化时，其依赖的对话框也会从屏幕上消失。当 Frame 最大化时，其依赖的对话框会重新显示在屏幕上。Swing 的 JDialog 类从 AWT 的 Dialog 类继承了这种行为。

对话框可以是模态的。当模态对话框可见时，它会阻止用户对程序中所有其他窗口的输入。JOptionPane 创建的 JDialog 是模态的。要创建非模态对话框，必须直接使用 JDialog 类。

从 JDK 7 开始，您可以使用新的 Modality API 修改对话框窗口的模态行为。详情请参阅新的 Modality API。

JDialog 类是 AWT java.awt.Dialog 类的子类。它为 Dialog 对象添加了一个根窗格容器和默认关闭操作的支持。这些都是 JFrame 具有的相同特性，直接使用 JDialog 非常类似于使用 JFrame。如果你要直接使用 JDialog，那么你应该了解使用顶层容器和如何创建框架中的内容，特别是响应窗口关闭事件。

即使你使用 JOptionPane 实现对话框，背后仍然使用 JDialog。原因是 JOptionPane 只是一个容器，可以自动创建一个 JDialog 并将自身添加到 JDialog 的内容窗格中。

DialogDemo 示例

这是一个显示对话框的应用程序的图片。

试试这个：

点击启动按钮以使用 Java™ Web Start 运行 Dialog Demo（下载 JDK 7 或更高版本）。或者，要自行编译和运行示例，请参考示例索引。
点击 Show it! 按钮。

一个模态对话框将出现。在关闭它之前，应用程序将无响应，尽管如果需要会重绘自身。你可以通过在对话框中点击按钮或显式关闭，例如使用对话框窗口装饰，来关闭对话框。
在更多对话框面板中，点击底部的单选按钮，然后点击 Show it! 按钮。

一个非模态对话框将出现。请注意，当非模态对话框出现时，DialogDemo 窗口仍然完全可用。
当非模态对话框显示时，将 DialogDemo 窗口最小化。

对话框将从屏幕上消失，直到你将 DialogDemo 窗口还原。

JOptionPane 特性

使用 JOptionPane，你可以快速创建和自定义几种不同类型的对话框。JOptionPane 提供了支持布局标准对话框、提供图标、指定对话框标题和文本以及自定义按钮文本的功能。其他功能允许你自定义对话框显示的组件，并指定对话框应该出现在屏幕的位置。你甚至可以指定选项对话框将自己放入一个内部框架 (JInternalFrame) 而不是一个 JDialog。

当你创建一个 JOptionPane 时，与外观相关的代码会向 JOptionPane 添加组件并确定这些组件的布局。

JOptionPane的图标支持让您可以轻松指定对话框显示的图标。您可以使用自定义图标，没有图标，或者四种标准JOptionPane图标之一（问题，信息，警告和错误）。每种外观和感觉都有其自己版本的这四个标准图标。下图显示了 Java（和 Windows）外观和感觉中使用的图标。

JOptionPane 使用的图标

图标描述	Java 外观和感觉	Windows 外观和感觉
问题
信息
警告
错误

创建和显示简单对话框

对于大多数简单的模态对话框，您可以使用JOptionPane的show*Xxx*Dialog方法创建和显示对话框。如果您的对话框应该是一个内部框架，那么在show后面添加Internal，例如，showMessageDialog变为showInternalMessageDialog。如果您需要控制对话框的窗口关闭行为，或者不希望对话框是模态的，那么您应该直接实例化JOptionPane并将其添加到JDialog实例中。然后在JDialog上调用setVisible(true)使其显示。

最有用的两个show*Xxx*Dialog方法是showMessageDialog和showOptionDialog。showMessageDialog方法显示一个简单的单按钮对话框。showOptionDialog方法显示一个自定义对话框，可以显示各种带有自定义按钮文本的按钮，并且可以包含标准文本消息或一组组件。

另外两个show*Xxx*Dialog方法使用较少。showConfirmDialog方法要求用户确认某事，但呈现标准按钮文本（例如 Yes/No 或本地化等效文本），而不是根据用户情况定制的按钮文本（例如 Start/Cancel）。第四个方法showInputDialog旨在显示一个模态对话框，从用户那里获取一个字符串，可以使用文本字段，不可编辑的组合框或列表。

以下是一些示例，取自DialogDemo.java，演示了如何使用showMessageDialog、showOptionDialog和JOptionPane构造函数。有关更多示例代码，请参见DialogDemo.java和使用对话框的示例中列出的其他程序。

showMessageDialog

显示一个带有一个按钮的模态对话框，按钮标记为“确定”（或本地化等效）。您可以轻松指定对话框显示的消息、图标和标题。以下是使用showMessageDialog的一些示例：

//default title and icon
JOptionPane.showMessageDialog(frame,
    "Eggs are not supposed to be green.");

//custom title, warning icon
JOptionPane.showMessageDialog(frame,
    "Eggs are not supposed to be green.",
    "Inane warning",
    JOptionPane.WARNING_MESSAGE);

//custom title, error icon
JOptionPane.showMessageDialog(frame,
    "Eggs are not supposed to be green.",
    "Inane error",
    JOptionPane.ERROR_MESSAGE);

//custom title, no icon
JOptionPane.showMessageDialog(frame,
    "Eggs are not supposed to be green.",
    "A plain message",
    JOptionPane.PLAIN_MESSAGE);

//custom title, custom icon
JOptionPane.showMessageDialog(frame,
    "Eggs are not supposed to be green.",
    "Inane custom dialog",
    JOptionPane.INFORMATION_MESSAGE,
    icon);

showOptionDialog

显示一个带有指定按钮、图标、消息、标题等的模态对话框。使用此方法，您可以更改标准对话框上按钮上显示的文本。您还可以执行许多其他类型的自定义。

//Custom button text
Object[] options = {"Yes, please",
                    "No, thanks",
                    "No eggs, no ham!"};
int n = JOptionPane.showOptionDialog(frame,
    "Would you like some green eggs to go "
    + "with that ham?",
    "A Silly Question",
    JOptionPane.YES_NO_CANCEL_OPTION,
    JOptionPane.QUESTION_MESSAGE,
    null,
    options,
    options[2]);

JOptionPane（构造函数）

创建一个带有指定按钮、图标、消息、标题等的JOptionPane。然后您必须将选项窗格添加到JDialog，在选项窗格上注册属性更改侦听器，并显示对话框。有关详细信息，请参见停止自动对话框关闭。

final JOptionPane optionPane = new JOptionPane(
    "The only way to close this dialog is by\n"
    + "pressing one of the following buttons.\n"
    + "Do you understand?",
    JOptionPane.QUESTION_MESSAGE,
    JOptionPane.YES_NO_OPTION);

所有show*Xxx*Dialog方法和JOptionPane构造函数的参数都是标准化的，尽管每种方法和构造函数的参数数量不同。以下列表描述了每个参数。要查看特定方法的确切参数列表，请参见对话框 API。

Component *parentComponent*

每个show*Xxx*Dialog方法的第一个参数始终是父组件，它必须是一个 Frame、Frame 内的组件或 null。如果指定了 Frame 或 Dialog，则对话框将出现在 Frame 的中心，并遵循该 Frame 的焦点行为。如果指定了 Frame 内的组件，则对话框将出现在该组件的中心，并遵循该组件的 Frame 的焦点行为。如果指定为 null，则外观和感觉将选择对话框的适当位置——通常是屏幕的中心——对话框不一定遵循任何可见 Frame 或 Dialog 的焦点行为。

JOptionPane构造函数不包括此参数。相反，您在创建包含JOptionPane的JDialog时指定父框架，并使用JDialog的setLocationRelativeTo方法设置对话框位置。

Object *message*

此必需参数指定对话框在主区域中应显示的内容。通常，您会指定一个字符串，这将导致对话框显示具有指定文本的标签。您可以通过在消息字符串中放置换行符（\n）来将消息分成多行。例如：

"Complete the sentence:\n \"Green eggs and...\""

String *title*

对话框的标题。

int *optionType*

指定出现在对话框底部的按钮集。从以下标准集之一中选择：DEFAULT_OPTION，YES_NO_OPTION，YES_NO_CANCEL_OPTION，OK_CANCEL_OPTION。

int *messageType*

此参数确定对话框中显示的图标。从以下值中选择一个：PLAIN_MESSAGE（无图标），ERROR_MESSAGE，INFORMATION_MESSAGE，WARNING_MESSAGE，QUESTION_MESSAGE。

Icon *icon*

要在对话框中显示的图标。

Object[] *options*

通常用于指定对话框底部每个按钮显示的字符串。有关更多信息，请参阅在标准对话框中自定义按钮文本。也可用于指定要由按钮显示的图标或要添加到按钮行的非按钮组件。

Object *initialValue*

指定要选择的默认值。

您可以让选项窗格显示其默认图标，也可以使用消息类型或图标参数指定图标。默认情况下，使用showMessageDialog创建的选项窗格显示信息图标，使用showConfirmDialog或showInputDialog创建的选项窗格显示问题图标，使用JOptionPane构造函数创建的选项窗格不显示图标。要指定对话框显示标准图标或不显示图标，请指定与所需图标对应的消息类型。要指定自定义图标，请使用图标参数。只要图标参数具有非空值，图标参数就优先于消息类型；对话框将显示指定的图标。

自定义按钮文本

当您使用JOptionPane创建对话框时，您可以使用标准按钮文本（可能会因外观和语言环境而异）或指定不同的文本。默认情况下，选项窗格类型确定出现多少个按钮。例如，YES_NO_OPTION对话框有两个按钮，而YES_NO_CANCEL_OPTION对话框有三个按钮。

下面的代码取自DialogDemo.java，创建了两个 Yes/No 对话框。第一个对话框是使用showConfirmDialog实现的，该对话框使用外观词汇来表示两个按钮。第二个对话框使用showOptionDialog以便自定义词汇。除了词汇变化外，对话框是相同的。

//default icon, custom title
int n = JOptionPane.showConfirmDialog(
    frame,
    "Would you like green eggs and ham?",
    "An Inane Question",
    JOptionPane.YES_NO_OPTION);

Object[] options = {"Yes, please",
                    "No way!"};
int n = JOptionPane.showOptionDialog(frame,
    "Would you like green eggs and ham?",
    "A Silly Question",
    JOptionPane.YES_NO_OPTION,
    JOptionPane.QUESTION_MESSAGE,
    null,     //do not use a custom Icon
    options,  //the titles of buttons
    options[0]); //default button title

正如前面的代码片段所示，showMessageDialog、showConfirmDialog和showOptionDialog方法返回一个指示用户选择的整数。这个整数的值是YES_OPTION、NO_OPTION、CANCEL_OPTION、OK_OPTION和CLOSED_OPTION。除了CLOSED_OPTION，每个选项对应用户按下的按钮。当返回CLOSED_OPTION时，表示用户显式关闭了对话框窗口，而不是通过选择选项窗格内的按钮。

即使更改标准对话框按钮显示的字符串，返回值仍然是预定义整数之一。例如，YES_NO_OPTION对话框始终返回以下值之一：YES_OPTION、NO_OPTION或CLOSED_OPTION。

从对话框获取用户输入

唯一不返回整数的show*Xxx*Dialog形式是showInputDialog，它返回一个Object。这个Object通常是反映用户选择的String。以下是使用showInputDialog创建一个对话框，让用户选择三个字符串的示例：

Object[] possibilities = {"ham", "spam", "yam"};
String s = (String)JOptionPane.showInputDialog(
                    frame,
                    "Complete the sentence:\n"
                    + "\"Green eggs and...\"",
                    "Customized Dialog",
                    JOptionPane.PLAIN_MESSAGE,
                    icon,
                    possibilities,
                    "ham");

//If a string was returned, say so.
if ((s != null) && (s.length() > 0)) {
    setLabel("Green eggs and... " + s + "!");
    return;
}

//If you're here, the return value was null/empty.
setLabel("Come on, finish the sentence!");

如果您不在乎限制用户的选择，可以使用少量参数的showInputDialog方法形式之一，或者为对象数组指定null。在 Java 外观中，将null替换为possibilities会导致对话框具有文本字段并且看起来像这样：

因为用户可以在文本字段中输入任何内容，您可能希望检查返回的值，并在无效时要求用户重试。另一种方法是创建一个自定义对话框，在返回之前验证用户输入的数据。查看CustomDialog.java以查看验证数据的示例。

如果您正在设计自定义对话框，您需要设计对话框的 API，以便查询对话框用户选择了什么。例如，CustomDialog有一个getValidatedText方法，返回用户输入的文本。

停止自动对话框关闭

默认情况下，当用户单击由JOptionPane创建的按钮时，对话框会关闭。但是如果您希望在关闭对话框之前检查用户的答案怎么办？在这种情况下，您必须实现自己的属性更改侦听器，以便当用户单击按钮时，对话框不会自动关闭。

DialogDemo包含两个对话框，实现了属性更改监听器。其中一个对话框是一个自定义模态对话框，实现在CustomDialog中，它使用JOptionPane来获取标准图标和布局辅助。另一个对话框，其代码如下，使用了标准的 Yes/No JOptionPane。虽然这个对话框写得相当无用，但其代码足够简单，可以用作更复杂对话框的模板。

除了设置属性更改监听器外，以下代码还调用了JDialog的setDefaultCloseOperation方法，并实现了一个窗口监听器，以正确处理窗口关闭尝试。如果您不在意用户显式关闭窗口时收到通知，则忽略粗体代码。

final JOptionPane optionPane = new JOptionPane(
                "The only way to close this dialog is by\n"
                + "pressing one of the following buttons.\n"
                + "Do you understand?",
                JOptionPane.QUESTION_MESSAGE,
                JOptionPane.YES_NO_OPTION);

final JDialog dialog = new JDialog(frame, 
                             "Click a button",
                             true);
dialog.setContentPane(optionPane);
dialog.setDefaultCloseOperation(
    JDialog.DO_NOTHING_ON_CLOSE);
dialog.addWindowListener(new WindowAdapter() {
    public void windowClosing(WindowEvent we) {
        setLabel("Thwarted user attempt to close window.");
    }
});
optionPane.addPropertyChangeListener(
    new PropertyChangeListener() {
        public void propertyChange(PropertyChangeEvent e) {
            String prop = e.getPropertyName();

            if (dialog.isVisible() 
             && (e.getSource() == optionPane)
             && (prop.equals(JOptionPane.VALUE_PROPERTY))) {
                //If you were going to check something
                //before closing the window, you'd do
                //it here.
                dialog.setVisible(false);
            }
        }
    });
dialog.pack();
dialog.setVisible(true);

int value = ((Integer)optionPane.getValue()).intValue();
if (value == JOptionPane.YES_OPTION) {
    setLabel("Good.");
} else if (value == JOptionPane.NO_OPTION) {
    setLabel("Try using the window decorations "
             + "to close the non-auto-closing dialog. "
             + "You can't!");
}

对话框 API

以下表格列出了常用的JOptionPane和JDialog构造函数和方法。您可能会调用的其他方法由Dialog、Window和Component类定义，并包括pack、setSize和setVisible。

API 如下列出：

显示标准模态对话框（使用JOptionPane类方法）
直接使用JOptionPane的方法
常用的JDialog构造函数和方法

显示标准模态对话框（使用JOptionPane类方法）

方法	目的

| 静态 void showMessageDialog(Component, Object) 静态 void showMessageDialog(Component, Object, String, int)

静态 void showMessageDialog(Component, Object, String, int, Icon) | 显示一个单按钮的模态对话框，向用户提供一些信息。参数按顺序指定了父组件、消息、标题、消息类型和对话框的图标。参见创建和显示简单对话框以讨论参数及其效果。 |

静态 int showOptionDialog(Component, Object, String, int, int, Icon, Object[], Object)	显示一个自定义的模态对话框。参数按顺序指定父组件、消息、标题、选项类型、消息类型、图标、选项和对话框的初始值。有关参数及其效果的讨论，请参见创建和显示简单对话框。

| 静态 int showConfirmDialog(Component, Object) 静态 int showConfirmDialog(Component, Object, String, int)

静态 int showConfirmDialog(Component, Object, String, int, int)

静态 int showConfirmDialog(Component, Object, String, int, int, Icon) | 显示一个询问用户问题的模态对话框。参数按顺序指定父组件、消息、标题、选项类型、消息类型和对话框的图标。有关参数及其效果的讨论，请参见创建和显示简单对话框。 |

| 静态 String showInputDialog(Object) 静态 String showInputDialog(Component, Object)

静态 String showInputDialog(Component, Object, String, int)

静态 String showInputDialog(Component, Object, String, int, Icon, Object[], Object) | 显示一个提示用户输入的模态对话框。单参数版本仅指定消息，父组件假定为 null。其他版本的参数按顺序指定父组件、消息、标题、消息类型、图标、选项和对话框的初始值。有关参数及其效果的讨论，请参见创建和显示简单对话框。 |

| static void showInternalMessageDialog(...) static void showInternalOptionDialog(...)

static void showInternalConfirmDialog(...)

static String showInternalInputDialog(...) | 实现一个标准对话框作为内部框架。请参阅JOptionPane API 文档以获取确切的参数列表。

直接使用JOptionPane的方法

方法或构造函数	目的

| JOptionPane() JOptionPane(Object)

JOptionPane(Object, int)的目的是实现一个标准对话框作为内部框架。

JOptionPane(Object, int, int)的目的是创建一个JOptionPane实例。请参阅创建和显示简单对话框以讨论参数及其效果。

JOptionPane(Object, int, int, Icon)

JOptionPane(Object, int, int, Icon, Object[])的目的是创建一个JOptionPane实例。请参阅创建和显示简单对话框以讨论参数及其效果。

JOptionPane(Object, int, int, Icon, Object[], Object)的目的是创建一个JOptionPane实例。请参阅创建和显示简单对话框以讨论参数及其效果。

static Frame getFrameForComponent(Component) static JDesktopPane getDesktopPaneForComponent(Component)	便捷的`JOptionPane`类方法，用于找到指定组件所在的框架或桌面窗格。

| int getMaxCharactersPerLineCount() | 确定选项面板文本中将自动插入换行符的位置。（默认值为Integer.MAX_VALUE。）要使用此方法，必须创建一个JOptionPane子类。例如，以下代码会导致一个选项面板，每行一个单词，因为字符串中的每个单词都是 5 个字符或更少：

JOptionPane op = new JOptionPane("This is the text.") {
    public int getMaxCharactersPerLineCount() {
        return 5;
    }
};

经常使用的JDialog构造函数和方法

方法或构造函数	目的

| JDialog() JDialog(Dialog)

JDialog(Dialog, boolean)

JDialog(Dialog, String)

JDialog(Dialog, String, boolean)

JDialog(Dialog, String, boolean, GraphicsConfiguration)

JDialog(Frame)

JDialog(Frame, boolean)

JDialog(Frame, String)

JDialog(Frame, String, boolean)

JDialog(Frame, String, boolean, GraphicsConfiguration)

JDialog(Window owner)

JDialog(Window owner, Dialog.ModalityType modalityType)

JDialog(Window owner, String title)

JDialog(Window owner, String title, Dialog.ModalityType modalityType)

JDialog(Window owner, String title, Dialog.ModalityType modalityType, GraphicsConfiguration gc) | 创建一个JDialog实例。如果有Frame参数，那么它是对话框依赖的框架（通常是一个JFrame对象）。将布尔参数设为true以指定模态对话框，设为false或者省略以指定非模态对话框。还可以使用字符串参数指定对话框的标题。 |

void setContentPane(Container) Container getContentPane()	获取和设置内容面板，通常是对话框所有组件的容器。查看使用顶层容器获取更多信息。
void setDefaultCloseOperation(int) int getDefaultCloseOperation()	获取和设置用户尝试关闭对话框时的操作。可能的值：`DISPOSE_ON_CLOSE`、`DO_NOTHING_ON_CLOSE`、`HIDE_ON_CLOSE`（默认）。查看响应窗口关闭事件获取更多信息。
void setLocationRelativeTo(Component)	将对话框居中于指定组件。
static void setDefaultLookAndFeelDecorated(boolean) static boolean isDefaultLookAndFeelDecorated()	设置或获取提示，指示对话框的窗口装饰（如边框或关闭窗口的小部件）是否应由当前外观提供。否则，对话框的装饰将由当前窗口管理器提供。查看指定窗口装饰获取更多信息。

使用对话框的示例

这个表列出了使用JOptionPane或JDialog的示例。要查找其他使用对话框的示例，请参阅进度条、颜色选择器和文件选择器的示例列表。

示例	描述位置	注意事项
`DialogDemo`, `CustomDialog`	本节	创建多种类型的对话框，使用`JOptionPane`和`JDialog`。
`框架`		当用户选择退出菜单项时，弹出确认对话框。
`列表对话框`	如何使用 BoxLayout	实现一个包含滚动列表和两个按钮的模态对话框。除了实用方法 `getFrameForComponent` 外，不使用 `JOptionPane`。

posted @ 2024-04-12 14:33 绝不原创的飞龙阅读(41) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

Java 中文官方教程 2022 版（十五）

文本组件 API

如何使用各种组件

如何制作 Applets

JApplet 提供的功能

小程序中的线程

在 Swing 小程序中使用图像

在 HTML 页面中嵌入小程序

小程序 JApplet API

Applet 示例

如何使用按钮、复选框和单选按钮

如何使用通用按钮 API

如何使用 JButton 功能

如何使用复选框

如何使用单选按钮

按钮 API

使用不同类型按钮的示例

如何使用 ButtonGroup 组件

如何使用 ButtonGroup 功能

ButtonGroup API

ButtonGroup 示例

如何使用颜色选择器

另一个示例：ColorChooserDemo2

在对话框中显示颜色选择器

移除或替换预览面板

创建自定义选择器面板

颜色选择器 API

使用颜色选择器的示例

如何使用组合框

使用不可编辑的组合框

处理组合框上的事件

使用可编辑的组合框

提供自定义渲染器

组合框 API

使用组合框的示例

如何制作对话框

对话框概述

DialogDemo 示例

JOptionPane 特性

创建和显示简单对话框

自定义按钮文本

从对话框获取用户输入

停止自动对话框关闭

对话框 API

使用对话框的示例

公告

`JApplet` 提供的功能