如何使用焦点子系统

原文： https://docs.oracle.com/javase/tutorial/uiswing/misc/focus.html

许多组件 - 甚至那些主要使用鼠标操作的组件，如按钮 - 都可以通过键盘操作。要使按键影响组件，组件必须具有键盘焦点。

从用户的角度来看，具有键盘焦点的组件通常是突出的 - 例如，带有点状或黑色边框。包含该组件的窗口也比屏幕上的其他窗口更突出。这些视觉提示让用户知道任何打字将与哪个组件相关。窗口系统中一次只有一个组件可以具有键盘焦点。

窗口获得焦点的确切方式取决于窗口系统。在所有平台上都没有万无一失的方法来确保窗口获得焦点。在某些操作系统（如 Microsoft Windows）上，前窗通常会成为焦点窗口。在这些情况下， Window.toFront 方法将窗口移动到前面，从而使其成为焦点。但是，在其他操作系统（如 Solaris™Operating System）上，窗口管理器可以根据光标位置选择聚焦窗口，在这些情况下，Window.toFront方法的行为是不同的。

组件通常在用户单击它时，或当用户在组件之间进行选项卡或以其他方式与组件交互时获得焦点。组件也可以以编程方式给予焦点，例如当其包含框架或对话框可见时。此代码段显示了每次窗口获得焦点时如何为特定组件提供焦点：

  1. //Make textField get the focus whenever frame is activated.
  2. frame.addWindowFocusListener(new WindowAdapter() {
  3.     public void windowGainedFocus(WindowEvent e) {
  4.         textField.requestFocusInWindow();
  5.     }
  6. });

如果要在第一次激活窗口时确保特定组件获得焦点，则可以在组件实现后，但在显示帧之前调用组件上的 requestFocusInWindow 方法。以下示例代码显示了如何执行此操作：

  1.     //...Where initialization occurs...
  2.     JFrame frame = new JFrame("Test");
  3.     JPanel panel = new JPanel(new BorderLayout());
  5.     //...Create a variety of components here...
  7.     //Create the component that will have the initial focus.
  8.     JButton button = new JButton("I am first");
  9.     panel.add(button);
  10.     frame.getContentPane().add(panel);  //Add it to the panel
  12.     frame.pack();  //Realize the components.
  13.     //This button will have the initial focus.
  14.     button.requestFocusInWindow(); 
  15.     frame.setVisible(true); //Display the window.

或者，您可以将自定义FocusTraversalPolicy应用于帧并调用getDefaultComponent方法以确定哪个组件将获得焦点。

本节的其余部分包括以下主题：

焦点子系统旨在尽可能无形地做正确的事情。在大多数情况下，它的行为方式合理，如果不合理，您可以通过各种方式调整其行为。一些常见情况可能包括：

  • 排序是正确的，但没有设置具有焦点的第一个组件。如上一节中的代码片段所示，当窗口变为可见时，您可以使用requestFocusInWindow方法在组件上设置焦点。
  • 订购错了。要解决此问题，您可以更改包含层次结构，可以更改组件添加到其容器的顺序，也可以创建自定义焦点遍历策略。有关详细信息，请参阅自定义焦点遍历。
  • 必须防止组件失去焦点，或者需要在组件失去焦点之前检查组件中的值。 输入验证是此问题的解决方案。
  • 自定义组件没有得到关注。要解决此问题，您需要确保它满足使自定义组件可聚焦中列出的所有要求。

FocusConceptsDemo示例说明了一些概念。

The FocusConceptsDemo example

Try this:

  1. 单击“启动”按钮以使用 Java™Web Start （下载 JDK 7 或更高版本）运行 FocusConceptsDemo。或者，要自己编译并运行示例，请参考示例索引。 Launches the FocusConceptsDemo application

  2. 如有必要，请单击窗口以获得焦点。

  3. 使用 Tab 键将焦点从组件移动到组件。 您会注意到当焦点移动到文本区域时，它会停留在文本区域中。
  4. 使用 Control-Tab 将焦点移出文本区域。
  5. 使用 Shift-Tab 将焦点向相反方向移动。
  6. 使用 Control-Shift-Tab 将焦点从相反方向移出文本区域。

KeyboardFocusManager是焦点子系统的关键元素。它管理状态并启动更改。键盘管理器跟踪焦点所有者 _ - 从键盘接收键入的组件。聚焦窗口*是包含焦点所有者的窗口。

JWindow and focus: To use a JWindow component in your GUI, you should know that the JWindow component’s owning frame must be visible in order for any components in the window to get the focus. By default, if you do not specify an owning frame for a JWindow component, an invisible owning frame is created for it. The result is that components in the JWindow component might not be able to get the focus. The solution is either to specify a visible owning frame when creating the JWindow component, or to use an undecorated JFrame component instead.

焦点循环（或焦点遍历循环）是一组在包含层次结构中共享共同祖先的组件。焦点循环根是作为特定焦点遍历循环的根的容器。默认情况下，每个JWindow和JInternalFrame组件都可以是焦点循环根。焦点循环根本身可以包含一个或多个焦点循环根。以下 Swing 对象可以是焦点循环根：JApplet，JDesktopPane，JDialog，JEditorPane，JFrame，JInternalFrame和JWindow。虽然可能看起来JTable和JTree对象是焦点循环根，但它们不是。

焦点遍历策略确定一组组件的导航顺序。 Swing 提供 LayoutFocusTraversalPolicy类，它根据布局管理器相关因素（如大小，位置和组件方向）决定导航顺序。在聚焦周期内，可以向前或向后导航组件。在焦点循环根的层次结构中，向上遍历将焦点从当前循环中移出到父循环中。

在大多数外观和感觉模型中，使用 Tab 和 Shift-Tab 键导航组件。这些键是默认的焦点遍历键，可以通过编程方式进行更改。例如，您可以使用以下四行代码添加 Enter 作为前向焦点遍历键：

  1. Set forwardKeys = getFocusTraversalKeys(
  2.     KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);
  3. Set newForwardKeys = new HashSet(forwardKeys);
  4. newForwardKeys.add(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0));
  5. setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
  6.     newForwardKeys);

Tab 将焦点向前移动。 Shift-Tab 向后移动焦点。例如，在 FocusConceptsDemo 中，第一个按钮具有初始焦点。 Tabbing 将焦点通过按钮移动到文本区域。附加标签将光标移动到文本区域内，但不会移出文本区域，因为在文本区域内，Tab 是而不是焦点遍历键。但是，Control-Tab 将焦点移出文本区域并移动到第一个文本字段中。同样，Control-Shift-Tab 将焦点移出文本区域并移动到上一个组件中。约定使用 Control 键将焦点移出任何以特殊方式处理 Tab 的组件，例如JTable。

您刚刚收到了焦点架构的简要介绍。如果您需要更多详细信息，请参阅焦点子系统的规格。

GUI 设计的一个常见要求是限制用户输入的组件 - 例如，仅允许以十进制格式（例如金钱）输入数字的文本字段或仅允许 5 位数字输入邮政编码的文本字段。易于使用的格式化文本字段组件，允许输入限制为各种可本地化的格式。您还可以为文本字段指定自定义格式化程序，它可以执行特殊检查，例如确定值是否不仅格式正确，而且合理。

您可以使用输入验证程序替代自定义格式化程序，或者当您拥有不是文本字段的组件时。输入验证程序允许您拒绝特定值，例如格式正确但无效的邮政编码，或超出所需范围的值，例如体温高于 110°F。要使用输入验证程序，请创建 InputVerifier的子类，创建子类的实例，并将实例设置为一个或多个组件的输入验证程序。

只要组件即将失去焦点，就会查询组件的输入验证程序。如果组件的值不可接受，则输入验证器可以采取适当的操作，例如拒绝在组件上产生焦点或用最后一个有效值替换用户的输入，然后允许焦点转移到下一个组件。但是，当焦点转移到另一个顶层组件时，不会调用InputVerifier。

以下两个例子显示了抵押贷款计算器。一个使用格式化文本字段，另一个使用输入验证和标准文本字段。

The InputVerificationDemo and example, which demonstrates

Try this:

  1. 单击“启动”按钮以使用 Java™Web Start （下载 JDK 7 或更高版本）运行 FormattedTextFieldDemo。或者，要自己编译并运行示例，请参考示例索引。 Launches the FormattedTextFieldDemo application

  2. 单击“启动”按钮以使用 Java™Web Start （下载 JDK 7 或更高版本）运行 InputVerificationDemo。或者，要自己编译并运行示例，请参考示例索引。 Launches the InputVerificationDemo application

  3. 比较两个抵押贷款计算器并排。您将看到输入验证演示在每个可编辑文本字段的相关标签中指定有效输入值。尝试在两个示例中输入格式错误的值以观察行为。然后尝试输入格式正确但不可接受的值。

您可以在 InputVerificationDemo.java 中找到输入验证演示的代码。这是InputVerifier子类的代码，MyVerifier：

  1. class MyVerifier extends InputVerifier
  2.                  implements ActionListener {
  3.     double MIN_AMOUNT = 10000.0;
  4.     double MAX_AMOUNT = 10000000.0;
  5.     double MIN_RATE = 0.0;
  6.     int MIN_PERIOD = 1;
  7.     int MAX_PERIOD = 40;
  9.    public boolean shouldYieldFocus(JComponent input) {
  10.         boolean inputOK = verify(input);
  11.         makeItPretty(input);
  12.         updatePayment();
  14.         if (inputOK) {
  15.             return true;
  16.         } else {
  17.             Toolkit.getDefaultToolkit().beep();
  18.             return false;
  19.         }
  20.     }
  22.     protected void updatePayment() {
  23.         double amount = DEFAULT_AMOUNT;
  24.         double rate = DEFAULT_RATE;
  25.         int numPeriods = DEFAULT_PERIOD;
  26.         double payment = 0.0;
  28.         //Parse the values.
  29.         try {
  30.             amount = moneyFormat.parse(amountField.getText()).
  31.                               doubleValue();
  32.         } catch (ParseException pe) {pe.printStackTrace();}
  33.         try {
  34.             rate = percentFormat.parse(rateField.getText()).
  35.                                  doubleValue();
  36.         } catch (ParseException pe) {pe.printStackTrace();}
  37.         try {
  38.             numPeriods = decimalFormat.parse(numPeriodsField.getText()).
  39.                               intValue();
  40.         } catch (ParseException pe) {pe.printStackTrace();}
  42.         //Calculate the result and update the GUI.
  43.         payment = computePayment(amount, rate, numPeriods);
  44.         paymentField.setText(paymentFormat.format(payment));
  45.     }
  47.     //This method checks input, but should cause no side effects.
  48.     public boolean verify(JComponent input) {
  49.         return checkField(input, false);
  50.     }
  52.     protected void makeItPretty(JComponent input) {
  53.         checkField(input, true);
  54.     }
  56.     protected boolean checkField(JComponent input, boolean changeIt) {
  57.         if (input == amountField) {
  58.             return checkAmountField(changeIt);
  59.         } else if (input == rateField) {
  60.             return checkRateField(changeIt);
  61.         } else if (input == numPeriodsField) {
  62.             return checkNumPeriodsField(changeIt);
  63.         } else {
  64.             return true; //should not happen
  65.         }
  66.     }
  68.     //Checks that the amount field is valid.  If it is valid,
  69.     //it returns true; otherwise, returns false.  If the
  70.     //change argument is true, this method sets the
  71.     //value to the minimum or maximum value if necessary and
  72.     // (even if not) sets it to the parsed number so that it
  73.     // looks good -- no letters, for example.
  74.     protected boolean checkAmountField(boolean change) {
  75.         boolean wasValid = true;
  76.         double amount = DEFAULT_AMOUNT;
  78.         //Parse the value.
  79.         try {
  80.             amount = moneyFormat.parse(amountField.getText()).
  81.                               doubleValue();
  82.         } catch (ParseException pe) {
  83.             pe.printStackTrace();
  84.             wasValid = false;
  85.         }
  87.         //Value was invalid.
  88.         if ((amount < MIN_AMOUNT) || (amount > MAX_AMOUNT)) {
  89.             wasValid = false;
  90.             if (change) {
  91.                 if (amount < MIN_AMOUNT) {
  92.                     amount = MIN_AMOUNT;
  93.                 } else { // amount is greater than MAX_AMOUNT
  94.                     amount = MAX_AMOUNT;
  95.                 }
  96.             }
  97.         }
  99.         //Whether value was valid or not, format it nicely.
  100.         if (change) {
  101.             amountField.setText(moneyFormat.format(amount));
  102.             amountField.selectAll();
  103.         }
  105.         return wasValid;
  106.     }
  108.     //Checks that the rate field is valid.  If it is valid,
  109.     //it returns true; otherwise, returns false.  If the
  110.     //change argument is true, this method reigns in the
  111.     //value if necessary and (even if not) sets it to the
  112.     //parsed number so that it looks good -- no letters,
  113.     //for example.
  114.     protected boolean checkRateField(boolean change) {
  115.         ...//Similar to checkAmountField...
  116.     }
  118.     //Checks that the numPeriods field is valid.  If it is valid,
  119.     //it returns true; otherwise, returns false.  If the
  120.     //change argument is true, this method reigns in the
  121.     //value if necessary and (even if not) sets it to the
  122.     //parsed number so that it looks good -- no letters,
  123.     //for example.
  124.     protected boolean checkNumPeriodsField(boolean change) {
  125.         ...//Similar to checkAmountField...
  126.     }
  128.     public void actionPerformed(ActionEvent e) {
  129.         JTextField source = (JTextField)e.getSource();
  130.         shouldYieldFocus(source); //ignore return value
  131.         source.selectAll();
  132.     }
  133. }

请注意，verify方法用于检测无效值，但不执行任何其他操作。 verify方法仅用于确定输入是否有效 - 它应该永远不会显示对话框或导致任何其他副作用。 shouldYieldFocus方法调用verify，如果值无效，则将其设置为最小值或最大值。允许shouldYieldFocus方法产生副作用，在这种情况下，它始终格式化文本字段并且还可以更改其值。在我们的示例中，shouldYieldFocus方法始终返回 true，因此实际上永远不会阻止焦点的传输。这只是可以实现验证的一种方式。找到这个名为 InputVerificationDialogDemo 的演示版本的另一个版本，当用户输入无效并要求用户输入合法值时，该版本会显示一个对话框。

输入验证程序使用JComponent类的setInputVerifier方法安装。例如，InputVerificationDemo具有以下代码：

  1. private MyVerifier verifier = new MyVerifier();
  2. ...
  3. amountField.setInputVerifier(verifier);

要使组件获得焦点，它必须满足三个要求：它必须是可见的，启用的和可聚焦的。还可以给出输入映射。有关输入映射的更多信息，请阅读如何使用键绑定。

TrackFocusDemo 示例定义了简单组件Picture。它的构造器如下所示：

  1. public Picture(Image image) {
  2.     this.image = image;
  3.     setFocusable(true);
  4.     addMouseListener(this);
  5.     addFocusListener(this);
  6. }

对setFocusable(true)方法的调用使组件可以聚焦。如果在WHEN_FOCUSED输入映射中明确指定组件键绑定，则无需调用setFocusable方法。

若要直观地显示焦点的变化（仅在组件具有焦点时绘制红色边框），Picture具有焦点监听器。

为了在用户点击图片时获得焦点，该组件具有鼠标监听器。监听器的mouseClicked方法请求将焦点转移到图片。这是代码：

  1. public void mouseClicked(MouseEvent e) {
  2.     //Since the user clicked on us, let us get focus!
  3.     requestFocusInWindow();
  4. }

有关 TrackFocusDemo 示例的更多讨论，请参见跟踪焦点对多个组件的更改。

焦点子系统确定使用焦点遍历键（例如 Tab）进行导航时应用的默认顺序。 Swing 应用程序的策略由 LayoutFocusTraversalPolicy 确定。您可以使用 setFocusCycleRoot 方法在任何Container上设置焦点遍历策略。但是，如果容器不是焦点循环根，则可能没有明显效果。或者，您可以将焦点遍历策略供应器传递给FocusTraversalPolicy方法而不是焦点循环根。使用 isFocusTraversalPolicyProvider() 方法确定Container是否是焦点遍历策略提供者。使用 setFocusTraversalPolicyProvider() 方法设置容器以提供焦点遍历策略。

FocusTraversalDemo示例演示了如何自定义焦点行为。

The Focus Traversal Demo, which demonstrates a custom FocusTraversalPolicy.

Try this:

  1. 单击“启动”按钮以使用 Java™Web Start （下载 JDK 7 或更高版本）运行 FocusTraversalDemo。或者，要自己编译并运行示例，请参考示例索引。 Launches the FocusTraversalDemo application

  2. 如有必要，单击窗口以使其成为焦点。

  3. 在选择组件时注意焦点顺序。焦点顺序由组件添加到内容窗格的顺序决定。另请注意，复选框永远不会得到焦点;我们从焦点周期中删除了它。
  4. 要将焦点移出表格，请使用 Control-Tab 或 Ctrl-Shift-Tab。
  5. 单击自定义 FocusTraversalPolicy 复选框。此框在框架上安装自定义焦点遍历策略。
  6. 尝试再次浏览组件。请注意，焦点顺序现在是从左到右，从上到下的顺序。

您可以在 FocusTraversalDemo.java 中找到演示代码。

使用以下代码行从复选周期中删除了复选框：

  1. togglePolicy.setFocusable(false);

这是应用程序的自定义FocusTraversalPolicy：

  1. ...
  2. JTextField tf1 = new JTextField("Field 1");
  3. JTextField tf2 = new JTextField("A Bigger Field 2");
  4. JTextField tf3 = new JTextField("Field 3");
  5. JTextField tf4 = new JTextField("A Bigger Field 4");
  6. JTextField tf5 = new JTextField("Field 5");
  7. JTextField tf6 = new JTextField("A Bigger Field 6");
  8. JTable table = new JTable(4,3);
  9. ...
  10. public FocusTraversalDemo() {
  11.     super(new BorderLayout());
  13.     JTextField tf1 = new JTextField("Field 1");
  14.     JTextField tf2 = new JTextField("A Bigger Field 2");
  15.     JTextField tf3 = new JTextField("Field 3");
  16.     JTextField tf4 = new JTextField("A Bigger Field 4");
  17.     JTextField tf5 = new JTextField("Field 5");
  18.     JTextField tf6 = new JTextField("A Bigger Field 6");
  19.     JTable table = new JTable(4,3);
  20.     togglePolicy = new JCheckBox("Custom FocusTraversalPolicy");
  21.     togglePolicy.setActionCommand("toggle");
  22.     togglePolicy.addActionListener(this);
  23.     togglePolicy.setFocusable(false);  //Remove it from the focus cycle.
  24.     //Note that HTML is allowed and will break this run of text
  25.     //across two lines.
  26.     label = new JLabel("<html>Use Tab (or Shift-Tab) to navigate from component to component.<p>Control-Tab 
  27.     (or Control-Shift-Tab) allows you to break out of the JTable.</html>");
  29.     JPanel leftTextPanel = new JPanel(new GridLayout(3,2));
  30.     leftTextPanel.add(tf1, BorderLayout.PAGE_START);
  31.     leftTextPanel.add(tf3, BorderLayout.CENTER);
  32.     leftTextPanel.add(tf5, BorderLayout.PAGE_END);
  33.     leftTextPanel.setBorder(BorderFactory.createEmptyBorder(0,0,5,5));
  34.     JPanel rightTextPanel = new JPanel(new GridLayout(3,2));
  35.     rightTextPanel.add(tf2, BorderLayout.PAGE_START);
  36.     rightTextPanel.add(tf4, BorderLayout.CENTER);
  37.     rightTextPanel.add(tf6, BorderLayout.PAGE_END);
  38.     rightTextPanel.setBorder(BorderFactory.createEmptyBorder(0,0,5,5));
  39.     JPanel tablePanel = new JPanel(new GridLayout(0,1));
  40.     tablePanel.add(table, BorderLayout.CENTER);
  41.     tablePanel.setBorder(BorderFactory.createEtchedBorder());
  42.     JPanel bottomPanel = new JPanel(new GridLayout(2,1));
  43.     bottomPanel.add(togglePolicy, BorderLayout.PAGE_START);
  44.     bottomPanel.add(label, BorderLayout.PAGE_END);
  46.     add(leftTextPanel, BorderLayout.LINE_START);
  47.     add(rightTextPanel, BorderLayout.CENTER);
  48.     add(tablePanel, BorderLayout.LINE_END);
  49.     add(bottomPanel, BorderLayout.PAGE_END);
  50.     setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
  51.     Vector<Component> order = new Vector<Component>(7);
  52.     order.add(tf1);
  53.     order.add(tf2);
  54.     order.add(tf3);
  55.     order.add(tf4);
  56.     order.add(tf5);
  57.     order.add(tf6);
  58.     order.add(table);
  59.     newPolicy = new MyOwnFocusTraversalPolicy(order);
  60. }

要使用自定义FocusTraversalPolicy，请在任何焦点循环根上实现以下代码。

  1.     MyOwnFocusTraversalPolicy newPolicy = new MyOwnFocusTraversalPolicy();
  2.     frame.setFocusTraversalPolicy(newPolicy);

您可以通过将FocusTraversalPolicy设置为null来删除自定义焦点遍历策略，这将恢复默认策略。

在某些情况下，应用程序可能需要跟踪哪个组件具有焦点。此信息可用于动态更新菜单或状态栏。如果您只需要跟踪特定组件的焦点，那么实现焦点事件监听器可能是有意义的。

如果焦点监听器不合适，您可以在KeyboardFocusManager上注册PropertyChangeListener。向属性更改监听器通知涉及焦点的每个更改，包括对焦点所有者，焦点窗口和默认焦点遍历策略的更改。有关完整列表，请参见 KeyboardFocusManager 属性表。

演示了如何通过在键盘焦点管理器上安装属性更改监听器来跟踪焦点所有者。

The TrackFocusDemo example, which demonstrates tracking the focus owner.

Try this:

  1. 单击“启动”按钮以使用 Java™Web Start （下载 JDK 7 或更高版本）运行 TrackFocusDemo。或者，要自己编译并运行示例，请参考示例索引。 Launches the TrackFocusDemo application

  2. 如有必要，请单击窗口以获得焦点。

  3. 该窗口显示六个图像，每个图像由Picture组件显示。具有焦点的Picture用红色边框表示。窗口底部的标签描述了具有焦点的Picture。
  4. 使用 Tab 或 Shift-Tab 或单击图像将焦点移动到另一个Picture。由于已在键盘焦点管理器上注册了属性更改监听器，因此会检测焦点更改并正确更新标签。

您可以在 TrackFocusDemo.java 中查看演示代码。用于绘制图像的自定义组件可在 Picture.java 中找到。以下是定义和安装属性更改监听器的代码：

  1. KeyboardFocusManager focusManager =
  2.     KeyboardFocusManager.getCurrentKeyboardFocusManager();
  3. focusManager.addPropertyChangeListener(
  4.     new PropertyChangeListener() {
  5.         public void propertyChange(PropertyChangeEvent e) {
  6.             String prop = e.getPropertyName();
  7.             if (("focusOwner".equals(prop)) &&
  8.                   ((e.getNewValue()) instanceof Picture)) {
  9.                 Component comp = (Component)e.getNewValue();
  10.                 String name = comp.getName();
  11.                 Integer num = new Integer(name);
  12.                 int index = num.intValue();
  13.                 if (index < 0 || index > comments.length) {
  14.                     index = 0;
  15.                 }
  16.                 info.setText(comments[index]);
  17.             }
  18.         }
  19.     }
  20. );

自定义组件Picture负责绘制图像。所有六个组件都以这种方式定义：

  1. pic1 = new Picture(createImageIcon("images/" +
  2.             mayaString + ".gif", mayaString).getImage());
  3. pic1.setName("1");

焦点转移是异步的。这种质量可能导致一些奇怪的与时间相关的问题和假设，特别是在焦点的自动转移期间。例如，想象一个带有包含“开始”按钮，“取消”按钮和文本字段的窗口的应用程序。组件按此顺序添加：

  1. 开始按钮
  2. 文本域
  3. 取消按钮

启动应用程序时，LayoutFocusTraversalPolicy确定焦点遍历策略 - 在这种情况下，它是组件添加到其容器的顺序。在此示例中，所需的行为是“开始”按钮具有初始焦点，单击“开始”按钮时，它将被禁用，然后“取消”按钮将获得焦点。实现此行为的正确方法是按所需顺序将组件添加到容器或创建自定义焦点遍历策略。如果出于某种原因，这是不可能的，那么您可以使用以下代码段实现此行为：

  1. public void actionPerformed(ActionEvent e) {
  2.     //This works.
  3.     start.setEnabled(false);
  4.     cancel.requestFocusInWindow();
  5. }

根据需要，焦点从“开始”按钮转到“取消”按钮，而不是文本字段。但如果以相反的顺序调用相同的方法，则会出现不同的结果，如下所示：

  1. public void actionPerformed(ActionEvent e) {
  2.     //This does not work.
  3.     cancel.requestFocusInWindow();
  4.     start.setEnabled(false);
  5. }

在这种情况下，在离开“开始”按钮之前，请在“取消”按钮上请求焦点。对requestFocusInWindow方法的调用会启动焦点传输，但不会立即将焦点移动到“取消”按钮。当禁用“开始”按钮时，焦点将转移到下一个组件（因此始终有一个具有焦点的组件），在这种情况下，它会将焦点移动到文本字段，而不是到取消按钮。

在可能影响焦点的所有其他更改适用于以下情况之后，您需要在几种情况下进行焦点请求：

  • 隐藏焦点所有者。
  • 使焦点所有者不可聚焦。
  • 在焦点所有者上调用removeNotify方法。
  • 对焦点所有者的容器执行上述任何操作，或者更改焦点策略，以便容器不再接受该组件作为焦点所有者。
  • 处理包含焦点所有者的顶级窗口。

下表列出了与焦点相关的常用构造器和方法。焦点 API 分为四类：

有关焦点架构的更多详细信息，请参阅焦点子系统的规范。您也可以找到如何编写焦点监听器有用。

方法（在Component中） 目的
isFocusOwner（） 如果组件是焦点所有者，则返回true。
setRequestFocusEnabled（boolean）

isRequestFocusEnabled（） （JComponent中的*）_ | 设置或检查此组件是否应该获得焦点。将setRequestFocusEnabled设置为false通常可以防止鼠标单击为组件提供焦点，同时仍允许键盘导航为组件提供焦点。此方法仅适用于接收鼠标事件的组件。例如，您可以在JButton上使用此方法，但不能在JPanel上使用此方法。如果您编写自定义组件，则由您来尊重此属性。建议使用setFocusable方法，这种方法可以让您的程序更好地适用于使用辅助技术的用户。 | | setFocusable（boolean） isFocusable（） | 设置或获取组件的可聚焦状态。组件必须是可聚焦的才能获得焦点。使用setFocusable(false)从焦点循环中删除组件时，无法再使用键盘导航组件。建议使用setRequestFocusEnabled方法，以便您的程序可以由使用辅助技术的用户运行。 | | requestFocusInWindow（） | 请求此组件应获得焦点。组件的窗口必须是当前聚焦的窗口。对于此请求，JComponent的子类必须是可见的，启用的和可聚焦的，并且具有要授予此请求的输入映射。在发生FOCUS_GAINED事件之前，不应该假设组件具有焦点。该方法优于requestFocus方法，该方法是平台相关的。 | | setFocusTraversalKeys（int，Set） getFocusTraversalKeys（int） areFocusTraversalKeysSet（int） （java.awt.Container中的） | 设置或获取特定方向的焦点遍历键，或确定是否已在此容器上显式设置任何焦点遍历键。如果未设置焦点遍历键，则它们将继承自祖先或键盘焦点管理器。可以按以下方向设置焦点遍历键：KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS，KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS或KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS。如果设置UP_CYCLE_TRAVERSAL_KEYS或DOWN_CYCLE_TRAVERSAL_KEYS，则还必须在焦点遍历策略上调用 setImplicitDownCycleTraversal(false) 。 |

类或方法 目的
LayoutFocusTraversalPolicy 默认情况下，该类确定 Swing 组件的焦点遍历策略。
getComponentAfter（Container，Component） 给定作为输入传递的组件，返回下一个应该具有焦点的组件。
getComponentBefore（Container，Component） 给定作为输入传递的组件，返回应该在此组件之前具有焦点的组件。该方法用于反向标签。
getDefaultComponent（Container）

（javax.swing.SortingFocusTraversalPolicy中的）_ | 返回应具有默认焦点的组件。 | | getFirstComponent（Container） | 返回遍历循环中的第一个组件。 | | getInitialComponent（Container） | 当窗口第一次可见时，返回应该接收焦点的组件。 | | getLastComponent（Container） | 返回遍历循环中的最后一个组件。 | | setFocusTraversalPolicy（FocusTraversalPolicy） getFocusTraversalPolicy（FocusTraversalPolicy） （java.awt.Container中的） | 设置或获取焦点遍历策略或确定是否已设置策略。请注意，在不是焦点循环根的容器上设置焦点遍历策略可能没有明显的效果。值null表示尚未明确设置策略。如果未设置策略，则从父焦点循环根继承策略。 | | isFocusCycleRoot（） setFocusCycleRoot（boolean） （java.awt.Container中的*） | 检查或设置容器是否是焦点遍历循环的根。 | | isFocusTraversalPolicyProvider（） setFocusTraversalPolicyProvider（boolean） （java.awt.Container中的*）_ | 检查或设置是否将使用容器来提供焦点遍历策略。 |

类或方法 目的
InputVerifier 允许通过焦点机制进行输入验证的抽象类。当尝试将焦点从包含输入验证器的组件移位时，在验证器满足之前不会放弃焦点。
shouldYieldFocus（JComponent）

（在InputVerifier中） | 当组件具有输入验证程序时，系统会调用此方法以确定焦点是否可以离开此组件。此方法可能会导致副作用，例如打开对话框。如果此方法返回false，则焦点将保留在传递给方法的组件上。 | | 验证（JComponent） （在InputVerifier中） | 您需要覆盖此方法以检查组件的输入是否有效。如果有效则应返回true，否则返回false。此方法不应导致任何副作用，例如打开对话框。该方法由shouldYieldFocus调用。 | | setInputVerifier（inputVerifier） getInputVerifier（） （在JComponent中） | 设置或获取分配给组件的输入验证程序。默认情况下，组件没有输入验证程序。 | | setVerifyInputWhenFocusTarget（boolean） getVerifyInputWhenFocusTarget（） （在JComponent中） | 设置或获取在此组件请求焦点之前是否调用当前焦点所有者的输入验证程序。默认值为true。对于即使输入无效也应该接收焦点的组件，例如取消按钮或滚动条，此方法应设置为false。 |

该表定义了 KeyboardFocusManager 的绑定属性。可以通过调用 addPropertyChangeListener 为这些属性注册监听器。

属性 目的
focusOwner 当前接收关键事件的组件。
permanentFocusOwner 最近收到永久FOCUS_GAINED事件的组件。通常与focusOwner相同，除非临时焦点更改当前有效。
focusedWindow 包含焦点所有者的窗口。
则 activeWindow 组件必须始终为Frame或Dialog。活动窗口是聚焦窗口，或者是聚焦窗口所有者的第一帧或对话框。
默认的 FocusTraversalPolicy 默认的焦点遍历策略，可以通过Container类的setFocusTraversalPolicy方法设置。
forwardDefaultFocusTraversalKeys 用于向前遍历的一组默认焦点键。对于多行文本组件，这些键默认为 Control-Tab。对于所有其他组件，这些键默认为 Tab 和 Control-Tab。
backwardDefaultFocusTraversalKeys 用于向后遍历的一组默认焦点键。对于多行文本组件，这些键默认为 Control-Shift-Tab。对于所有其他组件，这些键默认为 Shift-Tab 和 Control-Shift-Tab。
upCycleDefaultFocusTraversalKeys 上升循环的一组默认焦点键。默认情况下，这些键对于 Swing 组件为 null。如果在KeyboardFocusManager上设置这些键，或者在焦点循环根上设置downCycleFocusTraversalKeys，则还必须在焦点遍历策略上调用 setImplicitDownCycleTraversal(false) 方法。
downCycleDefaultFocusTraversalKeys 向下循环的一组默认焦点键。默认情况下，这些键对于 Swing 组件为 null。如果在KeyboardFocusManager上设置这些键，或者在焦点循环根上设置upCycleFocusTraversalKeys，则还必须在焦点遍历策略上调用 setImplicitDownCycleTraversal(false) 方法。
currentFocusCycleRoot 作为当前焦点循环根的容器。

下表列出了操作焦点的示例：

例 在哪里描述 笔记
FocusConceptsDemo 这个部分 演示基本的默认焦点行为。
FocusTraversalDemo 这个部分 演示如何覆盖默认焦点顺序。
TrackFocusDemo 这个部分 演示如何使用PropertyChangeListener跟踪焦点所有者。还实现了自定义可聚焦组件。
InputVerificationDemo 这个部分 演示如何实现InputVerifier来验证用户输入。
InputVerificationDialogDemo 这个部分 演示如何实现在用户输入无效时放置对话框的InputVerifier。
FocusEventDemo 如何编写焦点监听器 报告在几个组件上发生的所有焦点事件，以演示触发焦点事件的情况。