KeyboardFocusManager

目录搜索

文字

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

java.awt
类 KeyboardFocusManager

java.lang.Object
  java.awt.KeyboardFocusManager

所有已实现的接口：: KeyEventDispatcher, KeyEventPostProcessor

直接已知子类：: DefaultKeyboardFocusManager

public abstract class KeyboardFocusManager
extends Object
implements KeyEventDispatcher, KeyEventPostProcessor

KeyboardFocusManager 负责管理激活状态的聚焦 Window 和当前焦点所有者。焦点所有者的定义是：应用程序中的 Component，通常接收用户生成的所有 KeyEvent。聚焦 Window 指本身就是（或者包含）焦点所有者的 Window。只有 Frame 或 Dialog 才能成为活动 Window。本机的窗口操作系统可能使用特殊装饰（如高亮显示标题栏）来表示活动 Window 或其子窗口。活动 Window 要么是聚焦 Window，要么是作为聚焦 Window 所有者的第一个 Frame 或 Dialog。

KeyboardFocusManager 既是一个用于查询焦点所有者并启动焦点更改的客户端代码的集中位置，同时又是一个用于所有 FocusEvent、与焦点相关的 WindowEvent 和 KeyEvent 的调度程序。

有些浏览器将使用不同代码基数的 applet 划分为单独的上下文，并在这些上下文之间建墙分隔。在此方案中，每个上下文都将具有一个 KeyboardFocusManager。其他浏览器将所有 applet 置于同一个上下文中，这意味着仅存在一个用于所有 applet 的全局 KeyboardFocusManager。此行为是依赖于实现的。请参考浏览器文档以获取更多信息。然而，不管可能有多少上下文，每个 ClassLoader 的焦点所有者、聚焦 Window 或活动 Window 只能有一个。

请参见 How to Use the Focus Subsystem（The Java Tutorial 的一节）和 Focus Specification 以获取更多信息。

从以下版本开始：: 1.4
另请参见：: Window, Frame, Dialog, FocusEvent, WindowEvent, KeyEvent

字段摘要
`static int`	`BACKWARD_TRAVERSAL_KEYS` Backward 焦点遍历键的标识符。
`static int`	`DOWN_CYCLE_TRAVERSAL_KEYS` Down Cycle 焦点遍历键的标识符。
`static int`	`FORWARD_TRAVERSAL_KEYS` Forward 焦点遍历键的标识符。
`static int`	`UP_CYCLE_TRAVERSAL_KEYS` Up Cycle 焦点遍历键的标识符。

构造方法摘要
`KeyboardFocusManager()` 初始化 KeyboardFocusManager。

方法摘要
`void`	`addKeyEventDispatcher(KeyEventDispatcher dispatcher)` 将 KeyEventDispatcher 添加到此 KeyboardFocusManager 的调度程序链中。
`void`	`addKeyEventPostProcessor(KeyEventPostProcessor processor)` 将 KeyEventPostProcessor 添加到此 KeyboardFocusManager 的后处理器链中。
`void`	`addPropertyChangeListener(PropertyChangeListener listener)` 将 PropertyChangeListener 添加到侦听器列表。
`void`	`addPropertyChangeListener(String propertyName, PropertyChangeListener listener)` 将 PropertyChangeListener 添加到特定属性的侦听器列表。
`void`	`addVetoableChangeListener(String propertyName, VetoableChangeListener listener)` 将 VetoableChangeListener 添加到特定属性的侦听器列表。
`void`	`addVetoableChangeListener(VetoableChangeListener listener)` 将 VetoableChangeListener 添加到侦听器列表。
`void`	`clearGlobalFocusOwner()` 在 Java 和本机级别清除全局焦点所有者。
`protected abstract void`	`dequeueKeyEvents(long after, Component untilFocused)` 由 AWT 调用以通知 KeyboardFocusManager 应该取消延迟指派 KeyEvent。
`protected abstract void`	`discardKeyEvents(Component comp)` 由 AWT 调用以通知 KeyboardFocusManager 应该取消延迟指派 KeyEvent。
`abstract boolean`	`dispatchEvent(AWTEvent e)` AWT 事件调度程序可以调用此方法，请求当前的 KeyboardFocusManager 为其指派指定的事件。
`abstract boolean`	`dispatchKeyEvent(KeyEvent e)` 通常情况下，如果该指派程序链中的其他 KeyEventDispatcher 没有指派 KeyEvent 或者没有注册其他 KeyEventDispatcher，则 `dispatchEvent` 将调用此方法。
`void`	`downFocusCycle()` 当且仅当当前焦点所有者是一个作为焦点循环根的 Container 时，从当前焦点所有者将焦点下移一个焦点遍历循环。
`abstract void`	`downFocusCycle(Container aContainer)` 将焦点下移一个焦点遍历循环。
`protected abstract void`	`enqueueKeyEvents(long after, Component untilFocused)` 在指定的 Component 成为焦点所有者以前由 AWT 调用，以通知 KeyboardFocusManager 延迟指派 KeyEvent。
`protected void`	`firePropertyChange(String propertyName, Object oldValue, Object newValue)` 激发 PropertyChangeEvent 以响应绑定属性中的更改。
`protected void`	`fireVetoableChange(String propertyName, Object oldValue, Object newValue)` 激发 PropertyChangeEvent 以响应可否决属性中的更改。
`void`	`focusNextComponent()` 聚焦当前焦点所有者之后的 Component。
`abstract void`	`focusNextComponent(Component aComponent)` 聚焦 aComponent 之后的 Component，通常基于 FocusTraversalPolicy。
`void`	`focusPreviousComponent()` 聚焦当前焦点所有者之前的 Component。
`abstract void`	`focusPreviousComponent(Component aComponent)` 聚焦 aComponent 之前的 Component，通常基于 FocusTraversalPolicy。
`Window`	`getActiveWindow()` 如果活动 Window 与调用线程位于同一个上下文中，则返回活动 Window。
`Container`	`getCurrentFocusCycleRoot()` 如果当前焦点循环根与调用线程位于相同的上下文中，则返回当前焦点循环根。
`static KeyboardFocusManager`	`getCurrentKeyboardFocusManager()` 返回调用线程上下文的当前 KeyboardFocusManager 实例。
`Set<AWTKeyStroke>`	`getDefaultFocusTraversalKeys(int id)` 返回给定遍历操作的默认焦点遍历键的 Set。
`FocusTraversalPolicy`	`getDefaultFocusTraversalPolicy()` 返回默认 FocusTraversalPolicy。
`Window`	`getFocusedWindow()` 如果聚焦窗口与调用线程位于同一个上下文中，则返回聚焦窗口。
`Component`	`getFocusOwner()` 如果焦点所有者与调用线程位于同一个上下文中，则返回该焦点所有者。
`protected Window`	`getGlobalActiveWindow()` 返回活动 Window，即使调用线程处于活动 Window 之外的上下文中。
`protected Container`	`getGlobalCurrentFocusCycleRoot()` 返回当前焦点循环根，即使调用线程处于当前焦点循环根之外的上下文中。
`protected Window`	`getGlobalFocusedWindow()` 返回聚焦 Window，即使调用线程处于聚焦 Window 之外的上下文中。
`protected Component`	`getGlobalFocusOwner()` 返回焦点所有者，即使调用线程处于焦点所有者之外的上下文中。
`protected Component`	`getGlobalPermanentFocusOwner()` 返回持久焦点所有者，即使调用线程处于该持久焦点所有者之外的上下文中。
`protected List<KeyEventDispatcher>`	`getKeyEventDispatchers()` 作为 List 返回此 KeyboardFocusManager 的 KeyEventDispatcher 链。
`protected List<KeyEventPostProcessor>`	`getKeyEventPostProcessors()` 作为 List 返回此 KeyboardFocusManager 的 KeyEventPostProcessor 链。
`Component`	`getPermanentFocusOwner()` 如果持久焦点所有者与调用线程位于同一个上下文中，则返回持久焦点所有者。
`PropertyChangeListener[]`	`getPropertyChangeListeners()` 返回在此键盘焦点管理器上注册的所有属性更改侦听器组成的数组。
`PropertyChangeListener[]`	`getPropertyChangeListeners(String propertyName)` 返回与指定属性相关联的所有 `PropertyChangeListener` 组成的数组。
`VetoableChangeListener[]`	`getVetoableChangeListeners()` 返回在此键盘焦点管理器上注册的所有可否决更改侦听器组成的数组。
`VetoableChangeListener[]`	`getVetoableChangeListeners(String propertyName)` 返回与指定属性相关联的所有 `VetoableChangeListener` 组成的数组。
`abstract boolean`	`postProcessKeyEvent(KeyEvent e)` `dispatchKeyEvent` 将调用此方法。
`abstract void`	`processKeyEvent(Component focusedComponent, KeyEvent e)` 当且仅当该 KeyEvent 表示指定 focusedComponent 的焦点遍历键时，此方法启动焦点遍历操作。
`void`	`redispatchEvent(Component target, AWTEvent e)` 重新指派 AWTEvent 的方式是，AWT 事件调度程序不会递归式请求 KeyboardFocusManager 或任何已安装的 KeyEventDispatcher 再次指派该事件。
`void`	`removeKeyEventDispatcher(KeyEventDispatcher dispatcher)` 移除以前添加到此 KeyboardFocusManager 调度程序链中的 KeyEventDispatcher。
`void`	`removeKeyEventPostProcessor(KeyEventPostProcessor processor)` 从此 KeyboardFocusManager 的后处理器链中移除以前添加的 KeyEventPostProcessor。
`void`	`removePropertyChangeListener(PropertyChangeListener listener)` 从侦听器列表移除 PropertyChangeListener。
`void`	`removePropertyChangeListener(String propertyName, PropertyChangeListener listener)` 从特定属性的侦听器列表移除 PropertyChangeListener。
`void`	`removeVetoableChangeListener(String propertyName, VetoableChangeListener listener)` 从特定属性的侦听器列表移除 VetoableChangeListener。
`void`	`removeVetoableChangeListener(VetoableChangeListener listener)` 从侦听器列表移除 VetoableChangeListener。
`static void`	`setCurrentKeyboardFocusManager(KeyboardFocusManager newManager)` 设置调用线程上下文的当前 KeyboardFocusManager 实例。
`void`	`setDefaultFocusTraversalKeys(int id, Set<? extends AWTKeyStroke> keystrokes)` 设置给定遍历操作的默认焦点遍历键。
`void`	`setDefaultFocusTraversalPolicy(FocusTraversalPolicy defaultPolicy)` 设置默认 FocusTraversalPolicy。
`protected void`	`setGlobalActiveWindow(Window activeWindow)` 设置活动 Window。
`void`	`setGlobalCurrentFocusCycleRoot(Container newFocusCycleRoot)` 设置当前焦点循环根。
`protected void`	`setGlobalFocusedWindow(Window focusedWindow)` 设置聚焦 Window。
`protected void`	`setGlobalFocusOwner(Component focusOwner)` 设置焦点所有者。
`protected void`	`setGlobalPermanentFocusOwner(Component permanentFocusOwner)` 设置持久焦点所有者。
`void`	`upFocusCycle()` 从当前焦点所有者将焦点上移一个焦点遍历循环。
`abstract void`	`upFocusCycle(Component aComponent)` 将焦点上移一个焦点遍历循环。

从类 java.lang.Object 继承的方法
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

字段详细信息

FORWARD_TRAVERSAL_KEYS

public static final int FORWARD_TRAVERSAL_KEYS

Forward 焦点遍历键的标识符。

另请参见：: setDefaultFocusTraversalKeys(int, java.util.Set extends java.awt.AWTKeyStroke>), getDefaultFocusTraversalKeys(int), Component.setFocusTraversalKeys(int, java.util.Set extends java.awt.AWTKeyStroke>), Component.getFocusTraversalKeys(int), 常量字段值

BACKWARD_TRAVERSAL_KEYS

public static final int BACKWARD_TRAVERSAL_KEYS

Backward 焦点遍历键的标识符。

另请参见：: setDefaultFocusTraversalKeys(int, java.util.Set extends java.awt.AWTKeyStroke>), getDefaultFocusTraversalKeys(int), Component.setFocusTraversalKeys(int, java.util.Set extends java.awt.AWTKeyStroke>), Component.getFocusTraversalKeys(int), 常量字段值

UP_CYCLE_TRAVERSAL_KEYS

public static final int UP_CYCLE_TRAVERSAL_KEYS

Up Cycle 焦点遍历键的标识符。

另请参见：: setDefaultFocusTraversalKeys(int, java.util.Set extends java.awt.AWTKeyStroke>), getDefaultFocusTraversalKeys(int), Component.setFocusTraversalKeys(int, java.util.Set extends java.awt.AWTKeyStroke>), Component.getFocusTraversalKeys(int), 常量字段值

DOWN_CYCLE_TRAVERSAL_KEYS

public static final int DOWN_CYCLE_TRAVERSAL_KEYS

Down Cycle 焦点遍历键的标识符。

另请参见：: setDefaultFocusTraversalKeys(int, java.util.Set extends java.awt.AWTKeyStroke>), getDefaultFocusTraversalKeys(int), Component.setFocusTraversalKeys(int, java.util.Set extends java.awt.AWTKeyStroke>), Component.getFocusTraversalKeys(int), 常量字段值

构造方法详细信息

public KeyboardFocusManager()

初始化 KeyboardFocusManager。

方法详细信息

getCurrentKeyboardFocusManager

public static KeyboardFocusManager getCurrentKeyboardFocusManager()

返回调用线程上下文的当前 KeyboardFocusManager 实例。

返回：: 此线程上下文的 KeyboardFocusManager
另请参见：: setCurrentKeyboardFocusManager(java.awt.KeyboardFocusManager)

setCurrentKeyboardFocusManager

public static void setCurrentKeyboardFocusManager(KeyboardFocusManager newManager)
                                           throws SecurityException

设置调用线程上下文的当前 KeyboardFocusManager 实例。如果指定了 null，则使用 DefaultKeyboardFocusManager 的新实例替换当前 KeyboardFocusManager。

如果安装了 SecurityManager，则必须授予调用线程 AWTPermission "replaceKeyboardFocusManager" 才能替换当前 KeyboardFocusManager。如果未授予该权限，则此方法将抛出 SecurityException，而当前的 KeyboardFocusManager 不会改变。

参数：: newManager - 此线程上下文的新 KeyboardFocusManager
抛出：: SecurityException - 如果调用线程不具有替换当前 KeyboardFocusManager 的权限
另请参见：: getCurrentKeyboardFocusManager(), DefaultKeyboardFocusManager

getFocusOwner

public Component getFocusOwner()

如果焦点所有者与调用线程位于同一个上下文中，则返回该焦点所有者。焦点所有者的定义是：应用程序中的 Component，通常用户生成的所有 KeyEvent 都被接收。如果为焦点所有者启用了焦点遍历键，则不会传递映射到焦点所有者的焦点遍历键的 KeyEvent。此外，KeyEventDispatcher 在到达焦点所有者之前可能重定向或使用 KeyEvent。

返回：: 焦点所有者；如果焦点所有者调用的不是线程上下文的成员，则返回 null
另请参见：: getGlobalFocusOwner(), setGlobalFocusOwner(java.awt.Component)

getGlobalFocusOwner

protected Component getGlobalFocusOwner()
                                 throws SecurityException

返回焦点所有者，即使调用线程处于焦点所有者之外的上下文中。焦点所有者的定义是：应用程序中的 Component，通常接收用户生成的所有 KeyEvent。如果为焦点所有者启用了焦点遍历键，则不会传递映射到焦点所有者的焦点遍历键的 KeyEvent。此外，KeyEventDispatcher 在到达焦点所有者之前可能重定向或使用 KeyEvent。

如果此 KeyboardFocusManager 调用的不是线程上下文的当前 KeyboardFocusManager，则此方法将抛出 SecurityException。

返回：: 焦点所有者
抛出：: SecurityException - 如果此 KeyboardFocusManager 调用的不是线程上下文的当前 KeyboardFocusManager
另请参见：: getFocusOwner(), setGlobalFocusOwner(java.awt.Component)

setGlobalFocusOwner

protected void setGlobalFocusOwner(Component focusOwner)

设置焦点所有者。如果该 Component 不可以作为焦点，则取消操作。焦点所有者的定义是：应用程序中的 Component，通常接收用户生成的所有 KeyEvent。如果为焦点所有者启用了焦点遍历键，则不会传递映射到焦点所有者的焦点遍历键的 KeyEvent。此外，KeyEventDispatcher 在到达焦点所有者之前可能重定向或使用 KeyEvent。

此方法实际上没有将焦点设置为指定的 Component。它只存储该值，以便以后由 getFocusOwner() 返回它。更改焦点所有者需要使用 Component.requestFocus() 或 Component.requestFocusInWindow()，具体的使用因平台而异。

参数：: focusOwner - 焦点所有者
另请参见：: getFocusOwner(), getGlobalFocusOwner(), Component.requestFocus(), Component.requestFocusInWindow(), Component.isFocusable()

clearGlobalFocusOwner

public void clearGlobalFocusOwner()

在 Java 和本机级别清除全局焦点所有者。如果存在焦点所有者，则该 Component 将接收持久 FOCUS_LOST 事件。完成此操作后，在用户选择接收焦点的新 Component 或通过调用 requestFocus() 为 Component 显式分配焦点之前，本机窗口操作系统将放弃所有用户生成的 KeyEvent。此操作不改变聚焦或激活状态的 Window。

另请参见：: Component.requestFocus(), FocusEvent.FOCUS_LOST

getPermanentFocusOwner

public Component getPermanentFocusOwner()

如果持久焦点所有者与调用线程位于同一个上下文中，则返回持久焦点所有者。持久焦点所有者的定义是：应用程序中的最后一个 Component，它可以接收持久 FOCUS_GAINED 事件。如果不发生临时焦点更改，则焦点所有者和持久焦点所有者是等效的。在发生临时焦点更改的情形下，临时焦点更改结束后，持久焦点所有者又会变成焦点所有者。

返回：: 持久焦点所有者；如果持久焦点所有者调用的不是线程上下文的成员，则返回 null
另请参见：: getGlobalPermanentFocusOwner(), setGlobalPermanentFocusOwner(java.awt.Component)

getGlobalPermanentFocusOwner

protected Component getGlobalPermanentFocusOwner()
                                          throws SecurityException

返回持久焦点所有者，即使调用线程处于该持久焦点所有者之外的上下文中。持久焦点所有者的定义是：应用程序中的最后一个 Component，它可以接收持久 FOCUS_GAINED 事件。如果不发生临时焦点更改，则焦点所有者和持久焦点所有者是等效的。在发生临时焦点更改的情形下，临时焦点更改结束后，持久焦点所有者又会变成焦点所有者。

如果此 KeyboardFocusManager 调用的不是线程上下文的当前 KeyboardFocusManager，则此方法将抛出 SecurityException。

返回：: 持久焦点所有者
抛出：: SecurityException - 如果此 KeyboardFocusManager 调用的不是线程上下文的当前 KeyboardFocusManager
另请参见：: getPermanentFocusOwner(), setGlobalPermanentFocusOwner(java.awt.Component)

setGlobalPermanentFocusOwner

protected void setGlobalPermanentFocusOwner(Component permanentFocusOwner)

设置持久焦点所有者。如果该 Component 不可以作为焦点，则取消该操作。持久焦点所有者的定义是：应用程序中的最后一个 Component，它可以接收持久 FOCUS_GAINED 事件。如果不发生临时焦点更改，则焦点所有者和持久焦点所有者是等效的。在发生临时焦点更改的情形下，临时焦点更改结束后，持久焦点所有者又会变成焦点所有者。

此方法实际上没有将焦点设置为指定的 Component。它只存储该值，以便以后由 getPermanentFocusOwner() 返回它。更改焦点所有者需要使用 Component.requestFocus() 或 Component.requestFocusInWindow()，因平台而异。

参数：: permanentFocusOwner - 持久焦点所有者
另请参见：: getPermanentFocusOwner(), getGlobalPermanentFocusOwner(), Component.requestFocus(), Component.requestFocusInWindow(), Component.isFocusable()

getFocusedWindow

public Window getFocusedWindow()

如果聚焦窗口与调用线程位于同一个上下文中，则返回聚焦窗口。聚焦 Window 指本身就是（或者包含）焦点所有者的 Window。

返回：: 聚焦 Window；如果聚焦 Window 调用的不是线程上下文的成员，则返回 null
另请参见：: getGlobalFocusedWindow(), setGlobalFocusedWindow(java.awt.Window)

getGlobalFocusedWindow

protected Window getGlobalFocusedWindow()
                                 throws SecurityException

返回聚焦 Window，即使调用线程处于聚焦 Window 之外的上下文中。聚焦 Window 指本身就是（或者包含）焦点所有者的 Window。

如果此 KeyboardFocusManager 调用的不是线程上下文的当前 KeyboardFocusManager，则此方法将抛出 SecurityException。

返回：: 聚焦 Window
抛出：: SecurityException - 如果此 KeyboardFocusManager 调用的不是线程上下文的当前 KeyboardFocusManager
另请参见：: getFocusedWindow(), setGlobalFocusedWindow(java.awt.Window)

setGlobalFocusedWindow

protected void setGlobalFocusedWindow(Window focusedWindow)

设置聚焦 Window。聚焦 Window 指本身就是（或者包含）焦点所有者的 Window。如果要聚焦的指定 Window 不是可以作为焦点的 Window，则取消该操作。

此方法不能实际更改与本机窗口操作系统相关的聚焦 Window。它只存储该值，以便以后由 getFocusedWindow() 返回它。更改聚焦 Window 需要使用 Component.requestFocus() 或 Component.requestFocusInWindow()，因平台而异。

参数：: focusedWindow - 聚焦 Window
另请参见：: getFocusedWindow(), getGlobalFocusedWindow(), Component.requestFocus(), Component.requestFocusInWindow(), Window.isFocusableWindow()

getActiveWindow

public Window getActiveWindow()

如果活动 Window 与调用线程位于同一个上下文中，则返回活动 Window。只有 Frame 或 Dialog 才能成为活动 Window。本机的窗口操作系统可能使用特殊装饰（如高亮显示标题栏）来表示活动 Window 或其子窗口。活动 Window 要么是聚焦 Window，要么是作为聚焦 Window 所有者的第一个 Frame 或 Dialog。

返回：: 活动 Window；如果活动 Window 调用的不是线程上下文的成员，则返回 null
另请参见：: getGlobalActiveWindow(), setGlobalActiveWindow(java.awt.Window)

getGlobalActiveWindow

protected Window getGlobalActiveWindow()
                                throws SecurityException

返回活动 Window，即使调用线程处于活动 Window 之外的上下文中。只有 Frame 或 Dialog 才能成为活动 Window。本机的窗口操作系统可能使用特殊装饰（如高亮显示标题栏）来表示活动 Window。活动 Window 要么是聚焦 Window，要么是作为聚焦 Window 所有者的第一个 Frame 或 Dialog。

如果此 KeyboardFocusManager 调用的不是线程上下文的当前 KeyboardFocusManager，则此方法将抛出 SecurityException。

返回：: 活动 Window
抛出：: SecurityException - 如果此 KeyboardFocusManager 调用的不是线程上下文的当前 KeyboardFocusManager
另请参见：: getActiveWindow(), setGlobalActiveWindow(java.awt.Window)

setGlobalActiveWindow

protected void setGlobalActiveWindow(Window activeWindow)

设置活动 Window。只有 Frame 或 Dialog 才能成为活动 Window。本机的窗口操作系统可能使用特殊装饰（如高亮显示标题栏）来表示活动 Window 或其子窗口。活动 Window 要么是聚焦 Window，要么是作为聚焦 Window 所有者的第一个 Frame 或 Dialog。

此方法不能实际更改与本机窗口操作系统相关的活动 Window。它只存储该值，以便以后由 getActiveWindow() 返回它。更改活动 Window 需要使用 Component.requestFocus() 或 Component.requestFocusInWindow()，因平台而异。

参数：: activeWindow - 活动 Window
另请参见：: getActiveWindow(), getGlobalActiveWindow(), Component.requestFocus(), Component.requestFocusInWindow()

getDefaultFocusTraversalPolicy

public FocusTraversalPolicy getDefaultFocusTraversalPolicy()

返回默认 FocusTraversalPolicy。通过显式调用 Container.setFocusTraversalPolicy 初始化自己的焦点遍历策略时，顶层组件会使用该值。

返回：: 默认 FocusTraversalPolicy。永远不会返回 null。
另请参见：: setDefaultFocusTraversalPolicy(java.awt.FocusTraversalPolicy), Container.setFocusTraversalPolicy(java.awt.FocusTraversalPolicy), Container.getFocusTraversalPolicy()

setDefaultFocusTraversalPolicy

public void setDefaultFocusTraversalPolicy(FocusTraversalPolicy defaultPolicy)

设置默认 FocusTraversalPolicy。通过显式调用 Container.setFocusTraversalPolicy 初始化自己的焦点遍历策略时，顶层组件会使用此值。注：此调用不影响已经创建的组件，因为它们的策略已经初始化了。只有新组件才会将此策略用作默认策略。

参数：: defaultPolicy - 新的默认 FocusTraversalPolicy
抛出：: IllegalArgumentException - 如果 defaultPolicy 为 null
另请参见：: getDefaultFocusTraversalPolicy(), Container.setFocusTraversalPolicy(java.awt.FocusTraversalPolicy), Container.getFocusTraversalPolicy()

setDefaultFocusTraversalKeys

public void setDefaultFocusTraversalKeys(int id,
                                         Set<? extends AWTKeyStroke> keystrokes)

设置给定遍历操作的默认焦点遍历键。此遍历键 Set 对没有显式定义自己的这种 Set 的所有 Window 均有效。对于没有显式定义自己的这种 Set 的 Windows 而言，此 Set 还可以由其子 Component 递归式继承。

默认焦点遍历键的默认值是依赖于实现的。Sun 建议特定本机平台的所有实现都使用相同的默认值。下面列出了对 Windows 和 Unix 的建议。这些建议用于 Sun AWT 实现中。

标识符	意义	默认值
`KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS`	正常向前键盘遍历	`TAB` on `KEY_PRESSED`, `CTRL-TAB` on `KEY_PRESSED`
`KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS`	正常反向键盘遍历	`SHIFT-TAB` on `KEY_PRESSED`, `CTRL-SHIFT-TAB` on `KEY_PRESSED`
`KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS`	向上一个焦点遍历循环	none
`KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS`	向下一个焦点遍历循环	none

要禁用遍历键，需要使用空 Set；建议使用 Collections.EMPTY_SET。

使用 AWTKeyStroke API，客户端代码可以指定在两个特定 KeyEvent 的哪一个上进行焦点遍历，KEY_PRESSED 还是 KEY_RELEASED。不管指定哪一个 KeyEvent，所有与焦点遍历键相关的 KeyEvent（包括关联的 KEY_TYPED 事件）都将被使用，不会将其指派给任何 Component。将 KEY_TYPED 事件指定为映射为焦点遍历操作或将同一事件映射为多个默认焦点遍历操作都是运行时错误。

参数：: id - KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS、KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS、KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS 和 KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS 其中之一; keystrokes - 指定操作的 AWTKeyStroke Set

抛出：

IllegalArgumentException - 如果 id 不是 KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS、KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS、KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS 和 KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS 其中之一，或者击键为 null，或者击键包含 null，或者击键中的任何 Object 不是 AWTKeyStroke，或者击键表示 KEY_TYPED 事件，或者击键已映射为别的默认焦点遍历操作

另请参见：

getDefaultFocusTraversalKeys(int), Component.setFocusTraversalKeys(int, java.util.Set extends java.awt.AWTKeyStroke>), Component.getFocusTraversalKeys(int)

getDefaultFocusTraversalKeys

public Set<AWTKeyStroke> getDefaultFocusTraversalKeys(int id)

返回给定遍历操作的默认焦点遍历键的 Set。此遍历键 Set 对没有显式定义自己的这种 Set 的所有 Window 均有效。对于没有显式定义自己的这种 Set 的 Window 而言，此 Set 还可以由其子 Component 递归式继承。（请参见 setDefaultFocusTraversalKeys 以获取每个操作的完整描述。）

参数：: id - KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS、KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS、KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS 和 KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS 其中之一
返回：: 指定操作的 AWTKeyStroke Set；该 Set 不可修改，并且可以为空；永远不会返回 null
抛出：: IllegalArgumentException - 如果 id 不是 KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS、KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS、KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS 和 KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS 其中之一
另请参见：: setDefaultFocusTraversalKeys(int, java.util.Set extends java.awt.AWTKeyStroke>), Component.setFocusTraversalKeys(int, java.util.Set extends java.awt.AWTKeyStroke>), Component.getFocusTraversalKeys(int)

getCurrentFocusCycleRoot

public Container getCurrentFocusCycleRoot()

如果当前焦点循环根与调用线程位于相同的上下文中，则返回当前焦点循环根。如果焦点所有者本身是一个焦点循环根，则在正常焦点遍历期间，哪些 Component 表示焦点的上一个和下一个 Component 可能不明确。在这种情况下，需要使用当前焦点循环根来区分各种可能性。

此方法仅供 KeyboardFocusManager 和焦点实现使用。一般客户端不能使用。

返回：: 当前焦点循环根；如果当前焦点循环根调用的不是线程上下文的成员，则返回 null
另请参见：: getGlobalCurrentFocusCycleRoot(), setGlobalCurrentFocusCycleRoot(java.awt.Container)

getGlobalCurrentFocusCycleRoot

protected Container getGlobalCurrentFocusCycleRoot()
                                            throws SecurityException

返回当前焦点循环根，即使调用线程处于当前焦点循环根之外的上下文中。如果焦点所有者本身是一个焦点循环根，则在正常焦点遍历期间，哪些 Component 表示焦点的上一个和下一个 Component 可能不明确。在这种情况下，需要使用当前焦点循环根来区分各种可能性。

如果此 KeyboardFocusManager 调用的不是线程上下文的当前 KeyboardFocusManager，则此方法将抛出 SecurityException。

返回：: 当前焦点循环根；如果当前焦点循环根调用的不是线程上下文的成员，则返回 null
抛出：: SecurityException - 如果此 KeyboardFocusManager 调用的不是线程上下文的当前 KeyboardFocusManager
另请参见：: getCurrentFocusCycleRoot(), setGlobalCurrentFocusCycleRoot(java.awt.Container)

setGlobalCurrentFocusCycleRoot

public void setGlobalCurrentFocusCycleRoot(Container newFocusCycleRoot)

设置当前焦点循环根。如果焦点所有者本身是一个焦点循环根，则在正常焦点遍历期间，哪些 Component 表示焦点的上一个和下一个 Component 可能不明确。在这种情况下，需要使用当前焦点循环根来区分各种可能性。

此方法仅供 KeyboardFocusManager 和焦点实现使用。一般客户端不能使用。

参数：: newFocusCycleRoot - 新焦点循环根
另请参见：: getCurrentFocusCycleRoot(), getGlobalCurrentFocusCycleRoot()

addPropertyChangeListener

public void addPropertyChangeListener(PropertyChangeListener listener)

将 PropertyChangeListener 添加到侦听器列表。为此类的所有绑定属性注册侦听器，这些属性包括：

KeyboardFocusManager 目前是否管理此应用程序或 applet 浏览器上下文的焦点 ("managingFocus")
焦点所有者 ("focusOwner")
持久焦点所有者 ("permanentFocusOwner")
聚焦 Window ("focusedWindow")
活动 Window ("activeWindow")
默认焦点遍历策略 ("defaultFocusTraversalPolicy")
默认 FORWARD_TRAVERSAL_KEYS 的 Set ("forwardDefaultFocusTraversalKeys")
默认 BACKWARD_TRAVERSAL_KEYS 的 Set ("backwardDefaultFocusTraversalKeys")
默认 UP_CYCLE_TRAVERSAL_KEYS 的 Set ("upCycleDefaultFocusTraversalKeys")
默认 DOWN_CYCLE_TRAVERSAL_KEYS 的 Set ("downCycleDefaultFocusTraversalKeys")
当前焦点循环根 ("currentFocusCycleRoot")

如果侦听器为 null，则不抛出异常，也不执行任何动作。

参数：: listener - 要添加的 PropertyChangeListener
另请参见：: removePropertyChangeListener(java.beans.PropertyChangeListener), getPropertyChangeListeners(), addPropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)

removePropertyChangeListener

public void removePropertyChangeListener(PropertyChangeListener listener)

从侦听器列表移除 PropertyChangeListener。可以使用此方法移除曾为此类的所有绑定属性注册的 PropertyChangeListener。

如果侦听器为 null，则不抛出异常，也不执行任何动作。

参数：: listener - 要移除的 PropertyChangeListener
另请参见：: addPropertyChangeListener(java.beans.PropertyChangeListener), getPropertyChangeListeners(), removePropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)

getPropertyChangeListeners

public PropertyChangeListener[] getPropertyChangeListeners()

返回在此键盘焦点管理器上注册的所有属性更改侦听器组成的数组。

返回：: 返回此键盘焦点管理器的所有 PropertyChangeListener；如果目前没有注册任何属性更改侦听器，则返回空数组
从以下版本开始：: 1.4
另请参见：: addPropertyChangeListener(java.beans.PropertyChangeListener), removePropertyChangeListener(java.beans.PropertyChangeListener), getPropertyChangeListeners(java.lang.String)

addPropertyChangeListener

public void addPropertyChangeListener(String propertyName,
                                      PropertyChangeListener listener)

将 PropertyChangeListener 添加到特定属性的侦听器列表。指定属性可能是用户定义的，也可能是以下属性之一：

KeyboardFocusManager 目前是否管理此应用程序或 applet 浏览器上下文的焦点 ("managingFocus")
焦点所有者 ("focusOwner")
持久焦点所有者 ("permanentFocusOwner")
聚焦 Window ("focusedWindow")
活动 Window ("activeWindow")
默认焦点遍历策略 ("defaultFocusTraversalPolicy")
默认 FORWARD_TRAVERSAL_KEYS 的 Set ("forwardDefaultFocusTraversalKeys")
默认 BACKWARD_TRAVERSAL_KEYS 的 Set ("backwardDefaultFocusTraversalKeys")
默认 UP_CYCLE_TRAVERSAL_KEYS 的 Set ("upCycleDefaultFocusTraversalKeys")
默认 DOWN_CYCLE_TRAVERSAL_KEYS 的 Set ("downCycleDefaultFocusTraversalKeys")
当前焦点循环根 ("currentFocusCycleRoot")

如果侦听器为 null，则不抛出异常，也不执行任何动作。

参数：: propertyName - 上面列出的属性名之一; listener - 要添加的 PropertyChangeListener

另请参见：

addPropertyChangeListener(java.beans.PropertyChangeListener), removePropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener), getPropertyChangeListeners(java.lang.String)

removePropertyChangeListener

public void removePropertyChangeListener(String propertyName,
                                         PropertyChangeListener listener)

从特定属性的侦听器列表移除 PropertyChangeListener。可以使用此方法移除为特定绑定属性注册的 PropertyChangeListener。

如果侦听器为 null，则不抛出异常，也不执行任何动作。

参数：: propertyName - 有效属性名; listener - 要移除的 PropertyChangeListener

另请参见：

addPropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener), getPropertyChangeListeners(java.lang.String), removePropertyChangeListener(java.beans.PropertyChangeListener)

getPropertyChangeListeners

public PropertyChangeListener[] getPropertyChangeListeners(String propertyName)

返回与指定属性相关联的所有 PropertyChangeListener 组成的数组。

返回：: 与指定属性相关联的所有 PropertyChangeListener；如果没有添加过这样的侦听器，则返回空数组。
从以下版本开始：: 1.4
另请参见：: addPropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener), removePropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)

firePropertyChange

protected void firePropertyChange(String propertyName,
                                  Object oldValue,
                                  Object newValue)

激发 PropertyChangeEvent 以响应绑定属性中的更改。该事件将被传递到所有已注册的 PropertyChangeListener 中。如果 oldValue 和 newValue 相同，则不会传递事件。

参数：: propertyName - 已更改的属性名; oldValue - 属性的上一个值; newValue - 属性的新值

addVetoableChangeListener

public void addVetoableChangeListener(VetoableChangeListener listener)

将 VetoableChangeListener 添加到侦听器列表。为此类的所有可否决属性注册侦听器，这些属性包括：

焦点所有者 ("focusOwner")
持久焦点所有者 ("permanentFocusOwner")
聚焦 Window ("focusedWindow")
活动 Window ("activeWindow")

如果侦听器为 null，则不抛出异常，也不执行任何动作。

参数：: listener - 要添加的 VetoableChangeListener
另请参见：: removeVetoableChangeListener(java.beans.VetoableChangeListener), getVetoableChangeListeners(), addVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener)

removeVetoableChangeListener

public void removeVetoableChangeListener(VetoableChangeListener listener)

从侦听器列表移除 VetoableChangeListener。使用此方法可以移除曾为此类的所有可否决属性注册的 VetoableChangeListener。

如果侦听器为 null，则不抛出异常，也不执行任何动作。

参数：: listener - 要移除的 VetoableChangeListener
另请参见：: addVetoableChangeListener(java.beans.VetoableChangeListener), getVetoableChangeListeners(), removeVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener)

getVetoableChangeListeners

public VetoableChangeListener[] getVetoableChangeListeners()

返回在此键盘焦点管理器上注册的所有可否决更改侦听器组成的数组。

返回：: 此键盘焦点管理器的所有 VetoableChangeListener；如果目前没有注册任何可否决更改侦听器，则返回空数组
从以下版本开始：: 1.4
另请参见：: addVetoableChangeListener(java.beans.VetoableChangeListener), removeVetoableChangeListener(java.beans.VetoableChangeListener), getVetoableChangeListeners(java.lang.String)

addVetoableChangeListener

public void addVetoableChangeListener(String propertyName,
                                      VetoableChangeListener listener)

将 VetoableChangeListener 添加到特定属性的侦听器列表。指定属性可能是用户定义的，也可能是以下属性之一：

焦点所有者 ("focusOwner")
持久焦点所有者 ("permanentFocusOwner")
聚焦 Window ("focusedWindow")
活动 Window ("activeWindow")

如果侦听器为 null，则不抛出异常，也不执行任何动作。

参数：: propertyName - 上面列出的属性名之一; listener - 要添加的 VetoableChangeListener

另请参见：

addVetoableChangeListener(java.beans.VetoableChangeListener), removeVetoableChangeListener(java.beans.VetoableChangeListener), getVetoableChangeListeners()

removeVetoableChangeListener

public void removeVetoableChangeListener(String propertyName,
                                         VetoableChangeListener listener)

从特定属性的侦听器列表移除 VetoableChangeListener。可以使用此方法移除为特定绑定属性注册的 VetoableChangeListener。

如果侦听器为 null，则不抛出异常，也不执行任何动作。

参数：: propertyName - 有效属性名; listener - 要移除的 VetoableChangeListener

另请参见：

addVetoableChangeListener(java.beans.VetoableChangeListener), getVetoableChangeListeners(), removeVetoableChangeListener(java.beans.VetoableChangeListener)

getVetoableChangeListeners

public VetoableChangeListener[] getVetoableChangeListeners(String propertyName)

返回与指定属性相关联的所有 VetoableChangeListener 组成的数组。

返回：: 与指定属性相关联的所有 VetoableChangeListener；如果没有添加过这样的侦听器，则返回空数组。
从以下版本开始：: 1.4
另请参见：: addVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener), removeVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener), getVetoableChangeListeners()

fireVetoableChange

protected void fireVetoableChange(String propertyName,
                                  Object oldValue,
                                  Object newValue)
                           throws PropertyVetoException

激发 PropertyChangeEvent 以响应可否决属性中的更改。该事件将被传递到所有已注册的 VetoableChangeListener 中。如果 VetoableChangeListener 抛出 PropertyVetoException，则激发将所有 VetoableChangeListener 还原为旧值的新事件，并再次抛出异常。如果 oldValue 和 newValue 相同，则不会传递事件。

参数：: propertyName - 已更改的属性名; oldValue - 属性以前的值; newValue - 属性的新值

抛出：

PropertyVetoException - 如果 VetoableChangeListener 抛出了 PropertyVetoException

addKeyEventDispatcher

public void addKeyEventDispatcher(KeyEventDispatcher dispatcher)

将 KeyEventDispatcher 添加到此 KeyboardFocusManager 的调度程序链中。此 KeyboardFocusManager 将请求每个 KeyEventDispatcher 在最终指派 KeyEvent 本身之前，首先指派由用户生成的 KeyEvent。KeyEventDispatcher 将按其添加顺序得到通知。一旦一个 KeyEventDispatcher 从其 dispatchKeyEvent 方法返回 true，通知就会暂停。可以添加的 KeyEventDispatcher 的总数没有限制，添加特定 KeyEventDispatcher 实例的次数也没有限制。

如果指定了 null 指派程序，则不执行动作也不抛出异常。

在多线程应用程序中，KeyEventDispatcher 的行为与其他 AWT 侦听器相同。有关更多详细信息，请参阅 AWT 线程问题。

参数：: dispatcher - 要添加到指派程序链的 KeyEventDispatcher
另请参见：: removeKeyEventDispatcher(java.awt.KeyEventDispatcher)

removeKeyEventDispatcher

public void removeKeyEventDispatcher(KeyEventDispatcher dispatcher)

移除以前添加到此 KeyboardFocusManager 调度程序链中的 KeyEventDispatcher。此 KeyboardFocusManager 本身不能被移除，除非它是通过调用 addKeyEventDispatcher 显式重新注册的。

如果指定了 null 调度程序，指定的调度程序没有位于调度程序链中，或者此 KeyboardFocusManager 不是通过显式重新注册指定的，则不执行动作也不抛出异常。

在多线程应用程序中，KeyEventDispatcher 的行为与其他 AWT 侦听器相同。有关更多详细信息，请参阅 AWT 线程问题。

参数：: dispatcher - 要从调度程序链中移除的 KeyEventDispatcher
另请参见：: addKeyEventDispatcher(java.awt.KeyEventDispatcher)

getKeyEventDispatchers

protected List<KeyEventDispatcher> getKeyEventDispatchers()

作为 List 返回此 KeyboardFocusManager 的 KeyEventDispatcher 链。该 List 不包括此 KeyboardFocusManager，除非它是通过调用 addKeyEventDispatcher 显式重新注册的。如果没有注册其他 KeyEventDispatcher，则实现随意返回 null 或长度为 0 的 List。客户端代码不应假定某种行为多于其他行为，也不应假定建立行为后不能更改。

返回：: 可能返回 null，也可能返回 KeyEventDispatcher 的空 List
另请参见：: addKeyEventDispatcher(java.awt.KeyEventDispatcher), removeKeyEventDispatcher(java.awt.KeyEventDispatcher)

addKeyEventPostProcessor

public void addKeyEventPostProcessor(KeyEventPostProcessor processor)

将 KeyEventPostProcessor 添加到此 KeyboardFocusManager 的后处理器链中。将 KeyEvent 指派给目标并由目标处理后，KeyboardFocusManager 将请求每个 KeyEventPostProcessor 作为 KeyEvent 的最终解析的一部分执行所有必要的后处理操作。KeyEventPostProcessor 将按其添加顺序得到通知；当前 KeyboardFocusManager 将排在最后。一旦一个 KeyEventPostProcessor 从其 postProcessKeyEvent 方法返回 true，通知就会暂停。可以添加的 KeyEventPostProcessors 的总数没有限制，添加特定 KeyEventPostProcessor 实例的次数也没有限制。

如果指定了 null 后处理器，则不执行动作也不抛出异常。

在多线程应用程序中，KeyEventPostProcessor 的行为与其他 AWT 侦听器相同。有关更多详细信息，请参阅 AWT 线程问题。

参数：: processor - 要添加到后处理器链的 KeyEventPostProcessor
另请参见：: removeKeyEventPostProcessor(java.awt.KeyEventPostProcessor)

removeKeyEventPostProcessor

public void removeKeyEventPostProcessor(KeyEventPostProcessor processor)

从此 KeyboardFocusManager 的后处理器链中移除以前添加的 KeyEventPostProcessor。从该链中无法将 KeyboardFocusManager 本身完全移除。只能移除通过 addKeyEventPostProcessor 添加的其他引用。

如果指定了 null 后处理器，指定的后处理器没有位于后处理器链中，或者此 KeyboardFocusManager 不是通过显式添加指定的，则不执行动作也不抛出异常。

在多线程应用程序中，KeyEventPostProcessor 的行为与其他 AWT 侦听器相同。有关更多详细信息，请参阅 AWT 线程问题。

参数：: processor - 要从后处理器链中移除的 KeyEventPostProcessor
另请参见：: addKeyEventPostProcessor(java.awt.KeyEventPostProcessor)

getKeyEventPostProcessors

protected List<KeyEventPostProcessor> getKeyEventPostProcessors()

作为 List 返回此 KeyboardFocusManager 的 KeyEventPostProcessor 链。该 List 不包括此 KeyboardFocusManager，除非它是通过调用 addKeyEventPostProcessor 显式添加的。如果没有注册任何 KeyEventDispatcher，则实现随意返回 null 或长度为 0 的 List。客户端代码不应假定某种行为多于其他行为，也不应假定建立行为后不能更改。

返回：: 可能返回 null 也可能返回 KeyEventPostProcessor 的空 List
另请参见：: addKeyEventPostProcessor(java.awt.KeyEventPostProcessor), removeKeyEventPostProcessor(java.awt.KeyEventPostProcessor)

dispatchEvent

public abstract boolean dispatchEvent(AWTEvent e)

AWT 事件调度程序可以调用此方法，请求当前的 KeyboardFocusManager 为其指派指定的事件。所有 KeyboardFocusManager 需要指派所有 FocusEvent、所有与焦点相关的 WindowEvent 和所有 KeyEvent。这些事件应该基于 KeyboardFocusManager 的焦点所有者和聚焦及活动 Window 概念指派，有时会重写指定的 AWTEvent 的源代码。必须使用 redispatchEvent 完成指派操作，以防 AWT 事件调度程序递归式请求 KeyboardFocusManager 再次指派该事件。如果此方法返回 false，则 AWT 事件调度程序将尝试指派该事件本身。

参数：: e - 要指派的 AWTEvent
返回：: 如果此方法指派了该事件，则返回 true；否则返回 false
另请参见：: redispatchEvent(java.awt.Component, java.awt.AWTEvent), dispatchKeyEvent(java.awt.event.KeyEvent)

redispatchEvent

public final void redispatchEvent(Component target,
                                  AWTEvent e)

重新指派 AWTEvent 的方式是，AWT 事件调度程序不会递归式请求 KeyboardFocusManager 或任何已安装的 KeyEventDispatcher 再次指派该事件。dispatchEvent 的客户端实现和客户端定义的 KeyEventDispatcher 必须调用 redispatchEvent(target, e) 而不是调用 target.dispatchEvent(e) 来指派事件。

此方法仅供 KeyboardFocusManager 和 KeyEventDispatcher 使用。一般客户端不能使用。

参数：: target - 应将事件指派到的 Component; e - 要指派的事件

另请参见：

dispatchEvent(java.awt.AWTEvent), KeyEventDispatcher

dispatchKeyEvent

public abstract boolean dispatchKeyEvent(KeyEvent e)

通常情况下，如果该指派程序链中的其他 KeyEventDispatcher 没有指派 KeyEvent 或者没有注册其他 KeyEventDispatcher，则 dispatchEvent 将调用此方法。如果此方法的实现返回 false，则 dispatchEvent 可能试图指派 KeyEvent 本身，或者可能简单地返回 false。如果返回 true，则 dispatchEvent 也应该返回 true。

指定者：: 接口 KeyEventDispatcher 中的 dispatchKeyEvent

参数：: e - 当前 KeyboardFocusManager 已经请求此 KeyEventDispatcher 指派的 KeyEvent
返回：: 如果指派了 KeyEvent，则返回 true；否则，返回 false
另请参见：: dispatchEvent(java.awt.AWTEvent)

postProcessKeyEvent

public abstract boolean postProcessKeyEvent(KeyEvent e)

dispatchKeyEvent 将调用此方法。默认情况下，此方法将通过使用该事件并激活快捷方式来处理映射到 AWT MenuShortcut 的所有未使用的 KeyEvent。

指定者：: 接口 KeyEventPostProcessor 中的 postProcessKeyEvent

参数：: e - 要后处理的 KeyEvent
返回：: true，指示任何其他 KeyEventPostProcessor 都将得不到该 KeyEvent 的通知。
另请参见：: dispatchKeyEvent(java.awt.event.KeyEvent), MenuShortcut

processKeyEvent

public abstract void processKeyEvent(Component focusedComponent,
                                     KeyEvent e)

当且仅当该 KeyEvent 表示指定 focusedComponent 的焦点遍历键时，此方法启动焦点遍历操作。focusedComponent 应该是当前的焦点所有者，尽管这一点不是必需的。如果它不是，焦点遍历仍把 focusedComponent 当作是当前焦点所有者而继续执行操作。

参数：: focusedComponent - 指定的事件表示其焦点遍历键时，将成为焦点遍历操作基础的 Component; e - 可能表示焦点遍历键的事件

enqueueKeyEvents

protected abstract void enqueueKeyEvents(long after,
                                         Component untilFocused)

在指定的 Component 成为焦点所有者以前由 AWT 调用，以通知 KeyboardFocusManager 延迟指派 KeyEvent。如果客户端代码请求焦点更改，则 AWT 将确定本机窗口操作系统是否批准此请求，然后由 AWT 调用此方法。在指定的 Component 接收 FOCUS_GAINED 事件或 AWT 通过调用 dequeueKeyEvents 或 discardKeyEvents 取消延迟请求以前，KeyboardFocusManager 负责延迟指派时间戳晚于指定时间戳的 KeyEvent。

参数：: after - 当前事件的时间戳，如果当前事件没有时间戳或者 AWT 无法确定目前正在处理哪个事件，则为当前系统时间; untilFocused - 挂起 KeyEvent 之前应该接收 FOCUS_GAINED 事件的 Component

另请参见：

dequeueKeyEvents(long, java.awt.Component), discardKeyEvents(java.awt.Component)

dequeueKeyEvents

protected abstract void dequeueKeyEvents(long after,
                                         Component untilFocused)

由 AWT 调用以通知 KeyboardFocusManager 应该取消延迟指派 KeyEvent。应该释放由于使用相同时间戳和 Component 调用 enqueueKeyEvents 而加入队列的 KeyEvent，以将它们正常指派给当前焦点所有者。如果给定的时间戳小于零，则应该取消具有 oldest 时间戳的给定 Component 的未处理排队请求（如果有）。

参数：: after - 在对 enqueueKeyEvents 的调用中指定的时间戳，或者任何小于 0 的值; untilFocused - 在对 enqueueKeyEvents 的调用中指定的 Component

另请参见：

enqueueKeyEvents(long, java.awt.Component), discardKeyEvents(java.awt.Component)

discardKeyEvents

protected abstract void discardKeyEvents(Component comp)

由 AWT 调用以通知 KeyboardFocusManager 应该取消延迟指派 KeyEvent。应该丢弃由于使用相同 Component 一次或多次调用 enqueueKeyEvents 而加入队列 KeyEvent。

参数：: comp - 对 enqueueKeyEvents 的一次或多次调用中指定的 Component
另请参见：: enqueueKeyEvents(long, java.awt.Component), dequeueKeyEvents(long, java.awt.Component)

focusNextComponent

public abstract void focusNextComponent(Component aComponent)

聚焦 aComponent 之后的 Component，通常基于 FocusTraversalPolicy。

参数：: aComponent - 作为焦点遍历操作基础的 Component
另请参见：: FocusTraversalPolicy

focusPreviousComponent

public abstract void focusPreviousComponent(Component aComponent)

聚焦 aComponent 之前的 Component，通常基于 FocusTraversalPolicy。

参数：: aComponent - 作为焦点遍历操作基础的 Component
另请参见：: FocusTraversalPolicy

upFocusCycle

public abstract void upFocusCycle(Component aComponent)

将焦点上移一个焦点遍历循环。通常情况下，将焦点所有者设置为 aComponent 的焦点循环根，而将当前焦点循环根设置为新的焦点所有者的焦点循环根。但是，如果 aComponent 的焦点循环根是一个 Window，则通常将焦点所有者设置为要聚焦的 Window 的默认 Component，当前焦点循环根保持不变。

参数：: aComponent - 作为焦点遍历操作基础的 Component

downFocusCycle

public abstract void downFocusCycle(Container aContainer)

将焦点下移一个焦点遍历循环。通常情况下，如果 aContainer 是焦点循环根，则将焦点所有者设置为要聚焦的 aContainer 的默认 Component，而将当前焦点循环根设置为 aContainer。如果 aContainer 不是焦点循环根，则不进行焦点遍历操作。

参数：: aContainer - 作为焦点遍历操作基础的 Container

focusNextComponent

public final void focusNextComponent()

聚焦当前焦点所有者之后的 Component。

focusPreviousComponent

public final void focusPreviousComponent()

聚焦当前焦点所有者之前的 Component。

upFocusCycle

public final void upFocusCycle()

从当前焦点所有者将焦点上移一个焦点遍历循环。通常情况下，将新焦点所有者设置为当前焦点所有者的焦点循环根，而将当前焦点循环根设置为新焦点所有者的焦点循环根。但是，如果当前焦点所有者的焦点循环根是一个 Window，则通常将焦点所有者设置为要聚焦的焦点循环根的默认 Component，而当前焦点循环根保持不变。

downFocusCycle

public final void downFocusCycle()

当且仅当当前焦点所有者是一个作为焦点循环根的 Container 时，从当前焦点所有者将焦点下移一个焦点遍历循环。通常情况下，将焦点所有者设置为要聚焦的当前焦点所有者的默认 Component，而将当前焦点循环根设置为当前焦点所有者。如果当前焦点所有者不是作为焦点循环根的 Container，则不进行任何焦点遍历操作。

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

java.awt 类 KeyboardFocusManager

FORWARD_TRAVERSAL_KEYS

BACKWARD_TRAVERSAL_KEYS

UP_CYCLE_TRAVERSAL_KEYS

DOWN_CYCLE_TRAVERSAL_KEYS