Module  java.desktop
软件包  javax.swing

Class JComponent

    • 字段详细信息

      • ui

        protected transient ComponentUI ui
        该组件的外观和感觉委托。

      • listenerList

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

      • WHEN_FOCUSED

        public static final int WHEN_FOCUSED
        用于 registerKeyboardAction常量，这意味着当组件具有焦点时应该调用该命令。
        另请参见：
        Constant Field Values

      • WHEN_ANCESTOR_OF_FOCUSED_COMPONENT

        public static final int WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
        常量用于 registerKeyboardAction ，这意味着当接收组件是聚焦组件的祖先或者本身是聚焦组件时，应该调用该命令。
        另请参见：
        Constant Field Values

      • WHEN_IN_FOCUSED_WINDOW

        public static final int WHEN_IN_FOCUSED_WINDOW
        常量用于 registerKeyboardAction ，这意味着当接收组件在具有焦点的窗口中或者本身是聚焦组件时，应该调用该命令。
        另请参见：
        Constant Field Values

      • UNDEFINED_CONDITION

        public static final int UNDEFINED_CONDITION
        一些API使用的常量意味着没有定义任何条件。
        另请参见：
        Constant Field Values

      • TOOL_TIP_TEXT_KEY

        public static final String TOOL_TIP_TEXT_KEY
        当光标在组件上方时显示的注释，也称为“值提示”，“天桥帮助”或“飞越标签”。
        另请参见：
        Constant Field Values

    • 构造方法详细信息

      • JComponent

        public JComponent​()
        默认JComponent构造函数。 这个构造函数在调用Container构造函数之前做的很少。 例如，初始布局管理器是null 。 但是，它将组件的区域设置属性设置为返回的值为JComponent.getDefaultLocale 。
        另请参见：
        getDefaultLocale()

    • 方法详细信息

      • setInheritsPopupMenu

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

        默认值为false，但是实现为JComponent的数量的一些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 。 用户界面负责注册绑定并添加必要的监听器，以便在适当的时候显示JPopupMenu 。 当显示JPopupMenu取决于外观和感觉：有些可能会在鼠标事件上显示，有些可能会启用键绑定。

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

        这是一个绑定属性。

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

      • getComponentPopupMenu

        public JPopupMenu getComponentPopupMenu​()
        返回分配给此组件的JPopupMenu 。 如果此组件没有分配JPopupMenu ，并且getInheritsPopupMenu为true，则返回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的paint方法，如果UI null 。 我们通过委托一份Graphics对象的副本，以保护其他油漆代码免受不可撤销的更改（例如， Graphics.translate ）。

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

        在Graphics对象中传递的对象可能具有除安装的标识变换之外的变换。 在这种情况下，如果累积应用另一个变换，您可能会得到意想不到的结果。

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

      • paintChildren

        protected void paintChildren​(Graphics g)
        涂抹这个组件的孩子。 如果shouldUseBuffer为真，则没有组件祖先具有缓冲区，并且子组件可以使用缓冲区（如果有）。 否则，一个祖先有一个缓冲区当前正在使用，孩子不应该使用缓冲区来绘制。
        参数
        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​()
        如果组件当前正在绘制图块，则返回true。 如果此方法返回true，则将再次为另一个tile调用paint。 如果不绘制瓷砖，或者如果最后一个瓷砖被绘制，则此方法返回false。 使用这种方法来保持一些可能需要的状态。
        结果
        如果组件当前正在绘制图块，则为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)
        已过时。 截至1.4，由FocusTraversalPolicy替换
        在1.4版本中，重点子系统被重新设计。 有关更多信息，请参阅“Java教程”中的“ How to Use the Focus Subsystem ”一节。

        通过无条件地将指定的Component设置为下一个Component中的Component ，并覆盖该JComponent的焦点遍历周期的默认FocusTraversalPolicy JComponent ，而该JComponent为该周期中指定的Component以前的Component 。

        参数
        aComponent - Component应该遵循这个 JComponent在焦点遍历周期
        另请参见：
        getNextFocusableComponent() ， FocusTraversalPolicy

      • getNextFocusableComponent

        @Deprecated
public Component getNextFocusableComponent​()
        已过时。 截至1.4，由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 ，请改用setFocusable方法。

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

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

      • grabFocus

        public void grabFocus​()
        请求此组件获取输入焦点，并且该组件的顶级祖先成为关注的窗口。 此组件必须可显示，可见和可聚焦才能被授予请求。

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

        另请参见：
        requestFocusInWindow()

      • setVerifyInputWhenFocusTarget

        @BeanProperty(description="Whether the Component verifies input before accepting focus.")
public void setVerifyInputWhenFocusTarget​(boolean verifyInputWhenFocusTarget)
        设置该值以指示在此组件请求焦点之前是否调用当前焦点所有者的输入验证器。 默认值为true。 在诸如取消按钮或滚动条的组件上设置为假，即使当前焦点所有者的输入未被该组件的输入验证器“传递”时，也应激活。
        参数
        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 - a包含所需最大允许尺寸的 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对象负责定义组件的插入（覆盖直接在组件上设置的任何Border ），并且可选地在这些插入的边界内渲染任何边框装饰。 应使用边框（而不是插图）来创建摆动部件的装饰性和非装饰性（如边距和填充）区域。 复合边框可用于在单个组件中嵌套多个边框。

        虽然技术上您可以在JComponent继承的任何对象上设置边框，但许多标准Swing组件的外观和感觉实现在用户设置边框上不能正常工作。 一般来说，当您要在JPanel或JLabel之外的标准Swing组件上设置边框时，我们建议您将组件置于JPanel ，并将边框设置为JPanel 。

        这是一个绑定属性。

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

      • getInsets

        public Insets getInsets​(Insets insets)
        返回包含此组件的插入值的Insets对象。 如果可能的话，传入的Insets对象将被重用。 调用方法不能假定相同的对象将被返回。 此对象内的所有现有值都将被覆盖。 如果insets为空，则会分配一个新的。
        参数
        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是按位OR'进入当前值

      • getDebugGraphicsOptions

        public int getDebugGraphicsOptions​()
        返回图形调试状态。
        结果
        0或更多以下选项的按位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放置一个虚拟绑定有效地禁止绑定从不发生。

        取消注册键盘操作。 这将删除从结合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通常在第二层中定义）中定义的绑定持续存在。

      • setInputMap

        public final void setInputMap​(int condition,
                              InputMap map)
        在InputMap到condition的条件下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 s不应该将该组件对准其基线。

        该方法调用同名的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，则使用此方法。 该方法可以返回BaselineResizeBehavior.OTHER以外的值，即使getBaseline返回小于0的值。

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

      • requestDefaultFocus

        @Deprecated
public boolean requestDefaultFocus​()
        已过时。 截至1.4，由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的locale属性的默认区域设置。 默认语言环境具有“AppContext”范围，以便小程序（以及可能在单个VM中运行的多个轻量级应用程序）可以拥有自己的设置。 小程序可以安全地更改其默认语言环境，因为它将对其他小程序（或浏览器）没有影响。
        结果
        默认为 Locale 。
        从以下版本开始：
        1.4
        另请参见：
        setDefaultLocale(java.util.Locale) ， Component.getLocale() ， Component.setLocale(java.util.Locale)

      • setDefaultLocale

        public static void setDefaultLocale​(Locale l)
        设置用于在创建时初始化每个JComponent的区域设置属性的默认区域设置。 初始值是VM的默认语言环境。 默认语言环境具有“AppContext”范围，以便小程序（以及可能在单个VM中运行的多个轻量级应用程序）可以拥有自己的设置。 小程序可以安全地更改其默认语言环境，因为它将对其他小程序（或浏览器）没有影响。
        参数
        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)
        作为KeyEvent e的结果，调用处理ks的键绑定。 获得适当的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)
        注册文本以显示在工具提示。 当光标停留在组件上时，显示文本。

        有关更多文档，请参阅Java教程中的 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)
        向JComponent的父母转发scrollRectToVisible()消息。 可以对请求进行服务的组件（如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 。 合成事件使得看起来拖动手势已经在组件边界被越过时建立的方向恢复。 支持自动滚动的组件必须通过使用包含鼠标事件位置的矩形来调用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 - 如果真的，当鼠标拖动到组件边界之外并鼠标按钮继续按住时，将生成合成鼠标拖动事件; 否则为虚假
        另请参见：
        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​()
        已过时。 从JDK 1.1版开始，由java.awt.Component.setEnabled(boolean)代替。
        重写：
        enable中的 Component

      • disable

        @Deprecated
public void disable​()
        已过时。 从JDK 1.1版开始，由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，也就是说，如果该组件没有本机窗口系统对等体，则返回true。
        参数
        c - 要检查的 Component
        结果
        如果该组件是轻量级的，则为true

      • reshape

        @Deprecated
public void reshape​(int x,
                    int y,
                    int w,
                    int h)
        已过时。 截至JDK 5，由Component.setBounds(int, int, int, int)替换。

        移动并调整此组件的大小。

        描述从类复制： 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更component.getBounds().x ，因为它不会导致任何堆分配。
        重写：
        getX在 Component
        结果
        组件原点的当前x坐标

      • getY

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

      • getWidth

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

      • getHeight

        @BeanProperty(bound=false)
public int getHeight​()
        返回此组件的当前高度。 这种方法比component.getBounds().height或component.getSize().height更component.getBounds().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)
        如果为真，组件将绘制其边界内的每个像素。 否则，组件可能不会绘制其部分或全部像素，从而允许底层像素显示。

        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发送适当的PropertyChangeEvent。
        重写：
        firePropertyChange在 Component
        参数
        propertyName - 其值已更改的属性
        oldValue - 该物业的以前的价值
        newValue - 物业的新价值

      • firePropertyChange

        public void firePropertyChange​(String propertyName,
                               int oldValue,
                               int newValue)
        支持报告整数属性的绑定属性更改。 当绑定属性已更改时，可以调用此方法，并且将向适当的PropertyChangeEvent发送适当的PropertyChangeEvent。
        重写：
        firePropertyChange在 Component
        参数
        propertyName - 其值已更改的属性
        oldValue - 该物业的以前的价值
        newValue - 该物业的新价值

      • fireVetoableChange

        protected void fireVetoableChange​(String propertyName,
                                  Object oldValue,
                                  Object newValue)
                           throws PropertyVetoException
        支持报告受限的属性更改。 当受限属性已更改时，可以调用此方法，并将适当的PropertyChangeEvent发送到任何已注册的VetoableChangeListeners 。
        参数
        propertyName - 收听的财产的名称
        oldValue - 该物业的旧值
        newValue - 该属性的新值
        异常
        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​(Class<T> listenerType)
        返回此JComponent当前注册为FooListener的所有对象的数组。 FooListener使用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 - a 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的字符串表示