Component - [ Java参考文档 ] - 在线原生手册

目录搜索

文字

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个下一个

框架 无框架

类 java.awt.Component
的使用

使用 Component 的软件包
java.applet	提供创建 applet 所必需的类和 applet 用来与其 applet 上下文通信的类。
java.awt	包含用于创建用户界面和绘制图形图像的所有类。
java.awt.dnd	Drag 和 Drop 是一种直接操作动作，在许多图形用户界面系统中都会遇到它，它提供了一种机制，能够在两个与 GUI 中显示元素逻辑相关的实体之间传输信息。
java.awt.event	提供处理由 AWT 组件所激发的各类事件的接口和类。
java.awt.im	提供输入方法框架所需的类和接口。
java.beans	包含与开发 beans 有关的类，即基于 JavaBeans^TM 架构的组件。
java.beans.beancontext	提供与 bean 上下文有关的类和接口。
javax.swing	提供一组“轻量级”（全部是 Java 语言）组件，尽量让这些组件在所有平台上的工作方式都相同。
javax.swing.border	提供围绕 Swing 组件绘制特殊边框的类和接口。
javax.swing.colorchooser	包含供 `JColorChooser` 组件使用的类和接口。
javax.swing.event	供 Swing 组件触发的事件使用。
javax.swing.plaf	提供一个接口和许多抽象类，Swing 用它们来提供自己的可插入外观功能。
javax.swing.plaf.basic	提供了根据基本外观构建的用户界面对象。
javax.swing.plaf.metal	提供根据 Java 外观（曾经代称为 Metal）构建的用户界面对象，Java 外观是默认外观。
javax.swing.plaf.synth	Synth 是一个可更换皮肤 (skinnable) 的外观，在其中可委托所有绘制。
javax.swing.table	提供用于处理 `javax.swing.JTable` 的类和接口。
javax.swing.text	提供类 `HTMLEditorKit` 和创建 HTML 文本编辑器的支持类。
javax.swing.text.html	提供类 `HTMLEditorKit` 和创建 HTML 文本编辑器的支持类。
javax.swing.tree	提供处理 `javax.swing.JTree` 的类和接口。

java.applet 中 Component 的使用

java.applet 中 Component 的子类
`class`	`Applet` applet 是一种不能单独运行但可嵌入在其他应用程序中的小程序。

java.awt 中 Component 的使用

java.awt 中 Component 的子类
`class`	`Button` 此类创建一个标签按钮。
`class`	`Canvas` `Canvas` 组件表示屏幕上一个空白矩形区域，应用程序可以在该区域内绘图，或者可以从该区域捕获用户的输入事件。
`class`	`Checkbox` 复选框是一个可处于“开”(`true`) 或“关”(`false`) 状态的图形组件。
`class`	`Choice` `Choice` 类表示一个弹出式选择菜单。
`class`	`Container` 一般的 Abstract Window Toolkit(AWT) 容器对象是一个可包含其他 AWT 组件的组件。
`class`	`Dialog` Dialog 是一个带标题和边界的顶层窗口，边界一般用于从用户处获得某种形式的输入。
`class`	`FileDialog` `FileDialog` 类显示一个对话框窗口，用户可以从中选择文件。
`class`	`Frame` `Frame` 是带有标题和边框的顶层窗口。
`class`	`Label` `Label` 对象是一个可在容器中放置文本的组件。
`class`	`List` `List` 组件为用户提供了一个可滚动的文本项列表。
`class`	`Panel` `Panel` 是最简单的容器类。
`class`	`Scrollbar` `Scrollbar` 类描述了一个滚动条，这是大家都很熟悉的用户界面对象。
`class`	`ScrollPane` 实现用于单个子组件的自动水平和/或垂直滚动的容器类。
`class`	`TextArea` `TextArea` 对象是显示文本的多行区域。
`class`	`TextComponent` `TextComponent` 类是所有允许编辑文本的组件的超类。
`class`	`TextField` `TextField` 对象是允许编辑单行文本的文本组件。
`class`	`Window` `Window` 对象是一个没有边界和菜单栏的顶层窗口。

类型参数类型为 Component 的 java.awt 中的字段
`protected Hashtable<Component,GridBagConstraints>`	`GridBagLayout.comptable` 此哈希表维持组件与其网格包约束之间的关联。

返回 Component 的 java.awt 中的方法
`Component`	`Container.add(Component comp)` 将指定组件追加到此容器的尾部。
`Component`	`Container.add(Component comp, int index)` 将指定组件添加到此容器的给定位置上。
`Component`	`Container.add(String name, Component comp)` 将指定组件添加到此容器中。
`Component`	`Container.findComponentAt(int x, int y)` 对包含指定位置的可视子组件进行定位。
`Component`	`Container.findComponentAt(Point p)` 对包含指定点的可视子组件进行定位。
`Component`	`Container.getComponent(int n)` 获取此容器中的第 n 个组件。
`Component`	`ContainerOrderFocusTraversalPolicy.getComponentAfter(Container aContainer, Component aComponent)` 返回应该接收 aComponent 后面的焦点的 Component。
`abstract Component`	`FocusTraversalPolicy.getComponentAfter(Container aContainer, Component aComponent)` 返回应该接收 aComponent 之后的焦点的 Component，aContainer 必须是 aComponent 的焦点循环根，或者焦点遍历策略提供者。
`Component`	`Container.getComponentAt(int x, int y)` 对包含 x，y 位置的组件进行定位。
`Component`	`Component.getComponentAt(int x, int y)` 确定此组件或其直接子组件之一是否包含（x，y）位置，并且如果是，则返回包含该位置的组件。
`Component`	`Container.getComponentAt(Point p)` 获取包含指定点的组件。
`Component`	`Component.getComponentAt(Point p)` 返回包含指定点的组件或子组件。
`Component`	`ContainerOrderFocusTraversalPolicy.getComponentBefore(Container aContainer, Component aComponent)` 返回应该接收 aComponent 前面的焦点的 Component。
`abstract Component`	`FocusTraversalPolicy.getComponentBefore(Container aContainer, Component aComponent)` 返回应该接收 aComponent 之前的焦点的 Component，aContainer 必须是 aComponent 的焦点循环根，或焦点遍历策略提供者。
`Component[]`	`Container.getComponents()` 获取此容器中的所有组件。
`Component`	`ContainerOrderFocusTraversalPolicy.getDefaultComponent(Container aContainer)` 返回默认拥有焦点的 Component。
`abstract Component`	`FocusTraversalPolicy.getDefaultComponent(Container aContainer)` 返回要聚焦的默认 Component。
`Component`	`ContainerOrderFocusTraversalPolicy.getFirstComponent(Container aContainer)` 返回遍历循环中的第一个 Component。
`abstract Component`	`FocusTraversalPolicy.getFirstComponent(Container aContainer)` 返回遍历循环中的第一个 Component。
`Component`	`KeyboardFocusManager.getFocusOwner()` 如果焦点所有者与调用线程位于同一个上下文中，则返回该焦点所有者。
`Component`	`Window.getFocusOwner()` 如果此窗口为焦点窗口，则返回是焦点窗口的子组件；否则返回 null。
`protected Component`	`KeyboardFocusManager.getGlobalFocusOwner()` 返回焦点所有者，即使调用线程处于焦点所有者之外的上下文中。
`protected Component`	`KeyboardFocusManager.getGlobalPermanentFocusOwner()` 返回持久焦点所有者，即使调用线程处于该持久焦点所有者之外的上下文中。
`Component`	`FocusTraversalPolicy.getInitialComponent(Window window)` 返回第一次将窗口设置为可见时，应该接收焦点的 Component。
`Component`	`ContainerOrderFocusTraversalPolicy.getLastComponent(Container aContainer)` 返回遍历循环中的最后一个 Component。
`abstract Component`	`FocusTraversalPolicy.getLastComponent(Container aContainer)` 返回遍历循环中的最后一个 Component。
`Component`	`BorderLayout.getLayoutComponent(Container target, Object constraints)` 基于目标 `Container` 的组件方向，返回给定约束位置对应的组件。
`Component`	`BorderLayout.getLayoutComponent(Object constraints)` 获取使用给定约束添加的组件。
`Component`	`Window.getMostRecentFocusOwner()` 返回此窗口的子组件，该子组件在此窗口为焦点窗口时将接收焦点。
`Component`	`KeyboardFocusManager.getPermanentFocusOwner()` 如果持久焦点所有者与调用线程位于同一个上下文中，则返回持久焦点所有者。
`Component`	`Container.locate(int x, int y)` 已过时。从 JDK version 1.1 开始，用 `getComponentAt(int, int)` 取代。
`Component`	`Component.locate(int x, int y)` 已过时。从 JDK version 1.1 开始，由 getComponentAt(int, int) 取代。

参数类型为 Component 的 java.awt 中的方法

protected boolean DefaultFocusTraversalPolicy.accept(Component aComponent)
确定是否可以接受选择某个 Component 作为新的焦点所有者。

protected boolean ContainerOrderFocusTraversalPolicy.accept(Component aComponent)
确定是否可以接受选择某个 Component 作为新的焦点拥有者。

Component Container.add(Component comp)
将指定组件追加到此容器的尾部。

Component Container.add(Component comp, int index)
将指定组件添加到此容器的给定位置上。

void Container.add(Component comp, Object constraints)
将指定的组件添加到此容器的尾部。

void Container.add(Component comp, Object constraints, int index)
使用指定约束，将指定组件添加到此容器的指定索引所在的位置上。

Component Container.add(String name, Component comp)
将指定组件添加到此容器中。

protected void ScrollPane.addImpl(Component comp, Object constraints, int index)
将指定的组件添加到此滚动窗格容器。

protected void Container.addImpl(Component comp, Object constraints, int index)
将指定组件添加到此容器的指定索引所在的位置上。

void GridBagLayout.addLayoutComponent(Component comp, Object constraints)
使用指定 constraints 对象将指定组件添加到布局中。

void CardLayout.addLayoutComponent(Component comp, Object constraints)
将指定的组件添加到此卡片布局的内部名称表。

void BorderLayout.addLayoutComponent(Component comp, Object constraints)
使用指定的约束对象将指定组件添加到布局中。

void LayoutManager2.addLayoutComponent(Component comp, Object constraints)
使用指定约束对象，将指定组件添加到布局。

void GridBagLayout.addLayoutComponent(String name, Component comp)
无效，因为此布局管理器不使用每组件字符串。

void GridLayout.addLayoutComponent(String name, Component comp)
将具有指定名称的指定组件添加到布局。

void CardLayout.addLayoutComponent(String name, Component comp)
已过时。 由 addLayoutComponent(Component, Object) 取代。

void FlowLayout.addLayoutComponent(String name, Component comp)
将指定的组件添加到布局中。

void BorderLayout.addLayoutComponent(String name, Component comp)
已过时。 由 addLayoutComponent(Component, Object) 取代。

void LayoutManager.addLayoutComponent(String name, Component comp)
如果布局管理器使用每组件字符串，则将组件 comp 添加到布局，并将它与 name 指定的字符串关联。

protected java.awt.peer.LightweightPeer Toolkit.createComponent(Component target)
创建组件或容器的同位体。




<T extends DragGestureRecognizer> 


T

Toolkit.createDragGestureRecognizer(Class<T> abstractRecognizerClass,
                            DragSource ds,
                            Component c,
                            int srcActions,
                            DragGestureListener dgl)

创建所请求的抽象 DragGestureRecognizer 类的具体的、与平台有关的子类，并将它与指定的 DragSource、Component 和 DragGestureListener 关联。

protected void DefaultKeyboardFocusManager.dequeueKeyEvents(long after, Component untilFocused)
释放正常指派到当前焦点所有者的所有 KeyEvent，这些 KeyEvent 因为调用了具有相同时间戳和 Component 的 enqueueKeyEvents 而被加入队列。

protected abstract void KeyboardFocusManager.dequeueKeyEvents(long after, Component untilFocused)
由 AWT 调用以通知 KeyboardFocusManager 应该取消延迟指派 KeyEvent。

protected void DefaultKeyboardFocusManager.discardKeyEvents(Component comp)
放弃因为一次或多次调用具有指定 Component 或其子代之一的 enqueueKeyEvents 而加入队列的所有 KeyEvent。

protected abstract void KeyboardFocusManager.discardKeyEvents(Component comp)
由 AWT 调用以通知 KeyboardFocusManager 应该取消延迟指派 KeyEvent。

protected void DefaultKeyboardFocusManager.enqueueKeyEvents(long after, Component untilFocused)
延迟对 KeyEvent 的指派，直到指定的 Component 成为焦点所有者。

protected abstract void KeyboardFocusManager.enqueueKeyEvents(long after, Component untilFocused)
在指定的 Component 成为焦点所有者以前由 AWT 调用，以通知 KeyboardFocusManager 延迟指派 KeyEvent。

void DefaultKeyboardFocusManager.focusNextComponent(Component aComponent)
使 aComponent 后面的 Component 拥有焦点，通常基于 FocusTraversalPolicy。

abstract void KeyboardFocusManager.focusNextComponent(Component aComponent)
聚焦 aComponent 之后的 Component，通常基于 FocusTraversalPolicy。

void DefaultKeyboardFocusManager.focusPreviousComponent(Component aComponent)
使 aComponent 前面的 Component 拥有焦点，通常基于 FocusTraversalPolicy。

abstract void KeyboardFocusManager.focusPreviousComponent(Component aComponent)
聚焦 aComponent 之前的 Component，通常基于 FocusTraversalPolicy。

Component ContainerOrderFocusTraversalPolicy.getComponentAfter(Container aContainer, Component aComponent)
返回应该接收 aComponent 后面的焦点的 Component。

abstract Component FocusTraversalPolicy.getComponentAfter(Container aContainer, Component aComponent)
返回应该接收 aComponent 之后的焦点的 Component，aContainer 必须是 aComponent 的焦点循环根，或者焦点遍历策略提供者。

Component ContainerOrderFocusTraversalPolicy.getComponentBefore(Container aContainer, Component aComponent)
返回应该接收 aComponent 前面的焦点的 Component。

abstract Component FocusTraversalPolicy.getComponentBefore(Container aContainer, Component aComponent)
返回应该接收 aComponent 之前的焦点的 Component，aContainer 必须是 aComponent 的焦点循环根，或焦点遍历策略提供者。

int Container.getComponentZOrder(Component comp)
返回容器内组件的 z 顺序索引。

GridBagConstraints GridBagLayout.getConstraints(Component comp)
获取指定组件的约束。

Object BorderLayout.getConstraints(Component comp)
获取指定组件的约束

protected static Container Toolkit.getNativeContainer(Component c)
使本机同位体能够查询给定本机组件的本机容器（例如，直接父组件可以是轻量级的）。

boolean Container.isAncestorOf(Component c)
检查该组件是否包含在此容器的组件层次结构中。

protected GridBagConstraints GridBagLayout.lookupConstraints(Component comp)
检索指定组件的约束。

void DefaultKeyboardFocusManager.processKeyEvent(Component focusedComponent, KeyEvent e)
当且仅当该 KeyEvent 表示指定 focusedComponent 的焦点遍历键时，此方法才会启动一个焦点遍历操作。

abstract void KeyboardFocusManager.processKeyEvent(Component focusedComponent, KeyEvent e)
当且仅当该 KeyEvent 表示指定 focusedComponent 的焦点遍历键时，此方法启动焦点遍历操作。

void KeyboardFocusManager.redispatchEvent(Component target, AWTEvent e)
重新指派 AWTEvent 的方式是，AWT 事件调度程序不会递归式请求 KeyboardFocusManager 或任何已安装的 KeyEventDispatcher 再次指派该事件。

void Container.remove(Component comp)
从此容器中移除指定组件。

void GridBagLayout.removeLayoutComponent(Component comp)
从此布局移除指定组件。

void GridLayout.removeLayoutComponent(Component comp)
从布局移除指定组件。

void CardLayout.removeLayoutComponent(Component comp)
从布局中移除指定的组件。

void FlowLayout.removeLayoutComponent(Component comp)
从布局中移除指定的组件。

void BorderLayout.removeLayoutComponent(Component comp)
从此边框布局中移除指定组件。

void LayoutManager.removeLayoutComponent(Component comp)
从布局移除指定组件。

void Container.setComponentZOrder(Component comp, int index)
将指定组件移动到容器中指定的 z 顺序索引。

void GridBagLayout.setConstraints(Component comp, GridBagConstraints constraints)
设置此布局中指定组件的约束条件。

protected void KeyboardFocusManager.setGlobalFocusOwner(Component focusOwner)
设置焦点所有者。

protected void KeyboardFocusManager.setGlobalPermanentFocusOwner(Component permanentFocusOwner)
设置持久焦点所有者。

void Window.setLocationRelativeTo(Component c)
设置窗口相对于指定组件的位置。

void PopupMenu.show(Component origin, int x, int y)
在相对于初始组件的 x、y 位置上显示弹出式菜单。

void DefaultKeyboardFocusManager.upFocusCycle(Component aComponent)
将焦点上移一个焦点遍历循环。

abstract void KeyboardFocusManager.upFocusCycle(Component aComponent)
将焦点上移一个焦点遍历循环。

参数类型为 Component 的 java.awt 中的构造方法
`MediaTracker(Component comp)` 创建媒体跟踪器以跟踪给定组件的图像。

java.awt.dnd 中 Component 的使用

声明为 Component 的 java.awt.dnd 中的字段
`protected Component`	`DragGestureRecognizer.component` 与此 `DragGestureRecognizer` 关联的 `Component`。

返回 Component 的 java.awt.dnd 中的方法
`Component`	`DragGestureEvent.getComponent()` 返回与此 `DragGestureEvent` 关联的 `Component`。
`Component`	`DragGestureRecognizer.getComponent()` 此方法返回 `DragGestureRecognizer` 所“观察”的 `Component`，以便了解拖动开始动作。
`Component`	`DragSourceContext.getComponent()` 返回与此 `DragSourceContext` 关联的 `Component`。
`Component`	`DropTargetContext.getComponent()` 此方法返回与此 `DropTargetContext` 相关的 `Component`。
`Component`	`DropTarget.getComponent()` 获取与此 `DropTarget` 关联的 `Component`。

参数类型为 Component 的 java.awt.dnd 中的方法

DragGestureRecognizer DragSource.createDefaultDragGestureRecognizer(Component c, int actions, DragGestureListener dgl)
创建一个新的 DragGestureRecognizer，为此 DragSource 实现 DragGestureRecognizer 的默认抽象子类并在新创建的对象上设置指定的 Component 和 DragGestureListener。




<T extends DragGestureRecognizer> 


T

DragSource.createDragGestureRecognizer(Class<T> recognizerAbstractClass,
                            Component c,
                            int actions,
                            DragGestureListener dgl)

创建一个新的 DragGestureRecognizer，实现 DragGestureRecognizer 的指定抽象子类并在新创建的对象上设置指定的 Component 和 DragGestureListener。

protected DropTarget.DropTargetAutoScroller DropTarget.createDropTargetAutoScroller(Component c, Point p)
创建一个嵌入式自动滚动条

void DragGestureRecognizer.setComponent(Component c)
设置与该 DragGestureRecognizer 关联的 Component 使用此方法时还会调用 registerListeners() 和 unregisterListeners()。

void DropTarget.setComponent(Component c)
注意：要求此接口允许 DropTarget 以下面两种方式之一与 Component 安全关联：component.setDropTarget(droptarget) 或 droptarget.setComponent(component)。

参数类型为 Component 的 java.awt.dnd 中的构造方法
`DragGestureRecognizer(DragSource ds, Component c)` 构造一个新的 `DragGestureRecognizer`，使其具有给定此 Drag 和 Drop 操作中使用的 `DragSource` 和此 `DragGestureRecognizer` 应该“观察”拖动开始动作的 `Component`。
`DragGestureRecognizer(DragSource ds, Component c, int sa)` 构造一个新的 `DragGestureRecognizer`，使其具有给定此 Drag 和 Drop 操作中使用的 `DragSource`、此 `DragGestureRecognizer` 应该“观察”拖动开始动作的 `Component` 和此 Drag 和 Drop 操作所支持的动作。
`DragGestureRecognizer(DragSource ds, Component c, int sa, DragGestureListener dgl)` 构造一个新的 `DragGestureRecognizer`，使其具有给定此 Drag 和 Drop 操作中使用的 `DragSource`、此 `DragGestureRecognizer` 应该“观察”拖动开始动作的 `Component`、此 Drag 和 Drop 操作所支持的操作和一旦检测到拖动开始动作要通知的 `DragGestureListener`。
`DropTarget.DropTargetAutoScroller(Component c, Point p)` 构造一个 DropTargetAutoScroller
`DropTarget(Component c, DropTargetListener dtl)` 在给出与之关联的 `Component` 和执行事件处理的 `DropTargetListener` 的情况下创建一个 `DropTarget`。
`DropTarget(Component c, int ops, DropTargetListener dtl)` 在给出与之关联的 `Component`、表示支持的默认可接受操作的 `int` 值和执行事件处理的 `DropTargetListener` 的情况下，创建一个 `DropTarget`。
`DropTarget(Component c, int ops, DropTargetListener dtl, boolean act)` 在给出与之关联的 `Component`、表示支持的默认可接受操作的 `int` 值、执行事件处理的 `DropTargetListener` 和表示 `DropTarget` 当前是否接受 drop 的 `boolean` 值的情况下，创建一个 `DropTarget`。
`DropTarget(Component c, int ops, DropTargetListener dtl, boolean act, FlavorMap fm)` 在给出与之关联的 `Component`、表示要支持的默认可接受操作的 `int` 值、执行事件处理的 `DropTargetListener`、表示 `DropTarget` 当前是否接受 drop 的 `boolean` 值和要使用的 `FlavorMap`（使用默认 `FlavorMap` 时为 null）的情况下，创建一个新的 DropTarget。
`MouseDragGestureRecognizer(DragSource ds, Component c)` 给出 `Component` c 的 `DragSource`、要观察的 `Component`，构造一个新的 `MouseDragGestureRecognizer`。
`MouseDragGestureRecognizer(DragSource ds, Component c, int act)` 给出 `Component` c 的 `DragSource`、要观察的 `Component`，以及此拖动操作允许的操作，构造一个新的 `MouseDragGestureRecognizer`。
`MouseDragGestureRecognizer(DragSource ds, Component c, int act, DragGestureListener dgl)` 给出 `Component` c 的 `DragSource`、要观察的 `Component`、此拖动操作允许的操作，以及检测到拖动动作时发出通知的 `DragGestureListener`，构造一个新的 `MouseDragGestureRecognizer`。

java.awt.event 中 Component 的使用

返回 Component 的 java.awt.event 中的方法
`Component`	`HierarchyEvent.getChanged()` 返回位于被更改层次结构顶部的 Component。
`Component`	`ContainerEvent.getChild()` 返回受事件影响的组件。
`Component`	`HierarchyEvent.getComponent()` 返回事件的始发者。
`Component`	`ComponentEvent.getComponent()` 返回事件的始发者。
`Component`	`FocusEvent.getOppositeComponent()` 返回此焦点更改中涉及的另一个 Component。

参数类型为 Component 的 java.awt.event 中的构造方法
`ComponentEvent(Component source, int id)` 构造一个 `ComponentEvent` 对象。
`ContainerEvent(Component source, int id, Component child)` 构造一个 `ContainerEvent` 对象。
`FocusEvent(Component source, int id)` 构造一个 `FocusEvent` 对象，并将它标识为一个持久性焦点更改。
`FocusEvent(Component source, int id, boolean temporary)` 构造一个 `FocusEvent` 对象，并将标识更改是否为暂时的。
`FocusEvent(Component source, int id, boolean temporary, Component opposite)` 构造一个 `FocusEvent` 对象，它具有指定的暂时状态和对立 `Component`。
`HierarchyEvent(Component source, int id, Component changed, Container changedParent)` 构造一个 `HierarchyEvent` 对象来标识 `Component` 层次结构中的更改。
`HierarchyEvent(Component source, int id, Component changed, Container changedParent, long changeFlags)` 构造一个 `HierarchyEvent` 对象来标识 `Component` 层次结构中的更改。
`InputMethodEvent(Component source, int id, AttributedCharacterIterator text, int committedCharacterCount, TextHitInfo caret, TextHitInfo visiblePosition)` 通过指定源组件、类型、文本、插入符和 visiblePosition 来构造 `InputMethodEvent`。
`InputMethodEvent(Component source, int id, long when, AttributedCharacterIterator text, int committedCharacterCount, TextHitInfo caret, TextHitInfo visiblePosition)` 通过指定源组件、类型、时间、文本、插入符和 visiblePosition 来构造 `InputMethodEvent`。
`InputMethodEvent(Component source, int id, TextHitInfo caret, TextHitInfo visiblePosition)` 通过指定源组件、类型、插入符和 visiblePosition 来构造 `InputMethodEvent`。
`KeyEvent(Component source, int id, long when, int modifiers, int keyCode)` 已过时。从 JDK1.1 开始
`KeyEvent(Component source, int id, long when, int modifiers, int keyCode, char keyChar)` 构造一个 `KeyEvent` 对象。
`KeyEvent(Component source, int id, long when, int modifiers, int keyCode, char keyChar, int keyLocation)`
`MouseEvent(Component source, int id, long when, int modifiers, int x, int y, int clickCount, boolean popupTrigger)` 构造一个具有指定源组件、类型、修饰符、坐标和单击计数的 `MouseEvent` 对象。
`MouseEvent(Component source, int id, long when, int modifiers, int x, int y, int clickCount, boolean popupTrigger, int button)` 构造一个具有指定源组件、类型、修饰符、坐标和单击计数的 `MouseEvent` 对象。
`MouseEvent(Component source, int id, long when, int modifiers, int x, int y, int xAbs, int yAbs, int clickCount, boolean popupTrigger, int button)` 构造一个具有指定源组件、类型、修饰符、相对坐标、绝对坐标和单击计数的 `MouseEvent` 对象。
`MouseWheelEvent(Component source, int id, long when, int modifiers, int x, int y, int clickCount, boolean popupTrigger, int scrollType, int scrollAmount, int wheelRotation)` 构造一个具有指定源组件、类型、修改键、坐标、滚动类型、滚动量和滚轮旋转的 `MouseWheelEvent`。
`MouseWheelEvent(Component source, int id, long when, int modifiers, int x, int y, int xAbs, int yAbs, int clickCount, boolean popupTrigger, int scrollType, int scrollAmount, int wheelRotation)` 构造一个具有指定源组件、类型、修改键、坐标、绝对坐标、滚动类型、滚动量和滚轮滚动的 `MouseWheelEvent` 对象。
`PaintEvent(Component source, int id, Rectangle updateRect)` 构造一个具有指定源组件和类型的 `PaintEvent` 对象。

java.awt.im 中 Component 的使用

参数类型为 Component 的 java.awt.im 中的方法
`void`	`InputContext.removeNotify(Component client)` 通知输入上下文，客户端组件已从它的包含层次结构中移除，或该组件已禁用输入方法支持。

java.beans 中 Component 的使用

返回 Component 的 java.beans 中的方法
`Component`	`PropertyEditor.getCustomEditor()` PropertyEditor 可以选择使用完全自定义的 Component 来编辑自己的属性值。
`Component`	`PropertyEditorSupport.getCustomEditor()` PropertyEditor 可以选择使用完全自定义的 Component 来编辑自己的属性值。

java.beans.beancontext 中 Component 的使用

返回 Component 的 java.beans.beancontext 中的方法
`Component`	`BeanContextChildComponentProxy.getComponent()` 获得与此 `BeanContextChild` 相关联的 `java.awt.Component`。

javax.swing 中 Component 的使用

javax.swing 中 Component 的子类
`class`	`AbstractButton` 定义按钮和菜单项的一般行为。
`class`	`Box` 使用 BoxLayout 对象作为其布局管理器的一个轻量级容器。
`static class`	`Box.Filler` 参与布局但没有视图的轻量级组件的实现。
`class`	`CellRendererPane` 此类被插入在单元格渲染器与使用它们的组件之间。
`class`	`DefaultListCellRenderer` 呈现列表中的一个项。
`static class`	`DefaultListCellRenderer.UIResource` 实现 UIResource 的 DefaultListCellRenderer 的子类。
`class`	`JApplet` `java.applet.Applet` 的扩展版，它添加了对 JFC/Swing 组件架构的支持。
`class`	`JButton` "push" 按钮的实现。
`class`	`JCheckBox` 复选框的实现，复选框是一个可以被选定和取消选定的项，它将其状态显示给用户。
`class`	`JCheckBoxMenuItem` 可以被选定或取消选定的菜单项。
`class`	`JColorChooser` `JColorChooser` 提供一个用于允许用户操作和选择颜色的控制器窗格。
`class`	`JComboBox` 将按钮或可编辑字段与下拉列表组合的组件。
`class`	`JComponent` 该类是除顶层容器外所有 Swing 组件的基类。
`class`	`JDesktopPane` 用于创建多文档界面或虚拟桌面的容器。
`class`	`JDialog` 创建对话框窗口的主要类。
`class`	`JEditorPane` 可编辑各种内容的文本组件。
`class`	`JFileChooser` `JFileChooser` 为用户选择文件提供了一种简单的机制。
`class`	`JFormattedTextField` `JFormattedTextField` 扩展了 `JTextField`，添加了对格式化任意值的支持，以及一旦用户编辑了文本就检索特定对象的支持。
`class`	`JFrame` `java.awt.Frame` 的扩展版本，该版本添加了对 JFC/Swing 组件架构的支持。
`class`	`JInternalFrame` 提供很多本机窗体功能的轻量级对象，这些功能包括拖动、关闭、变成图标、调整大小、标题显示和支持菜单栏。
`static class`	`JInternalFrame.JDesktopIcon` 此组件表示 `JInternalFrame` 的图标化版本。
`class`	`JLabel` 用于短文本字符串或图像或二者的显示区。
`class`	`JLayeredPane` `JLayeredPane` 为 JFC/Swing 容器添加了深度，允许组件在需要时互相重叠。
`class`	`JList` 显示对象列表并且允许用户选择一个或多个项的组件。
`class`	`JMenu` 菜单的该实现是一个包含 `JMenuItem` 的弹出窗口，用户选择 `JMenuBar` 上的项时会显示该 JMenuItem。
`class`	`JMenuBar` 菜单栏的实现。
`class`	`JMenuItem` 菜单中的项的实现。
`class`	`JOptionPane` `JOptionPane` 有助于方便地弹出要求用户提供值或向其发出通知的标准对话框。
`class`	`JPanel` `JPanel` 是一般轻量级容器。
`class`	`JPasswordField` `JPasswordField` 是一个轻量级组件，允许编辑单行文本，其视图指示键入内容，但不显示原始字符。
`class`	`JPopupMenu` 弹出菜单的实现，弹出菜单是一个可弹出并显示一系列选项的小窗口。
`static class`	`JPopupMenu.Separator` 弹出与菜单有关的分隔符。
`class`	`JProgressBar` 以可视化形式显示某些任务进度的组件。
`class`	`JRadioButton` 实现一个单选按钮，此按钮项可被选择或取消选择，并可为用户显示其状态。
`class`	`JRadioButtonMenuItem` 一个单选按钮菜单项的实现。
`class`	`JRootPane` 该轻量级容器由 `JFrame`、`JDialog`、`JWindow`、`JApplet` 和 `JInternalFrame` 在后台使用。
`class`	`JScrollBar` 滚动条的实现。
`class`	`JScrollPane` 提供轻量级组件的 scrollable 视图。
`protected class`	`JScrollPane.ScrollBar` 默认情况下，`JScrollPane` 创建的滚动条为此类的实例。
`class`	`JSeparator` `JSeparator` 为实现分隔线提供了一个通用组件 - 通常用作菜单项之间的分隔符，以便将菜单项分成几个逻辑组。
`class`	`JSlider` 一个让用户以图形方式在有界区间内通过移动滑块来选择值的组件。
`class`	`JSpinner` 让用户从一个有序序列中选择一个数字或者一个对象值的单行输入字段。
`static class`	`JSpinner.DateEditor` 其模型为 `SpinnerDateModel` 的 `JSpinner` 编辑器。
`static class`	`JSpinner.DefaultEditor` 一个针对非常特殊编辑器的简单基类，该类在 `JFormattedTextField` 中显示模型的当前值的只读视图。
`static class`	`JSpinner.ListEditor` 其模型为 `SpinnerListModel` 的 `JSpinner` 编辑器。
`static class`	`JSpinner.NumberEditor` 其模型为 `SpinnerNumberModel` 的 `JSpinner` 编辑器。
`class`	`JSplitPane` `JSplitPane` 用于分隔两个（只能两个）`Component`。
`class`	`JTabbedPane` 一个组件，它允许用户通过单击具有给定标题和/或图标的选项卡，在一组组件之间进行切换。
`class`	`JTable` `JTable` 用来显示和编辑常规二维单元表。
`class`	`JTextArea` `JTextArea` 是一个显示纯文本的多行区域。
`class`	`JTextField` `JTextField` 是一个轻量级组件，它允许编辑单行文本。
`class`	`JTextPane` 可以用以图形方式表示的属性来标记的文本组件。
`class`	`JToggleButton` 具有两个状态的（two-state）按钮的实现。
`class`	`JToolBar` `JToolBar` 提供了一个用来显示常用的 `Action` 或控件的组件。
`static class`	`JToolBar.Separator` 一个特定于工具栏的分隔符。
`class`	`JToolTip` 用来显示 Component 的“提示”。
`class`	`JTree` 将分层数据集显示为轮廓的控件。
`class`	`JViewport` 用于查看底层信息的“视口”或“观察孔”。
`class`	`JWindow` `JWindow` 是一个容器，可以显示在用户桌面上的任何位置。

声明为 Component 的 javax.swing 中的字段
`protected static Component`	`ImageIcon.component`
`protected Component`	`JTable.editorComp` 在编辑时处理编辑的 `Component`。
`protected Component`	`JRootPane.glassPane` 覆盖菜单栏和内容窗格的玻璃窗格，便于截取鼠标移动等操作。
`protected Component`	`JLabel.labelFor`
`protected Component`	`JSplitPane.leftComponent` 左边或者顶部的组件。
`protected Component`	`ScrollPaneLayout.lowerLeft` 左下角显示的组件。
`protected Component`	`JScrollPane.lowerLeft` 在左下角显示的组件。
`protected Component`	`ScrollPaneLayout.lowerRight` 右下角显示的组件。
`protected Component`	`JScrollPane.lowerRight` 在右下角显示的组件。
`protected Component`	`JSplitPane.rightComponent` 右边或者底部的组件。
`protected Component`	`ScrollPaneLayout.upperLeft` 左上角显示的组件。
`protected Component`	`JScrollPane.upperLeft` 在左上角显示的组件。
`protected Component`	`ScrollPaneLayout.upperRight` 右上角显示的组件。
`protected Component`	`JScrollPane.upperRight` 在右上角显示的组件。

返回 Component 的 javax.swing 中的方法
`Component`	`JTabbedPane.add(Component component)` 添加一个 `component`，其选项卡的默认值为调用 `component.getName` 返回的组件的名称。
`Component`	`JMenu.add(Component c)` 将某个组件追加到此菜单的末尾。
`Component`	`JTabbedPane.add(Component component, int index)` 在指定的选项卡索引位置添加一个 `component`，默认的选项卡标题为组件名称。
`Component`	`JMenu.add(Component c, int index)` 将指定组件添加到此容器的给定位置上。
`Component`	`JTabbedPane.add(String title, Component component)` 添加具有指定选项卡标题的 `component`。
`protected Component`	`ScrollPaneLayout.addSingletonComponent(Component oldC, Component newC)` 移除现有组件。
`Component`	`MenuSelectionManager.componentForPoint(Component source, Point sourcePoint)` 返回包含 sourcePoint 的当前选择路径的组件。
`protected Component`	`JRootPane.createGlassPane()` 由构造方法调用以便创建默认的 `glassPane`。
`static Component`	`Box.createGlue()` 创建一个不可见的 "glue" 组件，其可见组件有一个最大宽度（对于横向 box）或高度（对于纵向 box）的 Box，该组件可能很有用。
`static Component`	`Box.createHorizontalGlue()` 创建一个横向 glue 组件。
`static Component`	`Box.createHorizontalStrut(int width)` 创建一个不可见的、固定宽度的组件。
`static Component`	`Box.createRigidArea(Dimension d)` 创建一个总是具有指定大小的不可见组件。
`static Component`	`Box.createVerticalGlue()` 创建一个纵向 glue 组件。
`static Component`	`Box.createVerticalStrut(int height)` 创建一个不可见的、固定高度的组件。
`static Component`	`SwingUtilities.findFocusOwner(Component c)` 已过时。从 1.4 开始，由 `KeyboardFocusManager.getFocusOwner()` 取代。
`Component`	`JSplitPane.getBottomComponent()` 返回分隔条下面或者右边的组件。
`Component`	`Renderer.getComponent()` 返回用于呈现该值的组件。
`Component`	`DefaultCellEditor.getComponent()` 返回对编辑器组件的引用。
`Component`	`TransferHandler.TransferSupport.getComponent()` 返回此传输的目标组件。
`Component`	`JPopupMenu.getComponent()` 返回此 `JPopupMenu` 组件。
`Component`	`JMenuBar.getComponent()` 实现为 `MenuElement`。
`Component`	`JMenu.getComponent()` 返回用于绘制此 `MenuElement` 的 `java.awt.Component`。
`Component`	`JMenuItem.getComponent()` 返回用于绘制此对象的 `java.awt.Component`。
`Component`	`MenuElement.getComponent()` 此方法应返回用于绘制接收元素的 java.awt.Component。
`Component`	`DefaultFocusManager.getComponentAfter(Container aContainer, Component aComponent)`
`Component`	`LayoutFocusTraversalPolicy.getComponentAfter(Container aContainer, Component aComponent)` 返回应在 aComponent 之后接收焦点的 Component。
`Component`	`SortingFocusTraversalPolicy.getComponentAfter(Container aContainer, Component aComponent)` 返回应该接收 aComponent 后面的焦点的 Component。
`Component`	`JTabbedPane.getComponentAt(int index)` 返回 `index` 位置的组件。
`Component`	`JPopupMenu.getComponentAtIndex(int i)` 已过时。由 `Container.getComponent(int)` 取代
`Component`	`JMenuBar.getComponentAtIndex(int i)` 已过时。由 `getComponent(int i)` 取代
`Component`	`JToolBar.getComponentAtIndex(int i)` 返回指定索引位置的组件。
`Component`	`DefaultFocusManager.getComponentBefore(Container aContainer, Component aComponent)`
`Component`	`LayoutFocusTraversalPolicy.getComponentBefore(Container aContainer, Component aComponent)` 返回应在 aComponent 之前接收焦点的 Component。
`Component`	`SortingFocusTraversalPolicy.getComponentBefore(Container aContainer, Component aComponent)` 返回应该接收 aComponent 前面的焦点的 Component。
`Component[]`	`JLayeredPane.getComponentsInLayer(int layer)` 返回指定层中组件的数组。
`Component`	`ScrollPaneLayout.getCorner(String key)` 返回位于指定角的 `Component`。
`Component`	`JScrollPane.getCorner(String key)` 返回位于指定角的组件。
`protected Component`	`JTable.AccessibleJTable.AccessibleJTableCell.getCurrentComponent()` 获取表单元格渲染器组件。
`static Component`	`SwingUtilities.getDeepestComponentAt(Component parent, int x, int y)` 返回包含位置 `x`、`y` 的 `parent` 的最深可见后代组件。
`Component`	`SortingFocusTraversalPolicy.getDefaultComponent(Container aContainer)` 返回默认拥有焦点的 Component。
`Component`	`JTable.getEditorComponent()` 返回处理编辑会话的组件。
`Component`	`ComboBoxEditor.getEditorComponent()` 返回应该添加到此编辑器的树层次结构中的组件。
`Component`	`DefaultFocusManager.getFirstComponent(Container aContainer)`
`Component`	`LayoutFocusTraversalPolicy.getFirstComponent(Container aContainer)` 返回遍历循环中的第一个 Component。
`Component`	`SortingFocusTraversalPolicy.getFirstComponent(Container aContainer)` 返回遍历循环中的第一个 Component。
`Component`	`JInternalFrame.getFocusOwner()` 如果此 `JInternalFrame` 处于激活状态，则返回具有焦点的子组件。
`Component`	`JApplet.getGlassPane()` 返回此 applet 的 glassPane 对象。
`Component`	`JWindow.getGlassPane()` 返回此窗口的 `glassPane Component`。
`Component`	`JDialog.getGlassPane()` 返回此对话框的 `glassPane` 对象。
`Component`	`JInternalFrame.getGlassPane()` 返回此内部窗体的玻璃窗格。
`Component`	`JRootPane.getGlassPane()` 返回此 `JRootPane` 的当前玻璃窗格。
`Component`	`JFrame.getGlassPane()` 返回此窗体的 `glassPane` 对象。
`Component`	`RootPaneContainer.getGlassPane()` 返回 glassPane。
`Component`	`InternalFrameFocusTraversalPolicy.getInitialComponent(JInternalFrame frame)` 返回第一次选择 JInternalFrame 时应该接收焦点的 Component。
`Component`	`JPopupMenu.getInvoker()` 返回作为此弹出菜单的“调用者”的组件。
`Component`	`JLabel.getLabelFor()` 获取要添加标签的组件。
`Component`	`DefaultFocusManager.getLastComponent(Container aContainer)`
`Component`	`LayoutFocusTraversalPolicy.getLastComponent(Container aContainer)` 返回遍历循环中的最后一个 Component。
`Component`	`SortingFocusTraversalPolicy.getLastComponent(Container aContainer)` 返回遍历循环中的最后一个 Component。
`Component`	`JSplitPane.getLeftComponent()` 返回分隔条左边（或者上面）的组件。
`Component`	`DefaultListCellRenderer.getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus)`
`Component`	`ListCellRenderer.getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus)` 返回已配置用于显示指定值的组件。
`Component`	`JMenu.getMenuComponent(int n)` 返回位于位置 `n` 的组件。
`Component[]`	`JMenu.getMenuComponents()` 返回菜单子组件的 `Component` 数组。
`Component`	`JInternalFrame.getMostRecentFocusOwner()` 返回选定此 `JInternalFrame` 时，将接收焦点的 `JInternalFrame` 子组件。
`Component`	`JComponent.getNextFocusableComponent()` 已过时。从 1.4 版本开始，由 `FocusTraversalPolicy` 取代。
`Component`	`JSplitPane.getRightComponent()` 返回分隔条右边（或者下面）的组件。
`static Component`	`SwingUtilities.getRoot(Component c)` 返回当前组件树结构的根组件。
`Component`	`JTabbedPane.getSelectedComponent()` 返回此选项卡窗格当前选择的组件。
`Component`	`JTabbedPane.getTabComponentAt(int index)` 返回 `index` 位置上的选项卡组件。
`Component`	`DefaultCellEditor.getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column)` 实现 `TableCellEditor` 接口。
`Component`	`JSplitPane.getTopComponent()` 返回分隔条上面或者左边的组件。
`Component`	`DefaultCellEditor.getTreeCellEditorComponent(JTree tree, Object value, boolean isSelected, boolean expanded, boolean leaf, int row)` 实现 `TreeCellEditor` 接口。
`Component`	`JViewport.getView()` 返回 `JViewport` 的一个子对象或 `null`。
`Component`	`JTable.prepareEditor(TableCellEditor editor, int row, int column)` 通过查询 `row`、`column` 处单元格值的数据模型和单元格选择状态来准备编辑器。
`Component`	`JTable.prepareRenderer(TableCellRenderer renderer, int row, int column)` 通过查询 `row`、`column` 处单元格值的数据模型和单元格选择状态来准备渲染器。

返回变量类型为 Component 的类型的 javax.swing 中的方法
`protected Comparator<? super Component>`	`SortingFocusTraversalPolicy.getComparator()` 返回将用于对焦点遍历循环中的 Components 排序的 Comparator。
`protected Hashtable<Component,Integer>`	`JLayeredPane.getComponentToLayer()` 返回将组件映射到层的哈希表。

参数类型为 Component 的 javax.swing 中的方法
`protected boolean`	`LayoutFocusTraversalPolicy.accept(Component aComponent)` 确定是否可以接受选择指定的 `Component` 作为新的焦点所有者。
`protected boolean`	`SortingFocusTraversalPolicy.accept(Component aComponent)` 确定是否可以接受选择某个 Component 作为新的焦点拥有者。
`Component`	`JTabbedPane.add(Component component)` 添加一个 `component`，其选项卡的默认值为调用 `component.getName` 返回的组件的名称。
`Component`	`JMenu.add(Component c)` 将某个组件追加到此菜单的末尾。
`Component`	`JTabbedPane.add(Component component, int index)` 在指定的选项卡索引位置添加一个 `component`，默认的选项卡标题为组件名称。
`Component`	`JMenu.add(Component c, int index)` 将指定组件添加到此容器的给定位置上。
`void`	`JTabbedPane.add(Component component, Object constraints)` 将一个 `component` 添加到选项卡窗格中。
`void`	`JTabbedPane.add(Component component, Object constraints, int index)` 在指定的选项卡索引位置添加一个 `component`。
`Component`	`JTabbedPane.add(String title, Component component)` 添加具有指定选项卡标题的 `component`。
`GroupLayout.SequentialGroup`	`GroupLayout.SequentialGroup.addComponent(boolean useAsBaseline, Component component)` 将 `Component` 添加到此 `Group`。
`GroupLayout.SequentialGroup`	`GroupLayout.SequentialGroup.addComponent(boolean useAsBaseline, Component component, int min, int pref, int max)` 使用指定大小将 `Component` 添加到此 `Group`。
`GroupLayout.Group`	`GroupLayout.Group.addComponent(Component component)` 将 `Component` 添加到此 `Group`。
`GroupLayout.SequentialGroup`	`GroupLayout.SequentialGroup.addComponent(Component component)` 将 `Component` 添加到此 `Group`。
`GroupLayout.ParallelGroup`	`GroupLayout.ParallelGroup.addComponent(Component component)` 将 `Component` 添加到此 `Group`。
`GroupLayout.ParallelGroup`	`GroupLayout.ParallelGroup.addComponent(Component component, GroupLayout.Alignment alignment)` 使用指定的对齐方式将 `Component` 添加到此 `ParallelGroup`。
`GroupLayout.ParallelGroup`	`GroupLayout.ParallelGroup.addComponent(Component component, GroupLayout.Alignment alignment, int min, int pref, int max)` 使用指定的对齐方式和大小将 `Component` 添加到此 `ParallelGroup`。
`GroupLayout.Group`	`GroupLayout.Group.addComponent(Component component, int min, int pref, int max)` 使用指定大小将 `Component` 添加到此 `Group`。
`GroupLayout.SequentialGroup`	`GroupLayout.SequentialGroup.addComponent(Component component, int min, int pref, int max)` 使用指定大小将 `Component` 添加到此 `Group`。
`GroupLayout.ParallelGroup`	`GroupLayout.ParallelGroup.addComponent(Component component, int min, int pref, int max)` 使用指定大小将 `Component` 添加到此 `Group`。
`protected void`	`JDesktopPane.addImpl(Component comp, Object constraints, int index)` 将指定组件添加到此容器的指定索引所在的位置上。
`protected void`	`JApplet.addImpl(Component comp, Object constraints, int index)` 添加指定的子 `Component`。
`protected void`	`JWindow.addImpl(Component comp, Object constraints, int index)` 添加指定的子 `Component`。
`protected void`	`JViewport.addImpl(Component child, Object constraints, int index)` 设置 `JViewport` 的轻量子对象，可以为 `null`。
`protected void`	`CellRendererPane.addImpl(Component x, Object constraints, int index)` 如果指定组件已经是此组件的子组件，则不必再操心去做任何事，堆栈顺序对于单元格渲染器组件而言无关紧要（CellRendererPane 不管怎样都不进行绘制）。
`protected void`	`JSplitPane.addImpl(Component comp, Object constraints, int index)` 将指定组件添加到此分隔窗格。
`protected void`	`JToolBar.addImpl(Component comp, Object constraints, int index)` 在添加 `JButton` 时，它最初被设置为 disabled。
`protected void`	`JDialog.addImpl(Component comp, Object constraints, int index)` 添加指定的子 `Component`。
`protected void`	`AbstractButton.addImpl(Component comp, Object constraints, int index)` 将指定组件添加到此容器的指定索引所在的位置上，有关此方法的完整描述，请参阅 `Container.addImpl(Component, Object, int)`。
`protected void`	`JInternalFrame.addImpl(Component comp, Object constraints, int index)` 添加指定的子 `Component`。
`protected void`	`JLayeredPane.addImpl(Component comp, Object constraints, int index)`
`protected void`	`JRootPane.addImpl(Component comp, Object constraints, int index)` 重写以便将玻璃组件的位置强行设置成零位子级。
`protected void`	`JFrame.addImpl(Component comp, Object constraints, int index)` 添加指定的子 `Component`。
`void`	`GroupLayout.addLayoutComponent(Component component, Object constraints)` 已将 `Component` 添加到父容器的通知。
`void`	`OverlayLayout.addLayoutComponent(Component comp, Object constraints)` 使用指定的约束对象将指定组件添加到布局中。
`void`	`SpringLayout.addLayoutComponent(Component component, Object constraints)` 如果 `constraints` 是 `SpringLayout.Constraints` 的一个实例，则将该约束与指定组件相关联。
`void`	`BoxLayout.addLayoutComponent(Component comp, Object constraints)` 此类不使用。
`void`	`JRootPane.RootLayout.addLayoutComponent(Component comp, Object constraints)`
`void`	`GroupLayout.addLayoutComponent(String name, Component component)` 已将 `Component` 添加到父容器的通知。
`void`	`JSpinner.DefaultEditor.addLayoutComponent(String name, Component child)` 此 `LayoutManager` 方法不执行任何操作。
`void`	`OverlayLayout.addLayoutComponent(String name, Component comp)` 将指定的组件添加到布局中。
`void`	`SpringLayout.addLayoutComponent(String name, Component c)` 无效，因为此布局管理器不使用每组件字符串。
`void`	`ViewportLayout.addLayoutComponent(String name, Component c)` 将指定的组件添加到布局中。
`void`	`ScrollPaneLayout.addLayoutComponent(String s, Component c)` 将指定的组件添加到布局中。
`void`	`BoxLayout.addLayoutComponent(String name, Component comp)` 此类不使用。
`void`	`JRootPane.RootLayout.addLayoutComponent(String name, Component comp)`
`protected Component`	`ScrollPaneLayout.addSingletonComponent(Component oldC, Component newC)` 移除现有组件。
`void`	`JTabbedPane.addTab(String title, Component component)` 添加一个由 `title` 表示，且没有图标的 `component`。
`void`	`JTabbedPane.addTab(String title, Icon icon, Component component)` 添加一个由 `title` 和/或 `icon` 表示的 `component`，其任意一个都可以为 `null`。
`void`	`JTabbedPane.addTab(String title, Icon icon, Component component, String tip)` 添加由 `title` 和/或 `icon` 表示的 `component` 和 `tip`，其中任意一个都可以为 `null`。
`boolean`	`DefaultFocusManager.compareTabOrder(Component a, Component b)`
`Component`	`MenuSelectionManager.componentForPoint(Component source, Point sourcePoint)` 返回包含 sourcePoint 的当前选择路径的组件。
`static MouseEvent`	`SwingUtilities.convertMouseEvent(Component source, MouseEvent sourceEvent, Component destination)` 返回类似于 `sourceEvent` 的 MouseEvent，除了其 x 和 y 成员已转换到 `destination` 的坐标系统。
`static Point`	`SwingUtilities.convertPoint(Component source, int x, int y, Component destination)` 将 `source` 坐标系统中的点 `(x,y)` 转换到 `destination` 坐标系统。
`static Point`	`SwingUtilities.convertPoint(Component source, Point aPoint, Component destination)` 将 `source` 坐标系统中的 `aPoint` 转换到 `destination` 坐标系统。
`static void`	`SwingUtilities.convertPointFromScreen(Point p, Component c)` 将一个点从屏幕坐标转换到组件的坐标系统
`static void`	`SwingUtilities.convertPointToScreen(Point p, Component c)` 将一个点从组件的坐标系统转换到屏幕坐标。
`static Rectangle`	`SwingUtilities.convertRectangle(Component source, Rectangle aRectangle, Component destination)` 将 `source` 坐标系统中的矩形 `aRectangle` 转换到 `destination` 坐标系统。
`protected JDialog`	`JFileChooser.createDialog(Component parent)` 创建并返回包含 `this` 的新 `JDialog`，在 `parent` 窗体中的 `parent` 上居中。
`JDialog`	`JOptionPane.createDialog(Component parentComponent, String title)` 创建并返回一个新 `JDialog`，它在 `parentComponent` 窗体中的 `parentComponent` 中央包装 `this`。
`static JDialog`	`JColorChooser.createDialog(Component c, String title, boolean modal, JColorChooser chooserPane, ActionListener okListener, ActionListener cancelListener)` 创建并返回包含指定 `ColorChooser` 窗格及 "OK"、"Cancel" 和 "Reset" 按钮的新对话框。
`JInternalFrame`	`JOptionPane.createInternalFrame(Component parentComponent, String title)` 创建并返回 `JInternalFrame` 的实例。
`static RepaintManager`	`RepaintManager.currentManager(Component c)` 在给定 Component 的情况下，返回调用线程的 RepaintManager。
`static Component`	`SwingUtilities.findFocusOwner(Component c)` 已过时。从 1.4 开始，由 `KeyboardFocusManager.getFocusOwner()` 取代。
`static Accessible`	`SwingUtilities.getAccessibleAt(Component c, Point p)` 如果存在，则返回本地坐标 `Point` 处包含的 `Accessible` 子对象。
`static Accessible`	`SwingUtilities.getAccessibleChild(Component c, int i)` 返回对象的第 n 个可访问子对象。
`static int`	`SwingUtilities.getAccessibleChildrenCount(Component c)` 返回对象中可访问的子对象数。
`static int`	`SwingUtilities.getAccessibleIndexInParent(Component c)` 获取此对象在其可访问的父对象中的索引。
`static AccessibleStateSet`	`SwingUtilities.getAccessibleStateSet(Component c)` 获取此对象的状态。
`static Container`	`SwingUtilities.getAncestorNamed(String name, Component comp)` 在组件层次结构中搜索上面的 `comp` 的便捷方法，返回它找到的 `name` 第一个对象。
`static Container`	`SwingUtilities.getAncestorOfClass(Class<?> c, Component comp)` 在组件层次结构中搜索上面的 `comp` 的便捷方法，返回它找到的类 `c` 的第一个对象。
`Component`	`DefaultFocusManager.getComponentAfter(Container aContainer, Component aComponent)`
`Component`	`LayoutFocusTraversalPolicy.getComponentAfter(Container aContainer, Component aComponent)` 返回应在 aComponent 之后接收焦点的 Component。
`Component`	`SortingFocusTraversalPolicy.getComponentAfter(Container aContainer, Component aComponent)` 返回应该接收 aComponent 后面的焦点的 Component。
`Component`	`DefaultFocusManager.getComponentBefore(Container aContainer, Component aComponent)`
`Component`	`LayoutFocusTraversalPolicy.getComponentBefore(Container aContainer, Component aComponent)` 返回应在 aComponent 之前接收焦点的 Component。
`Component`	`SortingFocusTraversalPolicy.getComponentBefore(Container aContainer, Component aComponent)` 返回应该接收 aComponent 前面的焦点的 Component。
`int`	`JPopupMenu.getComponentIndex(Component c)` 返回指定组件的索引。
`int`	`JMenuBar.getComponentIndex(Component c)` 返回指定组件的索引。
`int`	`JToolBar.getComponentIndex(Component c)` 返回指定组件的索引。
`Spring`	`SpringLayout.getConstraint(String edgeName, Component c)` 返回控制该组件指定边及其父级的顶边或左边之间距离的 spring。
`SpringLayout.Constraints`	`SpringLayout.getConstraints(Component c)` 返回指定组件的约束。
`static Component`	`SwingUtilities.getDeepestComponentAt(Component parent, int x, int y)` 返回包含位置 `x`、`y` 的 `parent` 的最深可见后代组件。
`static JDesktopPane`	`JOptionPane.getDesktopPaneForComponent(Component parentComponent)` 返回指定组件的桌面窗格。
`static Frame`	`JOptionPane.getFrameForComponent(Component parentComponent)` 返回指定组件的 `Frame`。
`int`	`JLayeredPane.getIndexOf(Component c)` 返回指定 Component 的索引。
`int`	`JLayeredPane.getLayer(Component c)` 返回指定 Component 的 layer 属性。
`static JLayeredPane`	`JLayeredPane.getLayeredPaneAbove(Component c)` 一个便捷方法，它返回包含指定组件的第一个 JLayeredPane。
`static Rectangle`	`SwingUtilities.getLocalBounds(Component aComponent)` 返回组件 `aComponent` 的矩形 (0,0,bounds.width,bounds.height)。
`Image`	`RepaintManager.getOffscreenBuffer(Component c, int proposedWidth, int proposedHeight)` 返回屏幕外缓冲区，它应用作带有组件 `c` 的双缓冲区。
`Popup`	`PopupFactory.getPopup(Component owner, Component contents, int x, int y)` 为包含 Component `contents` 的 Component `owner` 创建 `Popup`。
`int`	`JLayeredPane.getPosition(Component c)` 获得该组件在其所在层中的相对位置。
`static Component`	`SwingUtilities.getRoot(Component c)` 返回当前组件树结构的根组件。
`static JRootPane`	`SwingUtilities.getRootPane(Component c)` 如果 c 是一个 JRootPane 后代，则返回其 JRootPane 祖先。
`Image`	`RepaintManager.getVolatileOffscreenBuffer(Component c, int proposedWidth, int proposedHeight)` 返回可变屏幕外缓冲区，它应用作带有指定组件 `c` 的双缓冲区。
`static Window`	`SwingUtilities.getWindowAncestor(Component c)` 返回 `c` 的第一个 `Window` 祖先；如果 `c` 未包含在 `Window` 内，则返回 `null`。
`static Spring`	`Spring.height(Component c)` 返回一个 spring，其 minimum、preferred、maximum 和 value 属性由所提供组件的 minimumSize、preferredSize、maximumSize 和 size 属性的高度定义。
`int`	`JTabbedPane.indexOfComponent(Component component)` 返回指定组件的选项卡索引。
`int`	`JTabbedPane.indexOfTabComponent(Component tabComponent)` 返回指定选项卡组件的选项卡索引。
`void`	`JPopupMenu.insert(Component component, int index)` 将指定组件插入到菜单的给定位置。
`void`	`JTextPane.insertComponent(Component c)` 将一个组件插入到文档中，以替换当前选择的内容。
`void`	`JTabbedPane.insertTab(String title, Icon icon, Component component, String tip, int index)` 在 `index` 位置插入一个 `component`，该组件通过 `title` 和/或 `icon`（任意一个都可以为 `null`）来表示。
`boolean`	`MenuSelectionManager.isComponentPartOfCurrentMenu(Component c)` 如果 c 是当前使用菜单的一部分，则返回 true
`static boolean`	`SwingUtilities.isDescendingFrom(Component a, Component b)` 如果组件 `a` 从组件 `b` 继承，则返回 `true`。
`static boolean`	`JComponent.isLightweightComponent(Component c)` 如果此组件是轻量的，也就是说，如果它没有本机窗口系统同位体，则返回 true。
`boolean`	`JMenu.isMenuComponent(Component c)` 如果在子菜单层次结构中存在指定的组件，则返回 true。
`void`	`GroupLayout.linkSize(Component... components)` 将指定组件强制调整为具有相同的大小，而不管其首选大小、最小大小或最大大小如何。
`void`	`GroupLayout.linkSize(int axis, Component... components)` 将指定组件强制调整为沿指定轴具有相同的大小，而不管其首选大小、最小大小或最大大小如何。
`void`	`JLayeredPane.moveToBack(Component c)` 将该组件移到当前层中所有组件的底层（位置 -1）。
`void`	`JLayeredPane.moveToFront(Component c)` 将该组件移到当前层中所有组件的顶层（位置 0）。
`void`	`CellRendererPane.paintComponent(Graphics g, Component c, Container p, int x, int y, int w, int h)` 调用 this.paintComponent(g, c, p, x, y, w, h, false)。
`static void`	`SwingUtilities.paintComponent(Graphics g, Component c, Container p, int x, int y, int w, int h)` 在指定的 `Graphics` 上绘制组件。
`void`	`CellRendererPane.paintComponent(Graphics g, Component c, Container p, int x, int y, int w, int h, boolean shouldValidate)` 在图形对象 g 上绘制一个单元格渲染器组件 c。
`void`	`CellRendererPane.paintComponent(Graphics g, Component c, Container p, Rectangle r)` 使用矩形的 x、y、width 和 height 字段的调用 this.paintComponent()。
`static void`	`SwingUtilities.paintComponent(Graphics g, Component c, Container p, Rectangle r)` 在指定的 `Graphics` 上绘制组件。
`void`	`ImageIcon.paintIcon(Component c, Graphics g, int x, int y)` 绘制图标。
`void`	`Icon.paintIcon(Component c, Graphics g, int x, int y)` 在指定位置上绘制图标。
`void`	`LookAndFeel.provideErrorFeedback(Component component)` 在用户尝试一个无效操作时调用，例如，在具有焦点的不可编辑的 `JTextField` 中进行粘贴。
`void`	`SpringLayout.putConstraint(String e1, Component c1, int pad, String e2, Component c2)` 将组件 `c1` 的边 `e1` 连接到组件 `c2` 的边 `e2`，边与边之间的距离固定。
`void`	`SpringLayout.putConstraint(String e1, Component c1, Spring s, String e2, Component c2)` 将组件 `c1` 的边 `e1` 连接到组件 `c2` 的边 `e2`。
`void`	`JApplet.remove(Component comp)` 从容器中移除指定的组件。
`void`	`JTabbedPane.remove(Component component)` 从 `JTabbedPane` 中移除指定 `Component`。
`void`	`JWindow.remove(Component comp)` 从该容器中移除指定组件。
`void`	`JViewport.remove(Component child)` 移除 `Viewport` 的一个轻量子对象。
`void`	`JSplitPane.remove(Component component)` 移除窗格中的子组件 `component`。
`void`	`JDialog.remove(Component comp)` 从该容器中移除指定组件。
`void`	`JMenu.remove(Component c)` 从此菜单移除组件 `c`。
`void`	`JInternalFrame.remove(Component comp)` 从此容器中移除指定组件。
`void`	`JFrame.remove(Component comp)` 从该容器中移除指定组件。
`void`	`GroupLayout.removeLayoutComponent(Component component)` 已从父容器中移除 `Component` 的通知。
`void`	`JSpinner.DefaultEditor.removeLayoutComponent(Component child)` 此 `LayoutManager` 方法不执行任何操作。
`void`	`OverlayLayout.removeLayoutComponent(Component comp)` 从布局移除指定组件。
`void`	`SpringLayout.removeLayoutComponent(Component c)` 移除与指定组件相关的约束。
`void`	`ViewportLayout.removeLayoutComponent(Component c)` 从布局中移除指定组件。
`void`	`ScrollPaneLayout.removeLayoutComponent(Component c)` 从布局中移除指定的组件。
`void`	`BoxLayout.removeLayoutComponent(Component comp)` 此类不使用。
`void`	`JRootPane.RootLayout.removeLayoutComponent(Component comp)`
`void`	`GroupLayout.replace(Component existingComponent, Component newComponent)` 使用新的组件替代现有组件。
`void`	`JSplitPane.setBottomComponent(Component comp)` 将组件设置到分隔条的下面或者右边。
`void`	`JScrollPane.setColumnHeaderView(Component view)` 创建一个列标题视口（如果有必要），设置其视图然后将此列标题视口添加到滚动窗格。
`void`	`JTabbedPane.setComponentAt(int index, Component component)` 将 `index` 位置的组件设置为 `component`。
`void`	`JDesktopPane.setComponentZOrder(Component comp, int index)` 将指定组件移动到容器中指定的 z 顺序索引。
`void`	`JScrollPane.setCorner(String key, Component corner)` 添加一个将显示在一个滚动窗格角中的子级，如果有空间的话。
`void`	`JApplet.setGlassPane(Component glassPane)` 设置 glassPane 属性。
`void`	`JWindow.setGlassPane(Component glassPane)` 设置 `glassPane` 属性。
`void`	`JDialog.setGlassPane(Component glassPane)` 设置 `glassPane` 属性。
`void`	`JInternalFrame.setGlassPane(Component glass)` 设置此 `JInternalFrame` 的 `glassPane` 属性。
`void`	`JRootPane.setGlassPane(Component glass)` 将指定的 `Component` 设置为此根窗格的玻璃窗格。
`void`	`JFrame.setGlassPane(Component glassPane)` 设置 `glassPane` 属性。
`void`	`RootPaneContainer.setGlassPane(Component glassPane)` glassPane 始终为 rootPane 的第一个子组件，rootPanes 布局管理器确保它始终与 rootPane 一样大。
`void`	`GroupLayout.setHonorsVisibility(Component component, Boolean honorsVisibility)` 设置确定组件的大小和位置时是否要考虑组件的可见性。
`void`	`JPopupMenu.setInvoker(Component invoker)` 设置此弹出菜单的调用者，即弹出菜单在其中显示的组件。
`void`	`JLabel.setLabelFor(Component c)` 设置要添加标签的组件。
`void`	`JLayeredPane.setLayer(Component c, int layer)` 设置指定组件的 layer 属性，使之成为该层中最底部的组件。
`void`	`JLayeredPane.setLayer(Component c, int layer, int position)` 为指定组件设置 layer 属性，并设置它在该层中的位置。
`void`	`JSplitPane.setLeftComponent(Component comp)` 将组件设置到分隔条的左边（或上面）。
`void`	`JComponent.setNextFocusableComponent(Component aComponent)` 已过时。从 1.4 版本开始，由 `FocusTraversalPolicy` 取代
`void`	`JLayeredPane.setPosition(Component c, int position)` 将该组件移到当前层中的 `position` 处，其中 0 表示该层中的最顶层位置，-1 表示最底层位置。
`void`	`JSplitPane.setRightComponent(Component comp)` 将组件设置到分隔条的右边（或者下面）。
`void`	`JScrollPane.setRowHeaderView(Component view)` 创建一个行标题视口（如果有必要），设置其视图然后将此行标题视口添加到滚动窗格。
`void`	`JPopupMenu.setSelected(Component sel)` 设置当前选择的组件，此方法将更改选择模型。
`void`	`JMenuBar.setSelected(Component sel)` 设置当前选择的组件，更改选择模型。
`void`	`JTabbedPane.setSelectedComponent(Component c)` 设置此选项卡窗格的已选组件。
`void`	`JTabbedPane.setTabComponentAt(int index, Component component)` 设置负责呈现指定选项卡标题的组件。
`void`	`JSplitPane.setTopComponent(Component comp)` 将组件设置到分隔条的上面或者左边。
`void`	`JViewport.setView(Component view)` 设置 `JViewport` 的一个轻量子对象 (`view`)，可以为 `null`。
`void`	`JScrollPane.setViewportView(Component view)` 创建一个视口（如果有必要）并设置其视图。
`void`	`JPopupMenu.show(Component invoker, int x, int y)` 在组件调用者的坐标空间中的位置 X、Y 显示弹出菜单。
`static int`	`JOptionPane.showConfirmDialog(Component parentComponent, Object message)` 调出带有选项 Yes、No 和 Cancel 的对话框；标题为 Select an Option。
`static int`	`JOptionPane.showConfirmDialog(Component parentComponent, Object message, String title, int optionType)` 调出一个由 `optionType` 参数确定其中选项数的对话框。
`static int`	`JOptionPane.showConfirmDialog(Component parentComponent, Object message, String title, int optionType, int messageType)` 调用一个由 `optionType` 参数确定其中选项数的对话框，`messageType` 参数确定要显示的图标。
`static int`	`JOptionPane.showConfirmDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon icon)` 调出一个带有指定图标的对话框，其中的选项数由 `optionType` 参数确定。
`int`	`JFileChooser.showDialog(Component parent, String approveButtonText)` 弹出具有自定义 approve 按钮的自定义文件选择器对话框。
`static Color`	`JColorChooser.showDialog(Component component, String title, Color initialColor)` 显示有模式的颜色选取器，在隐藏对话框之前一直阻塞。
`static String`	`JOptionPane.showInputDialog(Component parentComponent, Object message)` 显示请求用户输入内容的问题消息对话框，它以 `parentComponent` 为父级。
`static String`	`JOptionPane.showInputDialog(Component parentComponent, Object message, Object initialSelectionValue)` 显示请求用户输入内容的问题消息对话框，它以 `parentComponent` 为父级。
`static String`	`JOptionPane.showInputDialog(Component parentComponent, Object message, String title, int messageType)` 显示请求用户输入内容的对话框，它以 `parentComponent` 为父级，该对话框的标题为 `title`，消息类型为 `messageType`。
`static Object`	`JOptionPane.showInputDialog(Component parentComponent, Object message, String title, int messageType, Icon icon, Object[] selectionValues, Object initialSelectionValue)` 提示用户在可以指定初始选择、可能选择及其他所有选项的模块化的对话框中输入内容。
`static int`	`JOptionPane.showInternalConfirmDialog(Component parentComponent, Object message)` 调出带有选项 Yes、No 和 Cancel 的内部对话框面板；标题为 Select an Option。
`static int`	`JOptionPane.showInternalConfirmDialog(Component parentComponent, Object message, String title, int optionType)` 调出一个由 `optionType` 参数确定其中选项数的内部对话框面板。
`static int`	`JOptionPane.showInternalConfirmDialog(Component parentComponent, Object message, String title, int optionType, int messageType)` 调出一个由 `optionType` 参数确定其中选项数的内部对话框面板，`messageType` 参数确定要显示的图标。
`static int`	`JOptionPane.showInternalConfirmDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon icon)` 调出一个带有指定图标的内部对话框面板，其中的选项数由 `optionType` 参数确定。
`static String`	`JOptionPane.showInternalInputDialog(Component parentComponent, Object message)` 显示请求用户输入内容的内部问题消息对话框，它以 `parentComponent` 为父级。
`static String`	`JOptionPane.showInternalInputDialog(Component parentComponent, Object message, String title, int messageType)` 显示请求用户输入内容的内部对话框，它以 `parentComponent` 为父级。
`static Object`	`JOptionPane.showInternalInputDialog(Component parentComponent, Object message, String title, int messageType, Icon icon, Object[] selectionValues, Object initialSelectionValue)` 提示用户在可以指定初始选择、可能选择及其他所有选项的模块化的内部对话框中输入内容。
`static void`	`JOptionPane.showInternalMessageDialog(Component parentComponent, Object message)` 调出内部确认对话框面板。
`static void`	`JOptionPane.showInternalMessageDialog(Component parentComponent, Object message, String title, int messageType)` 调出一个显示消息的内部对话框面板，它使用由 `messageType` 参数确定的默认图标。
`static void`	`JOptionPane.showInternalMessageDialog(Component parentComponent, Object message, String title, int messageType, Icon icon)` 调出一个显示消息的内部对话框面板，为其指定了所有参数。
`static int`	`JOptionPane.showInternalOptionDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon icon, Object[] options, Object initialValue)` 调出一个带有指定图标的内部对话框面板，其中的初始选择由 `initialValue` 参数确定，选项数由 `optionType` 参数确定。
`static void`	`JOptionPane.showMessageDialog(Component parentComponent, Object message)` 调出标题为 "Message" 的信息消息对话框。
`static void`	`JOptionPane.showMessageDialog(Component parentComponent, Object message, String title, int messageType)` 调出对话框，它显示使用由 `messageType` 参数确定的默认图标的 message。
`static void`	`JOptionPane.showMessageDialog(Component parentComponent, Object message, String title, int messageType, Icon icon)` 调出一个显示信息的对话框，为其指定了所有参数。
`int`	`JFileChooser.showOpenDialog(Component parent)` 弹出一个 "Open File" 文件选择器对话框。
`static int`	`JOptionPane.showOptionDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon icon, Object[] options, Object initialValue)` 调出一个带有指定图标的对话框，其中的初始选择由 `initialValue` 参数确定，选项数由 `optionType` 参数确定。
`int`	`JFileChooser.showSaveDialog(Component parent)` 弹出一个 "Save File" 文件选择器对话框。
`static void`	`SwingUtilities.updateComponentTreeUI(Component c)` 简单的外观更改：将树结构中的每个节点转到 `updateUI()` -- 也就是说，通过当前外观初始化其 UI 属性。
`static Spring`	`Spring.width(Component c)` 返回一个 spring，其 minimum、preferred、maximum 和 value 属性由所提供组件的 minimumSize、preferredSize、maximumSize 和 size 属性的宽度定义。
`static Window`	`SwingUtilities.windowForComponent(Component c)` 返回 `c` 的第一个 `Window` 祖先；如果 `c` 未包含在 `Window` 内，则返回 `null`。

类型变量类型为 Component 的 javax.swing 中的方法参数
`protected void`	`SortingFocusTraversalPolicy.setComparator(Comparator<? super Component> comparator)` 设置将用于对焦点遍历循环中的 Components 排序的 Comparator。

参数类型为 Component 的 javax.swing 中的构造方法
`JScrollPane(Component view)` 创建一个显示指定组件内容的 `JScrollPane`，只要组件的内容超过视图大小就会显示水平和垂直滚动条。
`JScrollPane(Component view, int vsbPolicy, int hsbPolicy)` 创建一个 `JScrollPane`，它将视图组件显示在一个视口中，视图位置可使用一对滚动条控制。
`JSplitPane(int newOrientation, boolean newContinuousLayout, Component newLeftComponent, Component newRightComponent)` 创建一个具有指定方向、重绘方式和指定组件的新 `JSplitPane`。
`JSplitPane(int newOrientation, Component newLeftComponent, Component newRightComponent)` 创建一个具有指定方向和不连续重绘的指定组件的新 `JSplitPane`。
`Popup(Component owner, Component contents, int x, int y)` 为包含 Component `content` 的 Component `owner` 创建 `Popup`。
`ProgressMonitor(Component parentComponent, Object message, String note, int min, int max)` 构造一个图形对象，它一般会根据进程的完成情况通过填充矩形条来显示进度。
`ProgressMonitorInputStream(Component parentComponent, Object message, InputStream in)` 构造一个对象，以监视输入流的进度。
`SpringLayout.Constraints(Component c)` 创建组件 `c` 的合适 `x`、`y`、`width` 和 `height` spring 的 `Constraints` 对象。
`TransferHandler.TransferSupport(Component component, Transferable transferable)` 使用给定组件和 `Transferable` 创建一个 `TransferSupport`，对于该 `TransferSupport` `isDrop()` 返回 `false`。

类型变量类型为 Component 的 javax.swing 中的构造方法参数
`SortingFocusTraversalPolicy(Comparator<? super Component> comparator)` 构造具有指定 Comparator 的 SortingFocusTraversalPolicy。

javax.swing.border 中 Component 的使用

参数类型为 Component 的 javax.swing.border 中的方法
`int`	`TitledBorder.getBaseline(Component c, int width, int height)` 返回基线。
`int`	`AbstractBorder.getBaseline(Component c, int width, int height)` 返回基线。
`Component.BaselineResizeBehavior`	`TitledBorder.getBaselineResizeBehavior(Component c)` 返回一个枚举，指示该边框的基线如何随大小的改变而发生更改。
`Component.BaselineResizeBehavior`	`AbstractBorder.getBaselineResizeBehavior(Component c)` 返回一个枚举，指示组件的基线如何随大小的改变而发生更改。
`Insets`	`SoftBevelBorder.getBorderInsets(Component c)` 返回边框的 insets。
`Insets`	`TitledBorder.getBorderInsets(Component c)` 返回边框的 insets。
`Insets`	`BevelBorder.getBorderInsets(Component c)` 返回边框的 insets。
`Insets`	`EtchedBorder.getBorderInsets(Component c)` 返回边框的 insets
`Insets`	`LineBorder.getBorderInsets(Component c)` 返回边框的 insets。
`Insets`	`MatteBorder.getBorderInsets(Component c)` 返回边框的 insets。
`Insets`	`CompoundBorder.getBorderInsets(Component c)` 返回复合边框的 insets，它是外部边框的 insets 与内部边框的 insets 相加所得的结果。
`Insets`	`EmptyBorder.getBorderInsets(Component c)` 返回此边框的 insets
`Insets`	`AbstractBorder.getBorderInsets(Component c)` 此默认实现返回一个新的 `Insets` 实例，其中 `top`、`left`、`bottom` 和 `right` 字段都设置成了 `0`。
`Insets`	`Border.getBorderInsets(Component c)` 返回该边框的 insets。
`Insets`	`SoftBevelBorder.getBorderInsets(Component c, Insets insets)` 用此边框的当前 Insets 重新初始化 insets 参数。
`Insets`	`TitledBorder.getBorderInsets(Component c, Insets insets)` 用此边框的当前 Insets 重新初始化 insets 参数。
`Insets`	`BevelBorder.getBorderInsets(Component c, Insets insets)` 用此边框的当前 Insets 重新初始化 insets 参数。
`Insets`	`EtchedBorder.getBorderInsets(Component c, Insets insets)` 用此边框的当前 Insets 重新初始化 insets 参数
`Insets`	`LineBorder.getBorderInsets(Component c, Insets insets)` 用此边框的当前 Insets 重新初始化 insets 参数。
`Insets`	`MatteBorder.getBorderInsets(Component c, Insets insets)` 用此边框的当前 Insets 重新初始化 insets 参数。
`Insets`	`CompoundBorder.getBorderInsets(Component c, Insets insets)` 用此边框的当前 Insets 重新初始化 insets 参数。
`Insets`	`EmptyBorder.getBorderInsets(Component c, Insets insets)` 用此边框的当前 Insets 重新初始化 insets 参数
`Insets`	`AbstractBorder.getBorderInsets(Component c, Insets insets)` 用此边框的当前 Insets 重新初始化 insets 参数。
`protected Font`	`TitledBorder.getFont(Component c)`
`Color`	`EtchedBorder.getHighlightColor(Component c)` 返回浮雕化边框在指定组件上呈现的高亮显示颜色。
`Color`	`BevelBorder.getHighlightInnerColor(Component c)` 返回斜面边框在指定组件上呈现的内部高亮显示颜色。
`Color`	`BevelBorder.getHighlightOuterColor(Component c)` 返回斜面边框在指定组件上呈现的外部高亮显示颜色。
`static Rectangle`	`AbstractBorder.getInteriorRectangle(Component c, Border b, int x, int y, int width, int height)` 返回一个用所给的参数减去边框 insets 得到的矩形。
`Rectangle`	`AbstractBorder.getInteriorRectangle(Component c, int x, int y, int width, int height)` 此便捷方法调用静态方法。
`Dimension`	`TitledBorder.getMinimumSize(Component c)` 返回此边框完全显示边框和标题所需的最小大小。
`Color`	`EtchedBorder.getShadowColor(Component c)` 返回浮雕化边框在指定组件上呈现的阴影颜色。
`Color`	`BevelBorder.getShadowInnerColor(Component c)` 返回斜面边框在指定组件上呈现的内部阴影颜色。
`Color`	`BevelBorder.getShadowOuterColor(Component c)` 返回斜面边框在指定组件上呈现的外部阴影颜色。
`void`	`SoftBevelBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)` 按照指定的位置和尺寸绘制指定组件的边框。
`void`	`TitledBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)` 按照指定的位置和大小为指定的组件绘制边框。
`void`	`BevelBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)` 按指定的位置和尺寸绘制指定组件的边框。
`void`	`EtchedBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)` 按照指定的位置和尺寸为指定的组件绘制边框
`void`	`LineBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)` 按照指定的位置和尺寸为指定的组件绘制边框。
`void`	`MatteBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)` 绘制衬边边框。
`void`	`CompoundBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)` 绘制组合边框，方法是先按指定的位置和尺寸绘制外部边框，然后按照外部边框 insets 指定的位置和尺寸偏移量绘制内部边框。
`void`	`EmptyBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)` 默认情况下不执行绘制。
`void`	`AbstractBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)` 此默认实现不执行绘制操作。
`void`	`Border.paintBorder(Component c, Graphics g, int x, int y, int width, int height)` 按指定的位置和尺寸绘制指定组件的边框。
`protected void`	`BevelBorder.paintLoweredBevel(Component c, Graphics g, int x, int y, int width, int height)`
`protected void`	`BevelBorder.paintRaisedBevel(Component c, Graphics g, int x, int y, int width, int height)`

javax.swing.colorchooser 中 Component 的使用

javax.swing.colorchooser 中 Component 的子类
`class`	`AbstractColorChooserPanel` 这是用于颜色选取器的抽象超类。

javax.swing.event 中 Component 的使用

参数类型为 Component 的 javax.swing.event 中的构造方法
`MenuDragMouseEvent(Component source, int id, long when, int modifiers, int x, int y, int clickCount, boolean popupTrigger, MenuElement[] p, MenuSelectionManager m)` 构造一个 MenuDragMouseEvent 对象。
`MenuDragMouseEvent(Component source, int id, long when, int modifiers, int x, int y, int xAbs, int yAbs, int clickCount, boolean popupTrigger, MenuElement[] p, MenuSelectionManager m)` 构造一个 MenuDragMouseEvent 对象。
`MenuKeyEvent(Component source, int id, long when, int modifiers, int keyCode, char keyChar, MenuElement[] p, MenuSelectionManager m)` 构造一个 MenuKeyEvent 对象。

javax.swing.plaf 中 Component 的使用

参数类型为 Component 的 javax.swing.plaf 中的方法
`Insets`	`BorderUIResource.getBorderInsets(Component c)`
`void`	`BorderUIResource.paintBorder(Component c, Graphics g, int x, int y, int width, int height)`
`void`	`IconUIResource.paintIcon(Component c, Graphics g, int x, int y)`

javax.swing.plaf.basic 中 Component 的使用

javax.swing.plaf.basic 中 Component 的子类
`class`	`BasicArrowButton` 一个 JButton 对象，它绘制朝某个基本方向的缩放箭头。
`class`	`BasicComboBoxRenderer` ComboBox 渲染器警告：此类的序列化对象将与以后的 Swing 版本不兼容。
`static class`	`BasicComboBoxRenderer.UIResource` 实现 UIResource 的 BasicComboBoxRenderer 的子类。
`class`	`BasicComboPopup` 此为 `ComboPopup` 接口的基本实现。
`class`	`BasicInternalFrameTitlePane` 管理基本标题栏的类警告：此类的序列化对象将与以后的 Swing 版本不兼容。
`class`	`BasicInternalFrameTitlePane.SystemMenuBar` 此类应视为“受保护”内部类。
`class`	`BasicSplitPaneDivider` BasicSplitPaneUI 使用的分隔符。
`protected class`	`BasicToolBarUI.DragWindow`

声明为 Component 的 javax.swing.plaf.basic 中的字段
`protected Component[]`	`BasicSplitPaneUI.BasicHorizontalLayoutManager.components`
`protected Component`	`BasicTreeUI.MouseInputHandler.destination` 接收所有事件的目的地。
`protected Component`	`BasicTreeUI.editingComponent` 编辑时，它将是进行实际编辑的 Component。
`protected Component`	`BasicComboBoxUI.editor`
`protected Component`	`BasicSplitPaneDivider.hiddenDivider` 用于非连续布局模式的分隔符。
`protected Component`	`BasicOptionPaneUI.initialFocusComponent` 利用 selectInitialValue 传递消息时接收焦点的组件。
`protected Component`	`BasicSplitPaneUI.nonContinuousLayoutDivider` 使用非连续布局时分隔符阴影的实例。
`protected Component`	`BasicTreeUI.MouseInputHandler.source` 发起事件的源。
`Component`	`BasicMenuUI.ChangeHandler.wasFocused`

返回 Component 的 javax.swing.plaf.basic 中的方法
`protected Component`	`BasicSplitPaneUI.createDefaultNonContinuousLayoutDivider()` 返回默认的非连续布局分隔符，该分隔符是使用深灰色填充背景的 Canvas 的实例。
`protected Component`	`BasicSpinnerUI.createNextButton()` 创建将用 `spinner.getNextValue` 返回的对象取代 spinner 模型值的组件。
`protected Component`	`BasicSpinnerUI.createPreviousButton()` 创建将用 `spinner.getPreviousValue` 返回的对象取代 spinner 模型值的组件。
`Component`	`BasicComboBoxEditor.getEditorComponent()`
`protected Component`	`BasicSliderUI.getHighestValueLabel()` 返回与标签表中的最低滑块值相对应的标签。
`Component`	`BasicComboBoxRenderer.getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus)`
`protected Component`	`BasicSliderUI.getLowestValueLabel()` 返回与标签表中的最高滑块值相对应的标签。
`Component`	`BasicSplitPaneUI.getNonContinuousLayoutDivider()` 返回要在将 splitPane 配置为非连续布局时使用的分隔符。
`protected Component`	`BasicTabbedPaneUI.getVisibleComponent()`

参数类型为 Component 的 javax.swing.plaf.basic 中的方法
`void`	`BasicSplitPaneUI.BasicHorizontalLayoutManager.addLayoutComponent(Component comp, Object constraints)` 使用指定的约束对象将指定组件添加到布局中。
`void`	`BasicInternalFrameTitlePane.TitlePaneLayout.addLayoutComponent(String name, Component c)`
`void`	`BasicInternalFrameUI.InternalFrameLayout.addLayoutComponent(String name, Component c)`
`void`	`BasicOptionPaneUI.ButtonAreaLayout.addLayoutComponent(String string, Component comp)`
`void`	`BasicSplitPaneDivider.DividerLayout.addLayoutComponent(String string, Component c)`
`void`	`BasicSplitPaneUI.BasicHorizontalLayoutManager.addLayoutComponent(String place, Component component)` 在 place 位置添加组件。
`void`	`BasicTabbedPaneUI.TabbedPaneLayout.addLayoutComponent(String name, Component comp)`
`void`	`BasicComboBoxUI.ComboBoxLayoutManager.addLayoutComponent(String name, Component comp)`
`void`	`BasicScrollBarUI.addLayoutComponent(String name, Component child)`
`boolean`	`BasicToolBarUI.canDock(Component c, Point p)`
`protected void`	`BasicTreeUI.drawCentered(Component c, Graphics graphics, Icon icon, int x, int y)`
`Insets`	`BasicBorders.ButtonBorder.getBorderInsets(Component c)`
`Insets`	`BasicBorders.ToggleButtonBorder.getBorderInsets(Component c)`
`Insets`	`BasicBorders.RadioButtonBorder.getBorderInsets(Component c)`
`Insets`	`BasicBorders.MenuBarBorder.getBorderInsets(Component c)`
`Insets`	`BasicBorders.MarginBorder.getBorderInsets(Component c)`
`Insets`	`BasicBorders.FieldBorder.getBorderInsets(Component c)`
`Insets`	`BasicBorders.SplitPaneBorder.getBorderInsets(Component c)`
`Insets`	`BasicBorders.ButtonBorder.getBorderInsets(Component c, Insets insets)`
`Insets`	`BasicBorders.ToggleButtonBorder.getBorderInsets(Component c, Insets insets)`
`Insets`	`BasicBorders.RadioButtonBorder.getBorderInsets(Component c, Insets insets)`
`Insets`	`BasicBorders.MenuBarBorder.getBorderInsets(Component c, Insets insets)`
`Insets`	`BasicBorders.MarginBorder.getBorderInsets(Component c, Insets insets)`
`Insets`	`BasicBorders.FieldBorder.getBorderInsets(Component c, Insets insets)`
`protected int`	`BasicSplitPaneUI.BasicHorizontalLayoutManager.getPreferredSizeOfComponent(Component c)` 返回传入 Component 的首选大小的宽度。
`protected int`	`BasicSplitPaneUI.BasicHorizontalLayoutManager.getSizeOfComponent(Component c)` 返回传入组件的宽度。
`protected void`	`BasicSpinnerUI.installNextButtonListeners(Component c)` 在下一个按钮（`c`）上安装必要的侦听器以更新 `JSpinner` 来响应用户动作。
`protected void`	`BasicSpinnerUI.installPreviousButtonListeners(Component c)` 在上一个按钮（`c`）上安装必要的侦听器以更新 `JSpinner` 来响应用户动作。
`void`	`BasicBorders.RolloverButtonBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`BasicBorders.ButtonBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)`
`void`	`BasicBorders.ToggleButtonBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)`
`void`	`BasicBorders.RadioButtonBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)`
`void`	`BasicBorders.MenuBarBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)`
`void`	`BasicBorders.FieldBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)`
`void`	`BasicBorders.SplitPaneBorder.paintBorder(Component c, Graphics g, int x, int y, int width, int height)`
`protected void`	`BasicSliderUI.paintHorizontalLabel(Graphics g, int value, Component label)` 为标签表中的每个标签调用此方法。
`protected void`	`BasicSliderUI.paintVerticalLabel(Graphics g, int value, Component label)` 为标签表中的每个标签调用此方法。
`void`	`BasicInternalFrameTitlePane.TitlePaneLayout.removeLayoutComponent(Component c)`
`void`	`BasicInternalFrameUI.InternalFrameLayout.removeLayoutComponent(Component c)`
`void`	`BasicOptionPaneUI.ButtonAreaLayout.removeLayoutComponent(Component c)`
`void`	`BasicSplitPaneDivider.DividerLayout.removeLayoutComponent(Component c)`
`void`	`BasicSplitPaneUI.BasicHorizontalLayoutManager.removeLayoutComponent(Component component)` 根据了解的情况移除指定的组件。
`void`	`BasicTabbedPaneUI.TabbedPaneLayout.removeLayoutComponent(Component comp)`
`void`	`BasicComboBoxUI.ComboBoxLayoutManager.removeLayoutComponent(Component comp)`
`void`	`BasicScrollBarUI.removeLayoutComponent(Component child)`
`protected void`	`BasicToolBarUI.setBorderToNonRollover(Component c)` 将组件的边框设置为具有由 `createNonRolloverBorder` 创建的翻转边框。
`protected void`	`BasicToolBarUI.setBorderToNormal(Component c)` 将组件的边框设置为具有普通边框。
`protected void`	`BasicToolBarUI.setBorderToRollover(Component c)` 将组件的边框设置为具有由 `createRolloverBorder` 创建的翻转边框。
`protected void`	`BasicSplitPaneUI.BasicHorizontalLayoutManager.setComponentToSize(Component c, int size, int location, Insets insets, Dimension containerSize)` 将组件 c 的宽度设置为 size（将其 x 的位置放置到 location），将 y 和高度分别设置为 insets.top 和 containersize.height 减去上下 insets。
`protected void`	`BasicSplitPaneUI.setNonContinuousLayoutDivider(Component newDivider)` 设置要在将 splitPane 配置为非连续布局时使用的分隔符。
`protected void`	`BasicSplitPaneUI.setNonContinuousLayoutDivider(Component newDivider, boolean rememberSizes)` 设置要使用的分隔符。
`protected void`	`BasicTabbedPaneUI.setVisibleComponent(Component component)`

参数类型为 Component 的 javax.swing.plaf.basic 中的构造方法
`BasicTreeUI.MouseInputHandler(Component source, Component destination, MouseEvent event)`

javax.swing.plaf.metal 中 Component 的使用

javax.swing.plaf.metal 中 Component 的子类
`class`	`MetalComboBoxButton` 协助 MetalComboBoxUI 的 JButton 子类警告：此类的已序列化对象与以后的 Swing 版本不兼容。
`class`	`MetalComboBoxUI.MetalComboPopup` 已过时。从 Java 2 platform v1.4 开始。
`protected class`	`MetalFileChooserUI.FileRenderer`
`class`	`MetalFileChooserUI.FilterComboBoxRenderer` 呈现不同的类型大小和风格。
`class`	`MetalInternalFrameTitlePane` 管理 JLF 标题栏的类
`class`	`MetalScrollButton` Metal 滚动条箭头的 JButton 对象。

返回 Component 的 javax.swing.plaf.metal 中的方法
`Component`	`MetalFileChooserUI.FilterComboBoxRenderer.getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus)`

参数类型为 Component 的 javax.swing.plaf.metal 中的方法
`protected void`	`MetalCheckBoxIcon.drawCheck(Component c, Graphics g, int x, int y)`
`Insets`	`MetalBorders.Flush3DBorder.getBorderInsets(Component c)`
`Insets`	`MetalBorders.ButtonBorder.getBorderInsets(Component c)`
`Insets`	`MetalBorders.InternalFrameBorder.getBorderInsets(Component c)`
`Insets`	`MetalBorders.PaletteBorder.getBorderInsets(Component c)`
`Insets`	`MetalBorders.OptionDialogBorder.getBorderInsets(Component c)`
`Insets`	`MetalBorders.MenuBarBorder.getBorderInsets(Component c)`
`Insets`	`MetalBorders.MenuItemBorder.getBorderInsets(Component c)`
`Insets`	`MetalBorders.PopupMenuBorder.getBorderInsets(Component c)`
`Insets`	`MetalBorders.ToolBarBorder.getBorderInsets(Component c)`
`Insets`	`MetalBorders.ScrollPaneBorder.getBorderInsets(Component c)`
`Insets`	`MetalBorders.TableHeaderBorder.getBorderInsets(Component c)`
`Insets`	`MetalBorders.Flush3DBorder.getBorderInsets(Component c, Insets newInsets)`
`Insets`	`MetalBorders.ButtonBorder.getBorderInsets(Component c, Insets newInsets)`
`Insets`	`MetalBorders.InternalFrameBorder.getBorderInsets(Component c, Insets newInsets)`
`Insets`	`MetalBorders.PaletteBorder.getBorderInsets(Component c, Insets newInsets)`
`Insets`	`MetalBorders.OptionDialogBorder.getBorderInsets(Component c, Insets newInsets)`
`Insets`	`MetalBorders.MenuBarBorder.getBorderInsets(Component c, Insets newInsets)`
`Insets`	`MetalBorders.MenuItemBorder.getBorderInsets(Component c, Insets newInsets)`
`Insets`	`MetalBorders.PopupMenuBorder.getBorderInsets(Component c, Insets newInsets)`
`Insets`	`MetalBorders.ToolBarBorder.getBorderInsets(Component c, Insets newInsets)`
`void`	`MetalBorders.Flush3DBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.ButtonBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.InternalFrameBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.PaletteBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.OptionDialogBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.MenuBarBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.MenuItemBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.PopupMenuBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.RolloverButtonBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.ToolBarBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.TextFieldBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.ScrollPaneBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.ToggleButtonBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalBorders.TableHeaderBorder.paintBorder(Component c, Graphics g, int x, int y, int w, int h)`
`void`	`MetalCheckBoxIcon.paintIcon(Component c, Graphics g, int x, int y)`
`void`	`MetalComboBoxIcon.paintIcon(Component c, Graphics g, int x, int y)` 绘制 MetalComboBox 的水平条
`void`	`MetalIconFactory.PaletteCloseIcon.paintIcon(Component c, Graphics g, int x, int y)`
`void`	`MetalIconFactory.FolderIcon16.paintIcon(Component c, Graphics g, int x, int y)`
`void`	`MetalIconFactory.FileIcon16.paintIcon(Component c, Graphics g, int x, int y)`
`void`	`MetalIconFactory.TreeControlIcon.paintIcon(Component c, Graphics g, int x, int y)`
`void`	`MetalIconFactory.TreeControlIcon.paintMe(Component c, Graphics g, int x, int y)`
`void`	`MetalLookAndFeel.provideErrorFeedback(Component component)` 在用户尝试一个无效操作时调用，例如，在具有焦点的不可编辑的 `JTextField` 中进行粘贴。
`protected void`	`MetalToolBarUI.setBorderToNonRollover(Component c)`

javax.swing.plaf.synth 中 Component 的使用

参数类型为 Component 的 javax.swing.plaf.synth 中的方法
`static void`	`SynthLookAndFeel.updateStyles(Component c)` 更新与 `c` 关联的样式以及其所有子样式。

javax.swing.table 中 Component 的使用

javax.swing.table 中 Component 的子类
`class`	`DefaultTableCellRenderer` 呈现（显示） `JTable` 中每个单元格的标准类。
`static class`	`DefaultTableCellRenderer.UIResource` `DefaultTableCellRenderer` 的一个子类，它实现 `UIResource`。
`class`	`JTableHeader` 这是管理 `JTable` 的头的对象。

返回 Component 的 javax.swing.table 中的方法
`Component`	`TableCellEditor.getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column)` 为编辑器设置初始 `value`。
`Component`	`DefaultTableCellRenderer.getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column)` 返回默认的表单元格渲染器。
`Component`	`TableCellRenderer.getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column)` 返回用于绘制单元格的组件。

javax.swing.text 中 Component 的使用

javax.swing.text 中 Component 的子类
`class`	`JTextComponent` `JTextComponent` 是 swing 文本组件的基类。

返回 Component 的 javax.swing.text 中的方法
`protected Component`	`ComponentView.createComponent()` 创建与此视图关联的组件。
`Component`	`ComponentView.getComponent()` 获取与此视图关联的组件。
`static Component`	`StyleConstants.getComponent(AttributeSet a)` 从属性列表中获取组件设置。

参数类型为 Component 的 javax.swing.text 中的方法
`protected void`	`PlainView.damageLineRange(int line0, int line1, Shape a, Component host)` 重新绘制给定的行范围。
`static void`	`StyleConstants.setComponent(MutableAttributeSet a, Component c)` 设置组件属性。

javax.swing.text.html 中 Component 的使用

返回 Component 的 javax.swing.text.html 中的方法
`protected Component`	`FormView.createComponent()` 创建组件。
`protected Component`	`ObjectView.createComponent()` 创建组件。

javax.swing.tree 中 Component 的使用

javax.swing.tree 中 Component 的子类
`class`	`DefaultTreeCellEditor.DefaultTextField` 不提供任何编辑器时所使用的 `TextField`。
`class`	`DefaultTreeCellEditor.EditorContainer` 负责存放 `editingComponent` 的容器。
`class`	`DefaultTreeCellRenderer` 显示树中的条目。

声明为 Component 的 javax.swing.tree 中的字段
`protected Component`	`DefaultTreeCellEditor.editingComponent` 用于编辑的组件，从 `editingContainer` 获取。

返回 Component 的 javax.swing.tree 中的方法
`Component`	`DefaultTreeCellEditor.getTreeCellEditorComponent(JTree tree, Object value, boolean isSelected, boolean expanded, boolean leaf, int row)` 配置编辑器。
`Component`	`TreeCellEditor.getTreeCellEditorComponent(JTree tree, Object value, boolean isSelected, boolean expanded, boolean leaf, int row)` 设置编辑器的初始值。
`Component`	`DefaultTreeCellRenderer.getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus)` 配置基于传入组件的渲染器。
`Component`	`TreeCellRenderer.getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus)` 将当前树单元格的值设置为 `value`。

概述