模块  java.desktop
软件包  javax.swing

Class JComponent

    • 字段详细信息

      • ui

        protected transient ComponentUI ui
        此组件的外观委托。

      • listenerList

        protected EventListenerList listenerList
        此组件的事件侦听器列表。

      • WHEN_FOCUSED

        public static final int WHEN_FOCUSED
        用于 registerKeyboardAction常量，表示当组件具有焦点时应调用该命令。
        另请参见：
        常数字段值

      • WHEN_ANCESTOR_OF_FOCUSED_COMPONENT

        public static final int WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
        用于 registerKeyboardAction常量，表示当接收组件是焦点组件的祖先或本身是焦点组件时，应调用该命令。
        另请参见：
        常数字段值

      • WHEN_IN_FOCUSED_WINDOW

        public static final int WHEN_IN_FOCUSED_WINDOW
        用于 registerKeyboardAction常量，表示当接收组件位于具有焦点的窗口中或者本身是焦点组件时，应调用该命令。
        另请参见：
        常数字段值

      • UNDEFINED_CONDITION

        public static final int UNDEFINED_CONDITION
        某些API使用的常量表示没有定义条件。
        另请参见：
        常数字段值

      • TOOL_TIP_TEXT_KEY

        public static final String TOOL_TIP_TEXT_KEY
        光标在组件上方时显示的注释，也称为“值提示”，“飞越帮助”或“悬浮标签”。
        另请参见：
        常数字段值

    • 构造方法详细信息

      • JComponent

        public JComponent()
        默认JComponent构造函数。 除了调用Container构造函数之外，此构造函数执行的初始化很少。 例如，初始布局管理器是null 。 但是，它确实将组件的locale属性设置为JComponent.getDefaultLocale返回的值。
        另请参见：
        getDefaultLocale()

    • 方法详细信息

      • setInheritsPopupMenu

        @BeanProperty(description="Whether or not the JPopupMenu is inherited")
public void setInheritsPopupMenu​(boolean value)
        设置getComponentPopupMenu是否应该委派给父组件，如果该组件没有分配给它的JPopupMenu 。

        此默认值为false，但实现为JComponent s的某些JComponent子类可能将此设置为true。

        这是一个绑定属性。

        参数
        value - 是否继承JPopupMenu
        从以下版本开始：
        1.5
        另请参见：
        setComponentPopupMenu(javax.swing.JPopupMenu)

      • getInheritsPopupMenu

        public boolean getInheritsPopupMenu()
        如果JPopupMenu应该从父级继承，则返回true。
        结果
        如果JPopupMenu应该从父级继承，则为true
        从以下版本开始：
        1.5
        另请参见：
        setComponentPopupMenu(javax.swing.JPopupMenu)

      • setComponentPopupMenu

        @BeanProperty(preferred=true,
              description="Popup to show")
public void setComponentPopupMenu​(JPopupMenu popup)
        设置JPopupMenu此JComponent 。 UI负责注册绑定并添加必要的侦听器，以便在适当的时间显示JPopupMenu 。 当显示JPopupMenu取决于外观：有些可能在鼠标事件上显示，有些可能启用键绑定。

        如果popup为空，并且getInheritsPopupMenu返回true，则getComponentPopupMenu将委派给父级。 这提供了一种使所有子组件继承父组件的弹出菜单的方法。

        这是一个绑定属性。

        参数
        popup - - 将分配给此组件的弹出窗口可能为null
        从以下版本开始：
        1.5
        另请参见：
        getComponentPopupMenu()

      • getComponentPopupMenu

        public JPopupMenu getComponentPopupMenu()
        返回为此组件分配的JPopupMenu 。 如果此组件没有分配JPopupMenu且getInheritsPopupMenu为真，则返回getParent().getComponentPopupMenu() （假设父级有效。）
        结果
        JPopupMenu分配给该组件或 null如果没有弹出分配
        从以下版本开始：
        1.5
        另请参见：
        setComponentPopupMenu(javax.swing.JPopupMenu)

      • getUI

        public ComponentUI getUI()
        返回呈现此组件的外观委托。
        结果
        呈现此组件的 ComponentUI对象
        从以下版本开始：
        9

      • getUIClassID

        @BeanProperty(bound=false,
              expert=true,
              description="UIClassID")
public String getUIClassID()
        返回UIDefaults键，用于查找定义此组件外观的swing.plaf.ComponentUI类的名称。 大多数应用程序永远不需要调用此方法。 支持可插入外观的子类JComponent应覆盖此方法以返回映射到定义其外观的ComponentUI子类的UIDefaults键。
        结果
        UIDefaults用于 ComponentUI子类的密钥
        另请参见：
        UIDefaults.getUI(javax.swing.JComponent)

      • getComponentGraphics

        protected Graphics getComponentGraphics​(Graphics g)
        返回用于绘制此组件的图形对象。 如果DebugGraphics已打开，我们会根据需要创建一个新的DebugGraphics对象。 否则，我们只需配置指定图形对象的前景和字体。
        参数
        g - 原始 Graphics对象
        结果
        为此组件配置的 Graphics对象

      • paintComponent

        protected void paintComponent​(Graphics g)
        如果UI委托是非null ，则调用UI委托的绘制方法。 我们向代表传递Graphics对象的副本，以保护其余的油漆代码免受不可撤销的更改（例如， Graphics.translate ）。

        如果在子类中重写此项，则不应对传入的Graphics进行永久更改。 例如，您不应更改剪辑Rectangle或修改转换。 如果您需要执行这些操作，您可能会发现从传入Graphics创建新的Graphics更容易并对其进行操作。 此外，如果您不调用super的实现，则必须遵守opaque属性，即如果此组件是不透明的，则必须以不透明的颜色完全填充背景。 如果您不遵守opaque属性，您可能会看到视觉伪像。

        传入的Graphics对象可能具有除安装在其上的标识转换之外的转换。 在这种情况下，如果累积应用另一个转换，则可能会出现意外结果。

        参数
        g - Graphics保护对象
        另请参见：
        paint(java.awt.Graphics) ， ComponentUI

      • paintChildren

        protected void paintChildren​(Graphics g)
        涂抹这个组件的孩子。 如果shouldUseBuffer为true，则组件祖先没有缓冲区，子组件子组件可以使用缓冲区（如果有）。 否则，一个祖先有一个当前正在使用的缓冲区，孩子们不应该使用缓冲区来绘制。
        参数
        g - 要绘制的 Graphics上下文
        另请参见：
        paint(java.awt.Graphics) ， Container.paint(java.awt.Graphics)

      • paintBorder

        protected void paintBorder​(Graphics g)
        绘制组件的边框。

        如果在子类中覆盖它，则不应对传入的Graphics进行永久更改。 例如，您不应更改剪辑Rectangle或修改转换。 如果你需要做这些操作，你可能会发现更容易地创建一个新的Graphics从通过Graphics和操纵它。

        参数
        g - 要绘制的 Graphics上下文
        另请参见：
        paint(java.awt.Graphics) ， setBorder(javax.swing.border.Border)

      • print

        public void print​(Graphics g)
        调用此方法将组件打印到指定的Graphics 。 这种方法将导致调用printComponent ， printBorder和printChildren 。 如果您打算自定义打印方式，建议您覆盖前面提到的方法之一而不是此方法。 但是，如果要在调用超类行为之前准备状态，则覆盖此方法会很有用。 例如，如果要在打印前更改组件的背景颜色，可以执行以下操作： 
          public void print(Graphics g) {
         Color orig = getBackground();
         setBackground(Color.WHITE);

         // wrap in try/finally so that we always restore the state
         try {
             super.print(g);
         } finally {
             setBackground(orig);
         }
     }

        或者，或者对于将绘画委托给其他对象的组件，您可以在绘制期间查询该组件是否处于打印操作中。 isPaintingForPrint方法提供此功能，其返回值将通过以下方法更改：在渲染之前立即更改为true立即更改为false 。 每次更改时，将在此组件上触发属性更改事件，名称为"paintingForPrint" 。

        此方法设置组件的状态，以便不使用双缓冲区：绘制将直接在传入的Graphics 。

        重写：
        print类 Container
        参数
        g - 要绘制的 Graphics上下文
        另请参见：
        printComponent(java.awt.Graphics) ， printBorder(java.awt.Graphics) ， printChildren(java.awt.Graphics) ， isPaintingForPrint()

      • printComponent

        protected void printComponent​(Graphics g)
        这在打印操作期间被调用。 这是为了在组件上调用paintComponent 。 如果您希望在打印时添加特殊绘画行为，请覆盖此项。
        参数
        g - 要绘制的 Graphics上下文
        从以下版本开始：
        1.3
        另请参见：
        print(java.awt.Graphics)

      • printChildren

        protected void printChildren​(Graphics g)
        打印此组件的子项。 这是为了在组件上调用paintChildren 。 如果您希望以不同于绘画的方式打印子项，请覆盖此项。
        参数
        g - 要绘制的 Graphics上下文
        从以下版本开始：
        1.3
        另请参见：
        print(java.awt.Graphics)

      • printBorder

        protected void printBorder​(Graphics g)
        打印组件的边框。 这是为了在组件上调用paintBorder 。 如果您希望以不同的方式打印边框，请覆盖它。
        参数
        g - 要绘制的 Graphics上下文
        从以下版本开始：
        1.3
        另请参见：
        print(java.awt.Graphics)

      • isPaintingTile

        @BeanProperty(bound=false)
public boolean isPaintingTile()
        如果组件当前正在绘制tile，则返回true。 如果此方法返回true，则将再次为另一个tile调用paint。 如果您没有绘制图块或者绘制了最后一个图块，则此方法返回false。 使用此方法可以保持切片之间可能需要的某些状态。
        结果
        如果组件当前正在绘制tile，则返回true，否则返回false

      • isPaintingForPrint

        @BeanProperty(bound=false)
public final boolean isPaintingForPrint()
        如果此组件上的当前喷涂操作是print操作的一部分，则返回true 。 当您想要自定义打印内容与屏幕上显示的内容时，此方法很有用。

        您可以通过侦听名为"paintingForPrint"此组件上的属性更改事件来检测此属性值的更改。

        注意：此方法提供与其他高级Swing打印API提供的功能互补的功能。 但是，它严格处理绘画，不应混淆为提供更高级别的打印过程的信息。 例如， JTable.print()操作不一定导致完整组件的连续呈现，并且该方法的返回值可以在该操作期间多次改变。 在打印过程正在进行时，甚至可以将组件涂到屏幕上。 在这种情况下，当且仅当表格被绘制为打印过程的一部分时，此方法的返回值为true 。

        结果
        如果此组件上的当前绘制操作是打印操作的一部分，则为true
        从以下版本开始：
        1.6
        另请参见：
        print(java.awt.Graphics)

      • setNextFocusableComponent

        @Deprecated
public void setNextFocusableComponent​(Component aComponent)
        Deprecated.
        As of 1.4, replaced by FocusTraversalPolicy
        在1.4版中，重新设计了焦点子系统。 有关更多信息，请参阅“Java教程”中的 How to Use the Focus Subsystem部分。

        通过无条件地将指定的Component设置为Component中的下一个Component ，并将此JComponent作为循环中指定的Component的先前Component ，覆盖此JComponent的焦点遍历循环的默认FocusTraversalPolicy 。

        参数
        aComponent -该 Component应遵循此 JComponent的焦点遍历循环
        另请参见：
        getNextFocusableComponent() ， FocusTraversalPolicy

      • getNextFocusableComponent

        @Deprecated
public Component getNextFocusableComponent()
        Deprecated.
        As of 1.4, replaced by FocusTraversalPolicy.
        在1.4版中，重新设计了焦点子系统。 有关更多信息，请参阅“Java教程”中的 How to Use the Focus Subsystem部分。

        返回Component集通过对先前调用setNextFocusableComponent(Component)这个JComponent 。

        结果
        Component将在焦点遍历循环中跟随此 JComponent ，如果没有明确指定， null
        另请参见：
        setNextFocusableComponent(java.awt.Component)

      • setRequestFocusEnabled

        public void setRequestFocusEnabled​(boolean requestFocusEnabled)
        提供有关此JComponent是否应该获得焦点的提示。 这只是一个提示，并且需要关注以尊重此属性的消费者。 这通常适用于鼠标操作，但不适用于键盘操作。 例如，在鼠标操作期间请求焦点之前，外观可以验证此属性是否为真。 如果你不想在JComponent上用鼠标按JComponent窃取焦点，这通常会被使用，但确实希望JComponent可以通过键盘移动。 如果您不希望此JComponent完全可以使用，请使用setFocusable方法。

        有关详细信息，请参阅“Java教程”中的 How to Use the Focus Subsystem部分。

        参数
        requestFocusEnabled - 表示您是否希望此 JComponent可以聚焦
        另请参见：
        Focus Specification ， Component.setFocusable(boolean)

      • grabFocus

        public void grabFocus()
        请求此Component获取输入焦点，并且此Component的顶级祖先成为焦点Window。 对于要授予的请求，此组件必须是可显示的，可见的和可聚焦的。

        此方法旨在供焦点实现使用。 客户端代码不应使用此方法; 相反，它应该使用requestFocusInWindow() 。

        另请参见：
        requestFocusInWindow()

      • setVerifyInputWhenFocusTarget

        @BeanProperty(description="Whether the Component verifies input before accepting focus.")
public void setVerifyInputWhenFocusTarget​(boolean verifyInputWhenFocusTarget)
        设置该值以指示在此组件请求焦点之前是否将调用当前焦点所有者的输入验证程序。 默认值为true。 在取消按钮或滚动条等组件上设置为false，即使当前焦点所有者的输入未被该组件的输入验证程序“传递”，也应激活该组件。
        参数
        verifyInputWhenFocusTarget - verifyInputWhenFocusTarget属性的值
        从以下版本开始：
        1.3
        另请参见：
        InputVerifier ， setInputVerifier(javax.swing.InputVerifier) ， getInputVerifier() ， getVerifyInputWhenFocusTarget()

      • setMaximumSize

        @BeanProperty(description="The maximum size of the component.")
public void setMaximumSize​(Dimension maximumSize)
        将此组件的最大大小设置为常量值。 对getMaximumSize后续调用将始终返回此值; 组件的UI不会被要求计算它。 将最大大小设置为null可恢复默认行为。
        重写：
        setMaximumSize类 Component
        参数
        maximumSize - 包含所需的最大允许尺寸的 Dimension
        另请参见：
        getMaximumSize()

      • setMinimumSize

        @BeanProperty(description="The minimum size of the component.")
public void setMinimumSize​(Dimension minimumSize)
        将此组件的最小大小设置为常量值。 随后对getMinimumSize调用将始终返回此值; 组件的UI不会被要求计算它。 将最小大小设置为null将恢复默认行为。
        重写：
        setMinimumSize类 Component
        参数
        minimumSize - 此组件的新最小大小
        另请参见：
        getMinimumSize()

      • contains

        public boolean contains​(int x,
                        int y)
        为了鼠标处理，为UI委托提供了定义此组件的精确形状的机会。
        重写：
        contains类 Component
        参数
        x - 该点的 x坐标
        y - 该点的 y坐标
        结果
        如果此组件在逻辑上包含x，y，则返回true
        另请参见：
        Component.contains(int, int) ， ComponentUI

      • setBorder

        @BeanProperty(preferred=true,
              visualUpdate=true,
              description="The component\'s border.")
public void setBorder​(Border border)
        设置此组件的边框。 Border对象负责定义组件的insets（覆盖直接在组件上设置的任何insets），并可选择在这些insets的范围内呈现任何边框装饰。 应该使用边框（而不是插图）来为摆动组件创建装饰性和非装饰性（例如边距和填充）区域。 复合边框可用于在单个组件中嵌套多个边框。

        虽然从技术上讲，您可以在任何继承自JComponent对象上设置边框，但许多标准Swing组件的外观实现与用户设置的边框不兼容。 通常，如果要在JPanel或JLabel以外的标准Swing组件上设置边框，我们建议您将组件放在JPanel并将边框设置在JPanel 。

        这是一个绑定属性。

        参数
        border - 要为此组件呈现的边框
        另请参见：
        Border ， CompoundBorder

      • getInsets

        public Insets getInsets​(Insets insets)
        返回包含此组件的插入值的Insets对象。 如果可能，将重用传入的Insets对象。 但是，调用方法不能假定将返回相同的对象。 此对象中的所有现有值都将被覆盖。 如果insets为null，则将分配一个新的。
        参数
        insets - Insets对象，可以重复使用
        结果
        Insets对象
        另请参见：
        getInsets()

      • setAlignmentY

        @BeanProperty(description="The preferred vertical alignment of the component.")
public void setAlignmentY​(float alignmentY)
        设置垂直对齐方式。
        参数
        alignmentY - 新的垂直对齐方式
        另请参见：
        getAlignmentY()

      • setAlignmentX

        @BeanProperty(description="The preferred horizontal alignment of the component.")
public void setAlignmentX​(float alignmentX)
        设置水平对齐。
        参数
        alignmentX - 新的水平对齐方式
        另请参见：
        getAlignmentX()

      • setInputVerifier

        @BeanProperty(description="The component\'s input verifier.")
public void setInputVerifier​(InputVerifier inputVerifier)
        设置此组件的输入验证程序。
        参数
        inputVerifier - 新的输入验证程序
        从以下版本开始：
        1.3
        另请参见：
        InputVerifier

      • getInputVerifier

        public InputVerifier getInputVerifier()
        返回此组件的输入验证程序。
        结果
        inputVerifier属性
        从以下版本开始：
        1.3
        另请参见：
        InputVerifier

      • setDebugGraphicsOptions

        @BeanProperty(bound=false,
              preferred=true,
              enumerationValues={"DebugGraphics.NONE_OPTION","DebugGraphics.LOG_OPTION","DebugGraphics.FLASH_OPTION","DebugGraphics.BUFFERED_OPTION"},
              description="Diagnostic options for graphics operations.")
public void setDebugGraphicsOptions​(int debugOptions)
        启用或禁用有关组件或其子组件中执行的每个图形操作的诊断信息。
        参数
        debugOptions - 确定组件应如何显示信息; 以下选项之一：
        • DebugGraphics.LOG_OPTION - 导致打印文本消息。
        • DebugGraphics.FLASH_OPTION - 使绘图闪烁几次。
        • DebugGraphics.BUFFERED_OPTION - 创建一个ExternalWindow ，显示在View的屏幕外缓冲区上执行的操作。
        • DebugGraphics.NONE_OPTION禁用调试。
        • 值为0不会导致调试选项发生更改。
        debugOptions按位进入当前值

      • getDebugGraphicsOptions

        public int getDebugGraphicsOptions()
        返回图形调试的状态。
        结果
        零或多个以下选项的按位OR标志：
        • DebugGraphics.LOG_OPTION - 导致打印文本消息。
        • DebugGraphics.FLASH_OPTION - 使绘图闪烁几次。
        • DebugGraphics.BUFFERED_OPTION - 创建一个ExternalWindow ，显示在View的屏幕外缓冲区上执行的操作。
        • DebugGraphics.NONE_OPTION禁用调试。
        • 值为0不会导致调试选项发生更改。
        另请参见：
        setDebugGraphicsOptions(int)

      • registerKeyboardAction

        public void registerKeyboardAction​(ActionListener anAction,
                                   String aCommand,
                                   KeyStroke aKeyStroke,
                                   int aCondition)
        此方法现已过时，请使用getActionMap()和getInputMap()的组合进行类似操作。 例如，绑定KeyStroke aKeyStroke至Action anAction现在使用： 
          component.getInputMap().put(aKeyStroke, aCommand);
   component.getActionMap().put(aCommmand, anAction);
        以上假设您希望绑定适用于WHEN_FOCUSED 。 要为其他焦点状态注册绑定，请使用采用整数的getInputMap方法。

        注册新的键盘操作。 anAction如果匹配的关键事件将被调用aKeyStroke发生和aCondition验证。 KeyStroke对象定义键盘键和一个或多个修饰符（alt，shift，ctrl，meta）的特定组合。

        如果指定，将在交付的事件中设置aCommand 。

        aCondition可以是以下之一：

        WHEN_FOCUSED
        The action will be invoked only when the keystroke occurs while the component has the focus.
        WHEN_IN_FOCUSED_WINDOW
        The action will be invoked when the keystroke occurs while the component has the focus or if the component is in the window that has the focus. Note that the component need not be an immediate descendent of the window -- it can be anywhere in the window's containment hierarchy. In other words, whenever any component in the window has the focus, the action registered with this component is invoked.
        WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
        The action will be invoked when the keystroke occurs while the component has the focus or if the component is an ancestor of the component that has the focus.

        通过击键和条件的组合，您可以为指定的击键+修改器组合（使用KeyStroke类）定义高级（语义）动作事件，并指向具有焦点的组件的父级或子级，或者指向组件本身。 换句话说，在组件的任何分层结构中，可以立即将任意键组合定向到层次结构中的适当组件，并使特定方法被调用（通常通过适配器对象）。

        如果已为接收容器注册了一个操作，使用相同的charCode和相同的修饰符， anAction将替换该操作。

        参数
        anAction - 要注册的 Action
        aCommand - 要在传递的事件中设置的命令
        aKeyStroke - 要绑定到动作的 KeyStroke
        aCondition - 需要满足的条件，见上文
        另请参见：
        KeyStroke

      • registerKeyboardAction

        public void registerKeyboardAction​(ActionListener anAction,
                                   KeyStroke aKeyStroke,
                                   int aCondition)
        此方法现已过时，请结合使用 getActionMap()和 getInputMap()进行类似操作。
        参数
        anAction - 要对给定的击键和条件进行注册的动作
        aKeyStroke - a KeyStroke
        aCondition - 与给定击键和操作相关联的条件
        另请参见：
        getActionMap() ， getInputMap(int)

      • unregisterKeyboardAction

        public void unregisterKeyboardAction​(KeyStroke aKeyStroke)
        此方法现已过时。 要取消注册现有绑定，您可以从ActionMap/InputMap删除绑定，或者将绑定设置为InputMap 。 从InputMap删除绑定允许父InputMap的绑定处于活动状态，而在InputMap放置虚拟绑定InputMap有效地禁止绑定发生。

        取消注册键盘操作。 这将删除ActionMap （如果存在）以及InputMap 。

        参数
        aKeyStroke - 取消注册其键盘操作的击键

      • getConditionForKeyStroke

        public int getConditionForKeyStroke​(KeyStroke aKeyStroke)
        返回确定是否响应指定的击键发生注册操作的条件。

        对于Java 2平台KeyStroke可以与多个条件相关联。 例如，'a'可以绑定两个条件WHEN_FOCUSED和WHEN_IN_FOCUSED_WINDOW条件。

        参数
        aKeyStroke - 请求动作击键条件的击键
        结果
        动作键击条件

      • getActionForKeyStroke

        public ActionListener getActionForKeyStroke​(KeyStroke aKeyStroke)
        返回将执行为给定击键注册的操作的对象。
        参数
        aKeyStroke - 要为其返回侦听器的击键
        结果
        发生击键时调用的 ActionListener对象

      • resetKeyboardActions

        public void resetKeyboardActions()
        取消注册第一层InputMaps和ActionMap中的所有绑定。 这具有删除任何本地绑定的效果，并允许父InputMap/ActionMaps定义的绑定（UI通常在第二层中定义）保持InputMap/ActionMaps 。

      • setInputMap

        public final void setInputMap​(int condition,
                              InputMap map)
        将InputMap设置为在condition至map的条件下使用。 null值意味着您不希望使用任何绑定，即使从UI也是如此。 这将不会重新安装UI InputMap （如果有的话）。 condition具有以下值之一：
        • WHEN_IN_FOCUSED_WINDOW
        • WHEN_FOCUSED
        • WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
        如果condition是WHEN_IN_FOCUSED_WINDOW而map不是ComponentInputMap ，则抛出IllegalArgumentException 。 同样，如果condition不是列出的值之一，则会抛出IllegalArgumentException 。
        参数
        condition - 上面列出的值之一
        map - 用于给定条件的 InputMap
        异常
        IllegalArgumentException -如果condition为WHEN_IN_FOCUSED_WINDOW和map不是一个实例ComponentInputMap ; 或者如果condition不是上面指定的合法值之一
        从以下版本开始：
        1.3

      • getInputMap

        public final InputMap getInputMap​(int condition)
        返回 InputMap期间使用的 condition 。
        参数
        condition - WHEN_IN_FOCUSED_WINDOW，WHEN_FOCUSED，WHEN_ANCESTOR_OF_FOCUSED_COMPONENT之一
        结果
        InputMap为指定的 condition
        从以下版本开始：
        1.3

      • getInputMap

        public final InputMap getInputMap()
        返回组件具有焦点时使用的InputMap 。 这是getInputMap(WHEN_FOCUSED)便捷方法。
        结果
        组件具有焦点时使用的 InputMap
        从以下版本开始：
        1.3

      • setActionMap

        public final void setActionMap​(ActionMap am)
        将ActionMap设置为am 。 这不会将am的父节点设置为来自UI的ActionMap （如果有的话），由调用者完成此操作。
        参数
        am - 新的 ActionMap
        从以下版本开始：
        1.3

      • getActionMap

        public final ActionMap getActionMap()
        返回ActionMap用来确定什么Action火特定KeyStroke结合。 返回的ActionMap ，除非另有设置，否则将UI中的ActionMap设置为父级。
        结果
        ActionMap包含键/动作绑定
        从以下版本开始：
        1.3

      • getBaseline

        public int getBaseline​(int width,
                       int height)
        返回基线。 基线从组件顶部开始测量。 此方法主要用于LayoutManager以沿其基线对齐组件。 返回值小于0表示此组件没有合理的基线，并且LayoutManager不应将此组件与其基线对齐。

        此方法调用同名的ComponentUI方法。 如果此组件没有ComponentUI -1将返回。 如果返回值> = 0，则组件具有任何大小的有效基线> =最小大小，而getBaselineResizeBehavior可用于确定基线随大小而变化的方式。

        重写：
        getBaseline类 Component
        参数
        width - 获取基线的宽度
        height - 获取基线的高度
        结果
        基线或<0表示没有合理的基线
        异常
        IllegalArgumentException - 如果宽度或高度<0
        从以下版本开始：
        1.6
        另请参见：
        getBaselineResizeBehavior() ， FontMetrics

      • getBaselineResizeBehavior

        @BeanProperty(bound=false)
public Component.BaselineResizeBehavior getBaselineResizeBehavior()
        返回一个枚举，指示组件的基线如何随大小的变化而变化。 此方法主要用于布局管理器和GUI构建器。

        此方法调用同名的ComponentUI方法。 如果该组件没有ComponentUI BaselineResizeBehavior.OTHER将被退回。 子类不应该返回null ; 如果基线无法计算则返回BaselineResizeBehavior.OTHER 。 呼叫者应首先使用getBaseline询问基线，如果返回值> = 0，则使用此方法。 即使getBaseline返回小于0的值，此方法也可以返回BaselineResizeBehavior.OTHER getBaseline的值。

        重写：
        getBaselineResizeBehavior类 Component
        结果
        一个枚举，指示基线随组件大小的变化而变化的方式
        从以下版本开始：
        1.6
        另请参见：
        getBaseline(int, int)

      • requestDefaultFocus

        @Deprecated
public boolean requestDefaultFocus()
        Deprecated.
        As of 1.4, replaced by FocusTraversalPolicy.getDefaultComponent(Container).requestFocus()
        在1.4版中，重新设计了焦点子系统。 有关更多信息，请参阅“Java教程”中的 How to Use the Focus Subsystem部分。

        请求关注JComponent的FocusTraversalPolicy的默认Component 。 如果此JComponent是焦点循环根，则使用其FocusTraversalPolicy 。 否则，使用FocusTraversalPolicy的焦点循环根祖先的JComponent 。

        结果
        如果此组件可以请求获取输入焦点，则返回true;如果不能，则返回false
        另请参见：
        FocusTraversalPolicy.getDefaultComponent(java.awt.Container)

      • setEnabled

        @BeanProperty(expert=true,
              preferred=true,
              visualUpdate=true,
              description="The enabled state of the component.")
public void setEnabled​(boolean enabled)
        设置是否启用此组件。 启用的组件可能会响应用户输入，而未启用的组件则无法响应用户输入。 某些组件在被禁用时可能会改变其视觉表示，以便向用户提供他们无法接受输入的反馈。

        注意：禁用组件不会禁用其子组件。

        注意：禁用轻量级组件不会阻止它接收MouseEvents。

        重写：
        setEnabled类别 Component
        参数
        enabled - 如果应启用此组件， enabled true，否则为false
        另请参见：
        Component.isEnabled() ， Component.isLightweight()

      • setBackground

        @BeanProperty(preferred=true,
              visualUpdate=true,
              description="The background color of the component.")
public void setBackground​(Color bg)
        设置此组件的背景颜色。 仅当组件不透明时才使用背景颜色，并且仅使用JComponent或ComponentUI实现的子类。 直接子类JComponent必须覆盖paintComponent才能使用此属性。

        尊重这个属性取决于外观和感觉，有些人可能会选择忽略它。

        重写：
        setBackground类 Component
        参数
        bg - 所需的背景 Color
        另请参见：
        Component.getBackground() ， setOpaque(boolean)

      • getDefaultLocale

        public static Locale getDefaultLocale()
        返回用于在创建时初始化每个JComponent的语言环境属性的默认语言环境。 默认语言环境具有“AppContext”范围，因此applet（以及可能在单个VM中运行的多个轻量级应用程序）可以拥有自己的设置。 applet可以安全地更改其默认语言环境，因为它不会影响其他applet（或浏览器）。
        结果
        默认 Locale 。
        从以下版本开始：
        1.4
        另请参见：
        setDefaultLocale(java.util.Locale) ， Component.getLocale() ， Component.setLocale(java.util.Locale)

      • setDefaultLocale

        public static void setDefaultLocale​(Locale l)
        设置用于在创建时初始化每个JComponent的语言环境属性的默认语言环境。 初始值是VM的默认语言环境。 默认语言环境具有“AppContext”范围，因此applet（以及可能在单个VM中运行的多个轻量级应用程序）可以拥有自己的设置。 applet可以安全地更改其默认语言环境，因为它不会影响其他applet（或浏览器）。
        参数
        l - 新组件的所需默认值 Locale 。
        从以下版本开始：
        1.4
        另请参见：
        getDefaultLocale() ， Component.getLocale() ， Component.setLocale(java.util.Locale)

      • processComponentKeyEvent

        protected void processComponentKeyEvent​(KeyEvent e)
        处理组件本身可识别的任何关键事件。 这是在焦点管理员和任何感兴趣的听众有机会偷走事件之后调用的。 仅在尚未使用事件时才调用此方法。 在键盘UI逻辑之前调用此方法。

        实现此方法不执行任何操作。 如果子类自己处理某些键事件，它们通常会覆盖此方法。 如果事件被处理，则应该使用它。

        参数
        e - 要处理的事件

      • processKeyBinding

        protected boolean processKeyBinding​(KeyStroke ks,
                                    KeyEvent e,
                                    int condition,
                                    boolean pressed)
        调用以处理键绑定为ks作为的结果KeyEvent e 。 这将获得相应的InputMap ，获取绑定，从ActionMap获取操作，然后（如果找到操作并且组件已启用）调用notifyAction以通知操作。
        参数
        ks - 查询 KeyStroke
        e - KeyEvent
        condition - 以下值之一：
        • JComponent.WHEN_FOCUSED
        • JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
        • JComponent.WHEN_IN_FOCUSED_WINDOW
        pressed - 如果按下该键，则为true
        结果
        如果存在对操作的绑定，则为true，并且已启用该操作
        从以下版本开始：
        1.3

      • setToolTipText

        @BeanProperty(bound=false,
              preferred=true,
              description="The text to display in a tool tip.")
public void setToolTipText​(String text)
        注册要在工具提示中显示的文本。 当光标滞留在组件上时，将显示文本。

        有关更多文档，请参阅The Java Tutorial中的 How to Use Tool Tips 。

        参数
        text - 要显示的字符串; 如果文本为null ，则此组件的工具提示已关闭
        另请参见：
        TOOL_TIP_TEXT_KEY

      • getToolTipText

        public String getToolTipText()
        返回已使用 setToolTipText设置的工具提示字符串。
        结果
        工具提示的文字
        另请参见：
        TOOL_TIP_TEXT_KEY

      • getToolTipText

        public String getToolTipText​(MouseEvent event)
        返回要用作事件工具提示的字符串。 默认情况下，它返回使用setToolTipText设置的任何字符串。 如果组件提供更广泛的API以支持不同位置的不同工具提示，则应该重写此方法。
        参数
        event -该 MouseEvent发起 ToolTip显示器
        结果
        包含工具提示的字符串

      • getToolTipLocation

        public Point getToolTipLocation​(MouseEvent event)
        返回此组件坐标系中的工具提示位置。 如果返回null ，Swing将选择一个位置。 默认实现返回null 。
        参数
        event -该 MouseEvent导致该 ToolTipManager显示工具提示
        结果
        总是返回 null

      • getPopupLocation

        public Point getPopupLocation​(MouseEvent event)
        返回在此组件的坐标系中显示弹出菜单的首选位置。 尊重这个属性取决于外观和感觉，有些人可能会选择忽略它。 如果是null ，外观会选择合适的位置。
        参数
        event -的 MouseEvent要显示触发弹出式或 null如果弹出不被示出为鼠标事件的结果
        结果
        位置显示 JPopupMenu或 null
        从以下版本开始：
        1.5

      • createToolTip

        public JToolTip createToolTip()
        返回应该用于显示工具提示的JToolTip实例。 组件通常不会覆盖此方法，但可以用于使不同的工具提示以不同方式显示。
        结果
        JToolTip用于显示此工具提示

      • scrollRectToVisible

        public void scrollRectToVisible​(Rectangle aRect)
        将scrollRectToVisible()消息转发给JComponent的父母。 可以为请求提供服务的组件（例如JViewport ）会覆盖此方法并执行滚动操作。
        参数
        aRect - 可见 Rectangle
        另请参见：
        JViewport

      • setAutoscrolls

        @BeanProperty(bound=false,
              expert=true,
              description="Determines if this component automatically scrolls its contents when dragged.")
public void setAutoscrolls​(boolean autoscrolls)
        设置autoscrolls属性。 如果true鼠标拖动到组件边界之外并且鼠标运动暂停（同时按钮继续按下），将合成生成true鼠标拖动事件。 合成事件使得看起来拖动手势已经在跨越组件边界时建立的方向上恢复。 支持自动滚动的组件必须通过调用scrollRectToVisible来处理mouseDragged事件，该矩形包含鼠标事件的位置。 所有支持项目的选择，并且通常显示在Swing组件的JScrollPane （ JTable ， JList ， JTree ， JTextArea和JEditorPane ）已经处理鼠标这样拖事件。 要在任何其他组件中启用自动滚动，请添加一个调用scrollRectToVisible的鼠标移动侦听scrollRectToVisible 。 例如，给定一个JPanel ， myPanel ： 
          MouseMotionListener doScrollRectToVisible = new MouseMotionAdapter() {
     public void mouseDragged(MouseEvent e) {
        Rectangle r = new Rectangle(e.getX(), e.getY(), 1, 1);
        ((JPanel)e.getSource()).scrollRectToVisible(r);
    }
 };
 myPanel.addMouseMotionListener(doScrollRectToVisible);
        autoScrolls属性的默认值为false 。
        参数
        autoscrolls - 如果为true，则在将鼠标拖动到组件边界之外并继续按住鼠标按钮时，将生成合成鼠标拖动事件; 否则是假的
        另请参见：
        getAutoscrolls() ， JViewport ， JScrollPane

      • getAutoscrolls

        public boolean getAutoscrolls()
        获取 autoscrolls属性。
        结果
        autoscrolls财产的价值
        另请参见：
        JViewport ， setAutoscrolls(boolean)

      • setTransferHandler

        @BeanProperty(hidden=true,
              description="Mechanism for transfer of data to and from the component")
public void setTransferHandler​(TransferHandler newHandler)
        设置TransferHandler ，它支持通过剪切/复制/粘贴和拖放将数据传入和传出此组件。 如果组件不支持数据传输操作，则可能是null 。

        如果新的TransferHandler不是null ，则此方法还会在组件上安装新的 DropTarget以通过TransferHandler激活丢弃处理并激活任何内置支持（例如计算和显示潜在的丢弃位置）。 如果您不希望此组件以任何方式响应丢弃，则可以通过删除丢弃目标（ setDropTarget(null) ）或取消激活它（ getDropTaget().setActive(false) ）来完全禁用丢弃支持。

        如果新的TransferHandler是null ，则此方法将删除放置目标。

        在两种情况下，此方法不会修改放置目标：首先，如果开发人员将此组件上的现有放置目标明确设置为non-null值。 第二，如果系统属性suppressSwingDropSupport是true 。 系统属性的默认值为false 。

        有关详细信息，请参阅“Java教程”中的 How to Use Drag and Drop and Data Transfer部分。

        参数
        newHandler - 新的 TransferHandler
        从以下版本开始：
        1.4
        另请参见：
        TransferHandler ， getTransferHandler()

      • enable

        @Deprecated
public void enable()
        Deprecated.
        As of JDK version 1.1, replaced by java.awt.Component.setEnabled(boolean).
        重写：
        enable类 Component

      • disable

        @Deprecated
public void disable()
        Deprecated.
        As of JDK version 1.1, replaced by java.awt.Component.setEnabled(boolean).
        重写：
        disable类 Component

      • putClientProperty

        public final void putClientProperty​(Object key,
                                    Object value)
        向此组件添加任意键/值“客户端属性”。

        get/putClientProperty方法提供对小型每实例哈希表的访问。 调用者可以使用get / putClientProperty来注释由另一个模块创建的组件。 例如，布局管理器可以通过这种方式存储每个子约束。 例如： 

          componentA.putClientProperty("to the left of", componentB);
        如果值为null此方法将删除该属性。 使用PropertyChange事件报告对客户端属性的更改。 该属性的名称（为了PropertyChange事件）是key.toString() 。

        clientProperty字典不是为了支持JComponent的大规模扩展，也不应该在设计新组件时将其视为子类化的替代方法。

        参数
        key - 新的客户端属性键
        value - 新的客户端属性值; 如果null此方法将删除该属性
        另请参见：
        getClientProperty(java.lang.Object) ， Container.addPropertyChangeListener(java.beans.PropertyChangeListener)

      • isLightweightComponent

        public static boolean isLightweightComponent​(Component c)
        如果此组件是轻量级的，即，如果它没有本机窗口系统对等项，则返回true。
        参数
        c - 要检查的 Component
        结果
        如果此组件是轻量级，则为true

      • reshape

        @Deprecated
public void reshape​(int x,
                    int y,
                    int w,
                    int h)
        Deprecated.
        As of JDK 5, replaced by Component.setBounds(int, int, int, int).

        Moves and resizes this component.

        复制自类： Component描述
        重塑此组件的边界矩形。
        重写：
        reshape类 Component
        参数
        x - 新的水平位置
        y - 新的垂直位置
        w - 新宽度
        h - 新的高度
        另请参见：
        Component.setBounds(int, int, int, int)

      • getBounds

        public Rectangle getBounds​(Rectangle rv)
        将此组件的边界存储为“返回值” rv并返回rv 。 如果rv为null新Rectangle分配。 如果调用者想要避免在堆上分配新的Rectangle对象，则此版本的getBounds非常有用。
        重写：
        getBounds类 Component
        参数
        rv - 返回值，修改为组件的边界
        结果
        rv ; 如果rv是null返回一个新创建的Rectangle与此组件的界限

      • getSize

        public Dimension getSize​(Dimension rv)
        将此组件的宽度/高度存储为“返回值” rv并返回rv 。 如果rv是null则分配新的Dimension对象。 如果调用者想要避免在堆上分配新的Dimension对象，则此版本的getSize非常有用。
        重写：
        getSize类 Component
        参数
        rv - 返回值，修改为组件的大小
        结果
        rv

      • getLocation

        public Point getLocation​(Point rv)
        将此组件的x，y原点存储到“返回值” rv并返回rv 。 如果rv为null新Point分配。 如果调用者想要避免在堆上分配新的Point对象，则此版本的getLocation非常有用。
        重写：
        getLocation类别 Component
        参数
        rv - 返回值，已修改为组件的位置
        结果
        rv

      • getX

        @BeanProperty(bound=false)
public int getX()
        返回组件原点的当前x坐标。 此方法优于写入component.getBounds().x或component.getLocation().x因为它不会导致任何堆分配。
        重写：
        getX类 Component
        结果
        组件原点的当前x坐标

      • getY

        @BeanProperty(bound=false)
public int getY()
        返回组件原点的当前y坐标。 此方法优于编写component.getBounds().y或component.getLocation().y因为它不会导致任何堆分配。
        重写：
        getY类 Component
        结果
        组件原点的当前y坐标

      • getWidth

        @BeanProperty(bound=false)
public int getWidth()
        返回此组件的当前宽度。 此方法优于编写component.getBounds().width或component.getSize().width因为它不会导致任何堆分配。
        重写：
        getWidth在 Component类中
        结果
        此组件的当前宽度

      • getHeight

        @BeanProperty(bound=false)
public int getHeight()
        返回此组件的当前高度。 此方法优于编写component.getBounds().height或component.getSize().height因为它不会导致任何堆分配。
        重写：
        getHeight在类 Component
        结果
        此组件的当前高度

      • isOpaque

        public boolean isOpaque()
        如果此组件完全不透明，则返回true。

        不透明组件绘制其矩形边界内的每个像素。 非不透明组件仅绘制其像素的子集或根本不绘制，允许其下方的像素“显示”。 因此，未完全绘制其像素的组件提供了一定程度的透明度。

        保证始终完全绘制其内容的子类应重写此方法并返回true。

        重写：
        isOpaque在类 Component
        结果
        如果此组件完全不透明，则为true
        另请参见：
        setOpaque(boolean)

      • setOpaque

        @BeanProperty(expert=true,
              description="The component\'s opacity")
public void setOpaque​(boolean isOpaque)
        如果为true，则组件绘制其边界内的每个像素。 否则，组件可能不会绘制其部分或全部像素，从而允许底层像素显示。

        对于JComponent ，此属性的默认值为false。 但是，大多数标准JComponent子类（例如JButton和JTree ）上此属性的默认值取决于外观。

        参数
        isOpaque - 如果此组件不透明， isOpaque true
        另请参见：
        isOpaque()

      • computeVisibleRect

        public void computeVisibleRect​(Rectangle visibleRect)
        返回Component的“可见矩形矩形” - 此组件及其所有祖先的可见矩形的交集。 返回值存储在visibleRect 。
        参数
        visibleRect - 一个 Rectangle计算为此组件及其所有祖先的所有可见矩形的交集 - 这是此方法的返回值
        另请参见：
        getVisibleRect()

      • getVisibleRect

        @BeanProperty(bound=false)
public Rectangle getVisibleRect()
        返回 Component的“可见矩形” - 此组件的可见矩形 new Rectangle(0, 0, getWidth(), getHeight())及其所有祖先的可见矩形的交集。
        结果
        可见的矩形

      • firePropertyChange

        public void firePropertyChange​(String propertyName,
                               boolean oldValue,
                               boolean newValue)
        支持报告布尔属性的绑定属性更改。 绑定属性发生更改时，可以调用此方法，并将相应的PropertyChangeEvent发送到任何已注册的PropertyChangeListeners。
        重写：
        firePropertyChange类 Component
        参数
        propertyName - 其值已更改的属性
        oldValue - 该物业以前的价值
        newValue - 该物业的新价值

      • firePropertyChange

        public void firePropertyChange​(String propertyName,
                               int oldValue,
                               int newValue)
        支持报告整数属性的绑定属性更改。 绑定属性发生更改时，可以调用此方法，并将相应的PropertyChangeEvent发送到任何已注册的PropertyChangeListeners。
        重写：
        firePropertyChange类 Component
        参数
        propertyName - 其值已更改的属性
        oldValue - 该物业以前的价值
        newValue - 该物业的新价值

      • fireVetoableChange

        protected void fireVetoableChange​(String propertyName,
                                  Object oldValue,
                                  Object newValue)
                           throws PropertyVetoException
        支持报告受限制的属性更改。 当约束属性发生变化时，可以调用此方法，并将相应的PropertyChangeEvent发送到任何已注册的VetoableChangeListeners 。
        参数
        propertyName - 已侦听的属性的名称
        oldValue - 该属性的旧值
        newValue - 该物业的新值
        异常
        PropertyVetoException - 当组件 PropertyVetoException设置属性的尝试时

      • addVetoableChangeListener

        public void addVetoableChangeListener​(VetoableChangeListener listener)
        将VetoableChangeListener添加到侦听器列表中。 监听器已注册所有属性。
        参数
        listener - 要添加的 VetoableChangeListener

      • removeVetoableChangeListener

        public void removeVetoableChangeListener​(VetoableChangeListener listener)
        从侦听器列表中删除VetoableChangeListener 。 这将删除已为所有属性注册的VetoableChangeListener 。
        参数
        listener - 要删除的 VetoableChangeListener

      • getTopLevelAncestor

        @BeanProperty(bound=false)
public Container getTopLevelAncestor()
        返回此组件的顶级祖先（包含 Window或 Applet ）或 null如果此组件尚未添加到任何容器）。
        结果
        此组件所在的顶级 Container ，如果不在任何容器中， null

      • addAncestorListener

        public void addAncestorListener​(AncestorListener listener)
        注册listener以便在其或其任何祖先移动或变得可见或不可见时接收AncestorEvents 。 当从包含层次结构中添加或删除组件或其祖先时，也会发送事件。
        参数
        listener - AncestorListener注册
        另请参见：
        AncestorEvent

      • getListeners

        public <T extends EventListener> T[] getListeners​(类<T> listenerType)
        在此JComponent返回当前注册为FooListener的所有对象的数组。 FooListener s使用addFooListener方法注册。

        您可以使用类文字指定listenerType参数，例如FooListener.class 。 例如，您可以使用以下代码查询JComponent c以获取其鼠标侦听器： 

          MouseListener[] mls = (MouseListener[])(c.getListeners(MouseListener.class));
        如果不存在此类侦听器，则此方法返回空数组。
        重写：
        getListeners类 Container
        参数类型
        T - 监听器的类型
        参数
        listenerType - 要求的听众类型; 此参数应指定从java.util.EventListener的接口
        结果
        此组件上注册为 FooListener的所有对象的数组，如果未添加此类侦听器，则为空数组
        异常
        ClassCastException - 如果 listenerType未指定实现 java.util.EventListener的类或接口
        从以下版本开始：
        1.3
        另请参见：
        getVetoableChangeListeners() ， getAncestorListeners()

      • revalidate

        public void revalidate()
        支持延迟自动布局。

        调用invalidate ，然后将此组件的validateRoot添加到需要验证的组件列表中。 在调度所有当前待处理事件之后将进行验证。 换句话说，在调用此方法之后，将验证在向上遍历此组件的包含层次结构时找到的第一个validateRoot（如果有）。 默认情况下， JRootPane ， JScrollPane和JTextField回真正从isValidateRoot 。

        当属性值发生更改以使此组件的大小，位置或内部布局受到影响时，将自动在此组件上调用此方法。 这种自动更新与AWT不同，因为程序通常不再需要调用validate来获取GUI的内容以进行更新。

        重写：
        revalidate在类 Component
        另请参见：
        Component.invalidate() ， Container.validate() ， isValidateRoot() ， RepaintManager.addInvalidComponent(javax.swing.JComponent)

      • isOptimizedDrawingEnabled

        @BeanProperty(bound=false)
public boolean isOptimizedDrawingEnabled()
        如果此组件平铺其子项，则返回true - 即，它是否可以保证子项不会重叠。 在这种常见情况下，重新绘制系统实质上更有效。 JComponent无法进行此保证的子类（例如JLayeredPane ）应覆盖此方法以返回false。
        结果
        总是返回true

      • paintImmediately

        public void paintImmediately​(int x,
                             int y,
                             int w,
                             int h)
        立即绘制此组件中指定区域及其与区域重叠的所有后代。

        很少需要调用此方法。 在大多数情况下，调用重绘更有效，这会延迟实际绘制，并可以将冗余请求折叠到单个绘制调用中。 如果在调度当前事件时需要更新显示，则此方法很有用。

        当需要为绘制原点的组件更改脏区域时，将覆盖此方法。

        参数
        x - 要绘制的区域的x值
        y - 要绘制的区域的y值
        w - 要绘制区域的宽度
        h - 要绘制区域的高度
        另请参见：
        repaint(long, int, int, int, int) ， isPaintingOrigin()

      • paintImmediately

        public void paintImmediately​(Rectangle r)
        现在绘制指定的区域。
        参数
        r - 包含要绘制区域的 Rectangle

      • setDoubleBuffered

        public void setDoubleBuffered​(boolean aFlag)
        设置此组件是否应使用缓冲区进行绘制。 如果设置为true，则此组件中的所有绘图都将在屏幕外绘制缓冲区中完成。 屏幕外的绘画缓冲区将被复制到屏幕上。 如果Component被缓冲并且其祖先之一也被缓冲，则将使用祖先缓冲区。
        参数
        aFlag - 如果为true，则将此组件设置为双缓冲

      • isDoubleBuffered

        public boolean isDoubleBuffered()
        返回此组件是否应使用缓冲区进行绘制。
        重写：
        isDoubleBuffered在 Component类
        结果
        如果此组件是双缓冲的，则为true，否则为false

      • getRootPane

        @BeanProperty(bound=false)
public JRootPane getRootPane()
        返回此组件的 JRootPane祖先。
        结果
        该 JRootPane包含此组件，或 null如果没有 JRootPane发现

      • paramString

        protected String paramString()
        返回此JComponent的字符串表示JComponent 。 此方法仅用于调试目的，返回字符串的内容和格式可能因实现而异。 返回的字符串可能为空，但可能不是null 。
        重写：
        paramString类 Container
        结果
        此 JComponent的字符串表示 JComponent