Module java.desktop
Package javax.swing

Class JComponent

java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
所有已实现的接口:
ImageObserver, MenuContainer, Serializable
直接已知的子类:
AbstractButton, BasicInternalFrameTitlePane, Box, Box.Filler, JColorChooser, JComboBox, JFileChooser, JInternalFrame, JInternalFrame.JDesktopIcon, JLabel, JLayer, JLayeredPane, JList, JMenuBar, JOptionPane, JPanel, JPopupMenu, JProgressBar, JRootPane, JScrollBar, JScrollPane, JSeparator, JSlider, JSpinner, JSplitPane, JTabbedPane, JTable, JTableHeader, JTextComponent, JToolBar, JToolTip, JTree, JViewport
@JavaBean(defaultProperty="UIClassID") public abstract class JComponent extends Container implements Serializable
所有 Swing 组件的基类，除了顶级容器。要使用继承自 JComponent 的组件，必须将该组件放置在一个包含层次结构中，其根是一个顶级 Swing 容器。顶级 Swing 容器 -- 例如 JFrame、JDialog 和 JApplet -- 是提供其他 Swing 组件绘制自身的专用组件。有关包含层次结构的解释，请参阅 Swing 组件和包含层次结构，这是 The Java Tutorial 中的一节。

JComponent 类提供：

  • 标准和自定义组件都使用 Swing 架构的基类。
  • 可由程序员指定或（可选地）在运行时由用户选择的“可插入外观”（L&F）。每个组件的外观由一个 UI 代理 提供 -- 一个从 ComponentUI 继承的对象。有关更多信息，请参阅 The Java Tutorial 中的 如何设置外观。
  • 全面的按键处理。有关详细信息，请参阅文档 如何使用按键绑定，这是 The Java Tutorial 中的一篇文章。
  • 支持工具提示 -- 当光标停留在组件上时弹出的简短描述。有关更多信息，请参阅 The Java Tutorial 中的 如何使用工具提示。
  • 支持辅助功能。 JComponent 包含 Accessible 接口中的所有方法，但它实际上并未实现该接口。这是扩展 JComponent 的各个类的责任。
  • 支持组件特定的属性。使用 putClientProperty(java.lang.Object, java.lang.Object) 和 getClientProperty(java.lang.Object) 方法，您可以将名称-对象对与任何从 JComponent 继承的对象关联起来。
  • 用于绘制的基础设施，包括双缓冲和边框支持。有关更多信息，请参阅 绘制 和 如何使用边框，这两个都是 The Java Tutorial 中的部分。
有关这些主题的更多信息，请参阅 Swing 包描述 和 The Java Tutorial 中的部分 JComponent 类。

JComponent 及其子类记录了某些属性的默认值。例如，JTable 将默认行高度记录为 16。每个具有 ComponentUI 的 JComponent 子类将在其构造函数中创建 ComponentUI。为了提供特定的外观和感觉，每个 ComponentUI 可能会在创建它的 JComponent 上设置属性。记录的默认值是在安装 ComponentUI 之前的属性值。如果需要特定属性的特定值，应明确设置它。

JComponent 可以包含任意数量的默认或初始组件作为子组件。这种行为可能会根据外观和感觉而改变，因此对于特定外观和感觉，JComponent 可能包含一些默认或初始组件作为子组件，而对于其他外观和感觉则可能不包含。在特定外观和感觉中，这种行为也可能根据 JComponent 的配置属性而改变。总之，不能假定一个 JComponent 没有子组件，只因为应用程序没有直接添加它们。

在 1.4 版本中，焦点子系统进行了重新架构。有关更多信息，请参阅 如何使用焦点子系统，这是 The Java Tutorial 中的一节。

警告: Swing 不是线程安全的。有关更多信息，请参阅 Swing 的线程策略。

警告: 该类的序列化对象将不兼容未来的 Swing 版本。当前的序列化支持适用于短期存储或在运行相同版本的 Swing 的应用程序之间进行 RMI。从 1.4 版本开始，已将所有 JavaBeans 的长期存储支持添加到 java.beans 包中。请参阅 XMLEncoder。

自 JDK 版本:
1.2
参见:

  • Field Details

    • 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
      当光标悬停在组件上时显示的注释，也称为“值提示”、“悬停帮助”或“悬停标签”。
      参见：

  • Constructor Details

    • JComponent

      public JComponent()
      默认的JComponent构造函数。此构造函数除了调用Container构造函数外，几乎不进行任何初始化。例如，初始布局管理器为null。但是，它会将组件的区域设置属性设置为JComponent.getDefaultLocale返回的值。
      参见：

  • Method Details

    • 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
      参见：

    • getInheritsPopupMenu

      public boolean getInheritsPopupMenu()
      如果应从父级继承JPopupMenu，则返回true。
      返回：
      如果应从父级继承JPopupMenu，则返回true
      自：
      1.5
      参见：

    • setComponentPopupMenu

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

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

      这是一个绑定属性。

      参数：
      popup - 将分配给此组件的弹出菜单，可以为null
      自：
      1.5
      参见：

    • getComponentPopupMenu

      public JPopupMenu getComponentPopupMenu()
      返回为此组件分配的JPopupMenu。如果此组件未分配JPopupMenu，并且getInheritsPopupMenu为true，则返回getParent().getComponentPopupMenu()（假设父级有效）。
      返回：
      为此组件分配的JPopupMenu或如果未分配弹出菜单则返回null
      自：
      1.5
      参见：

    • updateUI

      public void updateUI()
      调用此方法以将UI属性更新为当前外观的值。 JComponent子类必须像这样重写此方法： 
         public void updateUI() {
      setUI((SliderUI)UIManager.getUI(this);
   }
      实现要求：
      此方法的默认实现不执行任何操作。
      参见：

    • getUI

      public ComponentUI getUI()
      返回用于绘制此组件的图形对象。如果打开了DebugGraphics，我们将根据需要创建新的DebugGraphics对象。否则，我们只需配置指定的图形对象的前景和字体。
      Returns:
      the ComponentUI object that renders this component
      Since:
      9

    • setUI

      @BeanProperty(hidden=true, visualUpdate=true, description="The component\'s look and feel delegate.") protected void setUI(ComponentUI newUI)
      Sets the look and feel delegate for this component. JComponent subclasses generally override this method to narrow the argument type. For example, in JSlider: 
       public void setUI(SliderUI newUI) {
     super.setUI(newUI);
 }

      Additionally JComponent subclasses must provide a getUI method that returns the correct type. For example:

       public SliderUI getUI() {
     return (SliderUI)ui;
 }
      Parameters:
      newUI - the new UI delegate
      See Also:

    • getUIClassID

      @BeanProperty(bound=false, expert=true, description="UIClassID") public String getUIClassID()
      Returns the UIDefaults key used to look up the name of the swing.plaf.ComponentUI class that defines the look and feel for this component. Most applications will never need to call this method. Subclasses of JComponent that support pluggable look and feel should override this method to return a UIDefaults key that maps to the ComponentUI subclass that defines their look and feel.
      Returns:
      the UIDefaults key for a ComponentUI subclass
      See Also:

    • getComponentGraphics

      protected Graphics getComponentGraphics(Graphics g)
      Returns the graphics object used to paint this component. If DebugGraphics is turned on we create a new DebugGraphics object if necessary. Otherwise we just configure the specified graphics object's foreground and font.
      参数:
      g - 原始的 Graphics 对象
      返回:
      配置为此组件的 Graphics 对象

    • paintComponent

      protected void paintComponent(Graphics g)
      调用UI代理的绘制方法，如果UI代理不为非 null。我们传递给代理一个 Graphics 对象的副本，以保护其余的绘制代码免受不可逆转的更改（例如，Graphics.translate）。

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

      传入的 Graphics 对象可能具有除标识变换之外的其他变换。在这种情况下，如果您累积应用另一个变换，则可能会得到意外的结果。

      参数:
      g - 要保护的 Graphics 对象
      参见:

    • paintChildren

      protected void paintChildren(Graphics g)
      绘制此组件的子组件。如果 shouldUseBuffer 为 true，则没有组件祖先具有缓冲区，组件子组件可以使用缓冲区（如果有）。否则，一个祖先当前正在使用缓冲区，子组件不应使用缓冲区进行绘制。
      参数:
      g - 要绘制的 Graphics 上下文
      参见:

    • paintBorder

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

      如果您在子类中重写此方法，不应对传入的 Graphics 进行永久更改。例如，不应更改剪辑 Rectangle 或修改变换。如果需要执行这些操作，可能更容易创建一个新的 Graphics，并从传入的 Graphics 进行操作。

      参数:
      g - 要绘制的 Graphics 上下文
      参见:

    • update

      public void update(Graphics g)
      调用 paint。不清除背景，但请参阅 ComponentUI.update，该方法由 paintComponent 调用。
      覆盖:
      update 在类 Container
      参数:
      g - 要绘制的 Graphics 上下文
      参见:

    • paint

      public void paint(Graphics g)
      Swing调用以绘制组件。应用程序不应直接调用 paint，而应使用 repaint 方法安排组件重新绘制。

      此方法实际上将绘制工作委托给三个受保护的方法：paintComponent、paintBorder 和 paintChildren。它们按照列出的顺序调用，以确保子组件显示在组件自身之上。一般来说，组件及其子组件不应在分配给边框的插图区域内绘制。子类可以像往常一样只覆盖此方法。如果子类只想专门化UI（外观和感觉）代理的 paint 方法，只需覆盖 paintComponent。

      覆盖:
      paint 在类 Container
      参数:
      g - 要绘制的 Graphics 上下文
      参见:

    • printAll

      public void printAll(Graphics g)
      调用此方法以打印组件。此方法在组件上调用 print。
      覆盖:
      printAll 在类 Component
      参数:
      g - 要绘制的 Graphics 上下文
      参见:

    • 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

      protected void printComponent(Graphics g)
      在打印操作期间调用此方法。此方法实现为在组件上调用 paintComponent。如果希望在打印时添加特殊的绘制行为，请覆盖此方法。
      参数:
      g - 要绘制的 Graphics 上下文
      自:
      1.3
      参见:

    • printChildren

      protected void printChildren(Graphics g)
      打印此组件的子组件。此方法实现为在组件上调用 paintChildren。如果希望以不同于绘制的方式打印子组件，请覆盖此方法。
      参数:
      g - 要绘制的 Graphics 上下文
      自:
      1.3
      参见:

    • printBorder

      protected void printBorder(Graphics g)
      打印组件的边框。此方法实现为在组件上调用 paintBorder。如果希望以不同于绘制的方式打印边框，请覆盖此方法。
      参数:
      g - 要绘制的 Graphics 上下文
      自:
      1.3
      参见:

    • isPaintingTile

      @BeanProperty(bound=false) public boolean isPaintingTile()
      如果组件当前正在绘制瓦片，则返回 true。如果此方法返回 true，则将为另一个瓦片再次调用绘制。如果您不是在绘制瓦片或上一个瓦片已绘制，则此方法返回 false。使用此方法保留您可能在瓦片之间需要的一些状态。
      返回:
      如果组件当前正在绘制瓦片，则返回 true，否则返回 false

    • isPaintingForPrint

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

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

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

      返回值:
      如果此组件上的当前绘画操作是打印操作的一部分，则返回true
      自版本:
      1.6
      另请参阅:

    • isManagingFocus

      @Deprecated @BeanProperty(bound=false) public boolean isManagingFocus()
      Deprecated.
      As of 1.4, replaced by Component.setFocusTraversalKeys(int, Set) and Container.setFocusCycleRoot(boolean).
      在1.4版本中，焦点子系统进行了重新架构。有关更多信息，请参阅如何使用焦点子系统，这是Java教程中的一节。

      将此JComponent的焦点遍历键更改为CTRL+TAB和CTRL+SHIFT+TAB。还会阻止SortingFocusTraversalPolicy在计算焦点遍历循环时考虑此JComponent的后代。

      返回值:
      false
      另请参阅:

    • setNextFocusableComponent

      @Deprecated public void setNextFocusableComponent(Component aComponent)
      Deprecated.
      As of 1.4, replaced by FocusTraversalPolicy
      在1.4版本中，焦点子系统进行了重新架构。有关更多信息，请参阅如何使用焦点子系统，这是Java教程中的一节。

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

      参数:
      aComponent - 应在焦点遍历循环中跟随此JComponent的Component
      另请参阅:

    • getNextFocusableComponent

      @Deprecated public Component getNextFocusableComponent()
      Deprecated.
      As of 1.4, replaced by FocusTraversalPolicy.
      在1.4版本中，焦点子系统进行了重新架构。有关更多信息，请参阅如何使用焦点子系统，这是Java教程中的一节。

      返回通过先前调用setNextFocusableComponent(Component)在此JComponent上设置的Component。

      返回值:
      将在焦点遍历循环中跟随此JComponent的Component，如果未明确指定，则返回null
      另请参阅:

    • setRequestFocusEnabled

      public void setRequestFocusEnabled(boolean requestFocusEnabled)
      提供关于此JComponent是否应该获得焦点的提示。这仅是一个提示，由请求焦点的消费者来遵守此属性。通常情况下，这会在鼠标操作中受到尊重，但在键盘操作中不会。例如，外观和感觉可能会在鼠标操作期间验证此属性为true，然后请求焦点。如果您不希望鼠标在JComponent上按下时窃取焦点，但希望JComponent可以通过键盘遍历，则通常会使用此属性。如果您根本不希望此JComponent可获得焦点，请改用setFocusable方法。

      有关更多信息，请参阅如何使用焦点子系统，这是Java教程中的一节。

      参数:
      requestFocusEnabled - 指示您是否希望此JComponent可获得焦点
      另请参阅:

    • isRequestFocusEnabled

      public boolean isRequestFocusEnabled()
      返回true如果此JComponent应该获得焦点；否则返回false。

      有关更多信息，请参阅如何使用焦点子系统，这是Java教程中的一节。

      返回值:
      如果此组件应该获得焦点，则返回true，否则返回false
      另请参阅:

    • requestFocus

      public void requestFocus()
      请求此Component获得输入焦点。有关此方法的完整描述，请参阅Component.requestFocus()。

      请注意，不建议使用此方法，因为其行为依赖于平台。相反，我们建议使用requestFocusInWindow()。如果您想要更多关于焦点的信息，请参阅如何使用焦点子系统，这是Java教程中的一节。

      覆盖:
      requestFocus 在类 Component中
      自版本:
      1.4
      另请参阅:

    • requestFocus

      public boolean requestFocus(boolean temporary)
      请求此Component获得输入焦点。有关此方法的完整描述，请参阅Component.requestFocus(boolean)。

      请注意，不建议使用此方法，因为其行为依赖于平台。相反，我们建议使用requestFocusInWindow(boolean)。如果您想要更多关于焦点的信息，请参阅如何使用焦点子系统，这是Java教程中的一节。

      覆盖:
      requestFocus 在类 Component中
      参数:
      temporary - 指示焦点更改是否是临时的布尔值
      返回值:
      如果焦点更改请求肯定会失败，则返回false；如果可能会成功，则返回true
      自版本:
      1.4
      另请参阅:

    • requestFocusInWindow

      public boolean requestFocusInWindow()
      请求此Component获得输入焦点。有关此方法的完整描述，请参阅Component.requestFocusInWindow()。

      如果您想要更多关于焦点的信息，请参阅如何使用焦点子系统，这是Java教程中的一节。

      覆盖:
      requestFocusInWindow 在类 Component中
      返回值:
      如果焦点更改请求肯定会失败，则返回false；如果可能会成功，则返回true
      自版本:
      1.4
      另请参阅:

    • requestFocusInWindow

      protected boolean requestFocusInWindow(boolean temporary)
      请求此Component获得输入焦点。有关此方法的完整描述，请参阅Component.requestFocusInWindow(boolean)。

      如果您想要更多关于焦点的信息，请参阅如何使用焦点子系统，这是Java教程中的一节。

      覆盖:
      requestFocusInWindow 在类 Component中
      参数:
      temporary - 表示焦点变化是否是临时的布尔值
      返回:
      如果焦点变化请求肯定会失败，则返回false; 如果可能成功，则返回true
      自从:
      1.4
      参见:

    • grabFocus

      public void grabFocus()
      请求此组件获取输入焦点，并使此组件的顶级祖先成为焦点窗口。为了满足请求，此组件必须是可显示的、可见的和可聚焦的。

      此方法旨在供焦点实现使用。客户端代码不应使用此方法；而应使用requestFocusInWindow()。

      参见:

    • setVerifyInputWhenFocusTarget

      @BeanProperty(description="Whether the Component verifies input before accepting focus.") public void setVerifyInputWhenFocusTarget(boolean verifyInputWhenFocusTarget)
      设置一个值，指示在此组件请求焦点之前是否会调用当前焦点所有者的输入验证器。默认值为true。对于诸如取消按钮或滚动条等应在当前焦点所有者的输入验证器未通过的情况下激活的组件，将其设置为false。
      参数:
      verifyInputWhenFocusTarget - verifyInputWhenFocusTarget属性的值
      自从:
      1.3
      参见:

    • getVerifyInputWhenFocusTarget

      public boolean getVerifyInputWhenFocusTarget()
      返回一个值，指示在此组件请求焦点之前是否会调用当前焦点所有者的输入验证器。
      返回:
      verifyInputWhenFocusTarget属性的值
      自从:
      1.3
      参见:

    • getFontMetrics

      public FontMetrics getFontMetrics(Font font)
      获取指定Font的FontMetrics。
      覆盖:
      getFontMetrics 在类 Component中
      参数:
      font - 要获取字体度量的字体
      返回:
      font的字体度量
      抛出:
      NullPointerException - 如果font为null
      自从:
      1.5
      参见:

    • setPreferredSize

      @BeanProperty(preferred=true, description="The preferred size of the component.") public void setPreferredSize(Dimension preferredSize)
      设置此组件的首选大小。如果preferredSize为null，则将请求UI提供首选大小。
      覆盖:
      setPreferredSize 在类 Component中
      参数:
      preferredSize - 新的首选大小，或null
      参见:

    • getPreferredSize

      public Dimension getPreferredSize()
      如果preferredSize已设置为非null值，则只返回它。如果UI委托的getPreferredSize方法返回非null值，则返回该值；否则将延迟到组件的布局管理器。
      覆盖:
      getPreferredSize 在类 Container中
      返回:
      preferredSize属性的值
      参见:

    • setMaximumSize

      @BeanProperty(description="The maximum size of the component.") public void setMaximumSize(Dimension maximumSize)
      将此组件的最大大小设置为一个常量值。随后调用getMaximumSize将始终返回此值；组件的UI将不会被要求计算它。将最大大小设置为null将恢复默认行为。
      覆盖:
      setMaximumSize 在类 Component中
      参数:
      maximumSize - 包含所需最大允许大小的Dimension
      参见:

    • getMaximumSize

      public Dimension getMaximumSize()
      如果最大大小已设置为非null值，则只返回它。如果UI委托的getMaximumSize方法返回非null值，则返回该值；否则将延迟到组件的布局管理器。
      覆盖:
      getMaximumSize 在类 Container中
      返回:
      maximumSize属性的值
      参见:

    • setMinimumSize

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

    • getMinimumSize

      public Dimension getMinimumSize()
      如果最小大小已设置为非null值，则只返回它。如果UI委托的getMinimumSize方法返回非null值，则返回该值；否则将延迟到组件的布局管理器。
      覆盖:
      getMinimumSize 在类 Container中
      返回:
      minimumSize属性的值
      参见:

    • contains

      public boolean contains(int x, int y)
      为了鼠标处理的目的，让UI委托有机会定义此组件的精确形状。
      覆盖:
      contains 在类 Component中
      参数:
      x - 点的x坐标
      y - 点的y坐标
      返回:
      如果此组件在逻辑上包含x，y，则返回true
      参见:

    • setBorder

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

      尽管在任何继承自JComponent的对象上都可以设置边框，但许多标准Swing组件的外观和感觉实现与用户设置的边框不兼容。通常，当您想要在标准Swing组件（除了JPanel或JLabel）上设置边框时，我们建议将组件放在JPanel中，并在JPanel上设置边框。

      这是一个绑定属性。

      参数:
      border - 要为此组件渲染的边框
      参见:

    • getBorder

      public Border getBorder()
      返回此组件的边框，如果当前未设置边框，则返回null。
      返回:
      此组件的边框对象
      参见:

    • getInsets

      @BeanProperty(expert=true) public Insets getInsets()
      如果在此组件上设置了边框，则返回边框的插图；否则调用super.getInsets。
      覆盖:
      getInsets 在类 Container
      返回:
      插图属性的值
      参见:

    • getInsets

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

    • getAlignmentY

      public float getAlignmentY()
      覆盖Container.getAlignmentY以返回垂直对齐。
      覆盖:
      getAlignmentY 在类 Container
      返回:
      alignmentY属性的值
      参见:

    • setAlignmentY

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

    • getAlignmentX

      public float getAlignmentX()
      覆盖Container.getAlignmentX以返回水平对齐。
      覆盖:
      getAlignmentX 在类 Container
      返回:
      alignmentX属性的值
      参见:

    • setAlignmentX

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

    • setInputVerifier

      @BeanProperty(description="The component\'s input verifier.") public void setInputVerifier(InputVerifier inputVerifier)
      为此组件设置输入验证器。
      参数:
      inputVerifier - 新的输入验证器
      自1.3起:
      1.3
      参见:

    • getInputVerifier

      public InputVerifier getInputVerifier()
      返回此组件的输入验证器。
      返回:
      inputVerifier属性
      自1.3起:
      1.3
      参见:

    • getGraphics

      @BeanProperty(bound=false) public Graphics getGraphics()
      返回此组件的图形上下文，允许您在组件上绘制。使用此方法获取Graphics对象，然后在该对象上调用操作以在组件上绘制。
      覆盖:
      getGraphics 在类 Component
      返回:
      此组件的图形上下文
      参见:

    • 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。
      • DebugGraphics.NONE_OPTION 禁用调试。
      • 值为0不会更改调试选项。
      debugOptions按位OR到当前值中

    • getDebugGraphicsOptions

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

    • 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方法。

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

      如果指定了，aCommand将在传递的事件中设置。

      aCondition可以是以下之一：

      WHEN_FOCUSED
      仅当组件具有焦点时才会调用该操作。
      WHEN_IN_FOCUSED_WINDOW
      当组件具有焦点或组件位于具有焦点的窗口中时将调用该操作。请注意，组件不必是窗口的直接后代 - 它可以位于窗口的包含层次结构的任何位置。换句话说，只要窗口中的任何组件具有焦点，就会调用与该组件注册的操作。
      WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
      当组件具有焦点或组件是具有焦点的组件的祖先时将调用该操作。

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

      如果为接收容器已经注册了一个具有相同charCode和相同修饰符的动作，则anAction将替换该动作。

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

    • registerKeyboardAction

      public void registerKeyboardAction(ActionListener anAction, KeyStroke aKeyStroke, int aCondition)
      此方法现在已过时，请使用getActionMap()和getInputMap()的组合来实现类似的行为。
      参数:
      anAction - 要注册到给定按键和条件的动作
      aKeyStroke - 一个KeyStroke
      aCondition - 与给定按键和动作关联的条件
      参见:

    • unregisterKeyboardAction

      public void unregisterKeyboardAction(KeyStroke aKeyStroke)
      该方法现已过时。要注销现有绑定，您可以从ActionMap/InputMap中删除绑定，或者在InputMap中放置一个虚拟绑定。从InputMap中删除绑定允许父InputMap中的绑定保持活动，而在InputMap中放置一个虚拟绑定将有效地禁用绑定的发生。

      注销键盘操作。这将从ActionMap（如果存在）以及InputMap中删除绑定。

      参数:
      aKeyStroke - 要注销其键盘操作的按键

    • getRegisteredKeyStrokes

      @BeanProperty(bound=false) public KeyStroke[] getRegisteredKeyStrokes()
      返回将启动已注册操作的KeyStrokes。
      返回:
      一个KeyStroke对象数组
      参见:

    • getConditionForKeyStroke

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

      对于Java 2平台v1.3，一个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下使用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)
      返回在condition期间使用的InputMap。
      参数:
      condition - WHEN_IN_FOCUSED_WINDOW、WHEN_FOCUSED、WHEN_ANCESTOR_OF_FOCUSED_COMPONENT之一
      返回:
      指定condition的InputMap
      自:
      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()
      返回用于确定特定KeyStroke绑定触发哪个Action的ActionMap。返回的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

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

      此方法调用同名的ComponentUI方法。如果此组件没有ComponentUI，将返回BaselineResizeBehavior.OTHER。子类永远不应返回null；如果无法计算基线，则返回BaselineResizeBehavior.OTHER。调用者应首先使用getBaseline请求基线，如果返回值大于等于0，则使用此方法。即使getBaseline返回小于0的值，此方法也可以返回BaselineResizeBehavior.OTHER以外的值。

      覆盖:
      getBaselineResizeBehavior 在类 Component
      返回:
      指示组件大小变化时基线如何变化的枚举
      自:
      1.6
      参见:

    • requestDefaultFocus

      @Deprecated public boolean requestDefaultFocus()
      Deprecated.
      As of 1.4, replaced by FocusTraversalPolicy.getDefaultComponent(Container).requestFocus()
      在1.4版本中，焦点子系统进行了重新架构。有关更多信息，请参阅如何使用焦点子系统，这是The Java Tutorial中的一个部分。

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

      返回:
      如果此组件可以请求获取输入焦点，则为true，否则为false
      参见:

    • setVisible

      @BeanProperty(hidden=true, visualUpdate=true) public void setVisible(boolean aFlag)
      使组件可见或不可见。覆盖Component.setVisible。
      覆盖:
      setVisible 在类 Component
      参数:
      aFlag - true表示使组件可见；false表示使其不可见
      参见:

    • setEnabled

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

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

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

      覆盖:
      setEnabled 在类 Component
      参数:
      enabled - 如果应启用此组件，则为true；否则为false
      参见:

    • setForeground

      @BeanProperty(preferred=true, visualUpdate=true, description="The foreground color of the component.") public void setForeground(Color fg)
      设置此组件的前景色。由外观和感觉来决定是否遵守此属性，有些可能选择忽略它。
      覆盖：
      setForeground 在类 Component中
      参数：
      fg - 所需的前景色Color
      参见：

    • 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
      参见：

    • setFont

      @BeanProperty(preferred=true, visualUpdate=true, description="The font for the component.") public void setFont(Font font)
      设置此组件的字体。
      覆盖：
      setFont 在类 Container中
      参数：
      font - 此组件所需的Font
      参见：

    • getDefaultLocale

      public static Locale getDefaultLocale()
      返回用于初始化每个JComponent的区域属性的默认区域设置。默认区域设置具有“AppContext”范围，以便小程序（以及潜在的在单个VM中运行的多个轻量级应用程序）可以拥有自己的设置。小程序可以安全地更改其默认区域设置，因为它不会影响其他小程序（或浏览器）。
      返回：
      默认的Locale。
      自：
      1.4
      参见：

    • setDefaultLocale

      public static void setDefaultLocale(Locale l)
      设置用于初始化每个JComponent的区域属性的默认区域设置。初始值是VM的默认区域设置。默认区域设置具有“AppContext”范围，以便小程序（以及潜在的在单个VM中运行的多个轻量级应用程序）可以拥有自己的设置。小程序可以安全地更改其默认区域设置，因为它不会影响其他小程序（或浏览器）。传递null将将当前区域设置重置为VM的默认区域设置。
      参数：
      l - 新组件的所需默认Locale
      自：
      1.4
      参见：

    • processComponentKeyEvent

      protected void processComponentKeyEvent(KeyEvent e)
      处理组件本身识别的任何键事件。在焦点管理器和任何感兴趣的侦听器有机会窃取事件之后调用此方法。仅当事件尚未被消耗时才调用此方法。此方法在键盘UI逻辑之前调用。

      此方法被实现为不执行任何操作。如果子类自行处理某些键事件，则通常会重写此方法。如果处理了事件，则应将其消耗。

      参数：
      e - 要处理的事件

    • processKeyEvent

      protected void processKeyEvent(KeyEvent e)
      覆盖processKeyEvent以处理事件。
      覆盖：
      processKeyEvent 在类 Component中
      参数：
      e - 键事件
      参见：

    • processKeyBinding

      protected boolean processKeyBinding(KeyStroke ks, KeyEvent e, int condition, boolean pressed)
      调用以处理ks的键绑定作为KeyEvente的结果。这获取适当的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，则此组件的工具提示将关闭
      参见：

    • getToolTipText

      public String getToolTipText()
      返回使用setToolTipText设置的工具提示字符串。
      返回：
      工具提示的文本
      参见：

    • getToolTipText

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

    • getToolTipLocation

      public Point getToolTipLocation(MouseEvent event)
      返回此组件坐标系统中工具提示的位置。如果返回null，Swing将选择一个位置。默认实现返回null。
      参数：
      event - 导致ToolTipManager显示工具提示的MouseEvent
      返回：
      始终返回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
      参见：

    • 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事件，传入包含鼠标事件位置的矩形。所有支持项目选择并通常显示在JScrollPane中的Swing组件（JTable、JList、JTree、JTextArea和JEditorPane）已经以这种方式处理鼠标拖动事件。要在任何其他组件中启用自动滚动，请添加一个鼠标移动监听器，该监听器调用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，则当鼠标拖动超出组件边界并且鼠标按钮继续按下时，将生成合成鼠标拖动事件；否则为false
      参见:

    • getAutoscrolls

      public boolean getAutoscrolls()
      获取autoscrolls属性。
      返回:
      autoscrolls属性的值
      参见:

    • 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，则此方法将移除拖放目标。

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

      请参阅如何使用拖放和数据传输，这是The Java Tutorial中的一个部分，以获取更多信息。

      参数:
      newHandler - 新的TransferHandler
      自版本:
      1.4
      参见:

    • getTransferHandler

      public TransferHandler getTransferHandler()
      获取transferHandler属性。
      返回:
      transferHandler属性的值
      自版本:
      1.4
      参见:

    • processMouseEvent

      protected void processMouseEvent(MouseEvent e)
      通过将发生在此组件上的鼠标事件分派给任何已注册的MouseListener对象来处理鼠标事件，参见Component.processMouseEvent(MouseEvent)以获取此方法的完整描述。
      覆盖:
      processMouseEvent 在类 Component
      参数:
      e - 鼠标事件
      自版本:
      1.5
      参见:

    • processMouseMotionEvent

      protected void processMouseMotionEvent(MouseEvent e)
      处理鼠标运动事件，例如MouseEvent.MOUSE_DRAGGED。
      覆盖:
      processMouseMotionEvent 在类 Component
      参数:
      e - MouseEvent
      参见:

    • 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

    • getClientProperty

      public final Object getClientProperty(Object key)
      返回具有指定键的属性的值。只有使用putClientProperty添加的属性将返回非null值。
      参数:
      key - 要查询的键
      返回:
      此属性的值或null
      参见:

    • 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，则此方法将删除属性
      参见:

    • setFocusTraversalKeys

      public void setFocusTraversalKeys(int id, Set<? extends AWTKeyStroke> keystrokes)
      为此组件的给定遍历操作设置焦点遍历键。参见Component.setFocusTraversalKeys(int, java.util.Set<? extends java.awt.AWTKeyStroke>)以获取此方法的完整描述。

      如果keystrokes中的任何Object不是AWTKeyStroke，则此方法可能会抛出ClassCastException。

      覆盖:
      setFocusTraversalKeys 在类 Container
      参数:
      id - KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS、KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS或KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS之一
      keystrokes - 指定操作的AWTKeyStroke集合
      抛出:
      IllegalArgumentException - 如果id不是KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS、KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS或KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS之一，或者如果keystrokes包含null，或者如果任何按键表示KEY_TYPED事件，或者如果任何按键已经映射到此组件的另一个焦点遍历操作
      自版本:
      1.5
      参见:

    • 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 - 新的高度
      另请参阅:

    • 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

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

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

      参数:
      isOpaque - 如果此组件应该是不透明的，则为true
      另请参阅:

    • computeVisibleRect

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

    • 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 - 当组件否决设置属性的尝试时

    • addVetoableChangeListener

      public void addVetoableChangeListener(VetoableChangeListener listener)
      向监听器列表中添加一个VetoableChangeListener。该监听器将为所有属性注册。
      参数:
      listener - 要添加的VetoableChangeListener

    • removeVetoableChangeListener

      public void removeVetoableChangeListener(VetoableChangeListener listener)
      从监听器列表中删除一个VetoableChangeListener。这会删除为所有属性注册的VetoableChangeListener。
      参数:
      listener - 要移除的VetoableChangeListener

    • getVetoableChangeListeners

      @BeanProperty(bound=false) public VetoableChangeListener[] getVetoableChangeListeners()
      返回在此组件上注册的所有约束性更改监听器的数组。
      返回:
      返回组件的所有VetoableChangeListener，如果当前没有注册任何vetoable更改侦听器，则返回空数组
      自从:
      1.4
      参见:

    • getTopLevelAncestor

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

    • addAncestorListener

      public void addAncestorListener(AncestorListener listener)
      注册listener，以便在它或其任何祖先移动、显示或隐藏时接收AncestorEvents。当组件或其祖先添加或从包含层次结构中移除时，也会发送事件。
      参数:
      listener - 要注册的AncestorListener
      参见:

    • removeAncestorListener

      public void removeAncestorListener(AncestorListener listener)
      取消注册listener，以便不再接收AncestorEvents。
      参数:
      listener - 要移除的AncestorListener
      参见:

    • getAncestorListeners

      @BeanProperty(bound=false) public AncestorListener[] getAncestorListeners()
      返回在此组件上注册的所有祖先侦听器的数组。
      返回:
      返回组件的所有AncestorListener，如果当前没有注册任何祖先侦听器，则返回空数组
      自从:
      1.4
      参见:

    • getListeners

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

      您可以使用类文字指定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
      参见:

    • addNotify

      public void addNotify()
      通知此组件现在具有父组件。调用此方法时，使用KeyboardAction事件侦听器设置父组件链。此方法由工具包内部调用，不应由程序直接调用。
      覆盖:
      addNotify 在类 Container中
      参见:

    • removeNotify

      public void removeNotify()
      通知此组件现在不再具有父组件。调用此方法时，将删除父组件链中设置的任何KeyboardAction。此方法由工具包内部调用，不应由程序直接调用。
      覆盖:
      removeNotify 在类 Container中
      参见:

    • repaint

      public void repaint(long tm, int x, int y, int width, int height)
      如果组件正在显示，则将指定区域添加到脏区域列表中。在所有当前挂起的事件都已分派后，将重新绘制组件。
      覆盖:
      repaint 在类 Component中
      参数:
      tm - 此参数未使用
      x - 脏区域的x值
      y - 脏区域的y值
      width - 脏区域的宽度
      height - 脏区域的高度
      参见:

    • repaint

      public void repaint(Rectangle r)
      如果组件正在显示，则将指定区域添加到脏区域列表中。在所有当前挂起的事件都已分派后，将重新绘制组件。
      参数:
      r - 包含脏区域的Rectangle
      参见:

    • revalidate

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

      调用invalidate，然后将此组件的validateRoot添加到需要验证的组件列表中。验证将在所有当前挂起的事件都已分派后进行。换句话说，在调用此方法后，当遍历此组件的包含层次结构时找到的第一个validateRoot（如果有）将被验证。默认情况下，JRootPane、JScrollPane和JTextField从isValidateRoot返回true。

      当属性值更改导致此组件的大小、位置或内部布局受到影响时，此方法将自动调用此组件。此自动更新与AWT不同，因为程序通常不再需要调用validate来更新GUI的内容。

      覆盖:
      revalidate 在类 Component中
      参见:

    • isValidateRoot

      public boolean isValidateRoot()
      如果此方法返回true，则此组件的后代调用revalidate将导致从此根开始的整个树被验证。默认情况下返回false。 JScrollPane覆盖此方法并返回true。
      覆盖:
      isValidateRoot 在类 Container中
      返回:
      始终返回false
      参见:

    • isOptimizedDrawingEnabled

      @BeanProperty(bound=false) public boolean isOptimizedDrawingEnabled()
      如果此组件平铺其子组件，则返回true -- 也就是说，它可以保证子组件不会重叠。在这种常见情况下，重绘系统效率更高。不能保证此点的JComponent子类（例如JLayeredPane）应覆盖此方法并返回false。
      返回:
      始终返回true

    • isPaintingOrigin

      protected boolean isPaintingOrigin()
      返回true如果子组件上触发的绘制应该导致绘制起始于此组件或其祖先之一。

      在Swing组件上调用repaint(long, int, int, int, int)或paintImmediately(int, int, int, int)将导致调用第一个祖先的paintImmediately(int, int, int, int)方法，如果有任何一个祖先的isPaintingOrigin()返回true。

      JComponent子类如果需要在其任何子组件被重绘时进行重绘，应该重写此方法返回true。

      返回:
      始终返回false
      参见:

    • paintImmediately

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

      很少需要调用此方法。在大多数情况下，调用repaint更有效，它会推迟实际绘制并可以将冗余请求合并为单个绘制调用。如果需要在当前事件被分派时更新显示，则此方法很有用。

      当需要更改脏区域以用于绘制起始组件时，应该重写此方法。

      参数:
      x - 要绘制的区域的x值
      y - 要绘制的区域的y值
      w - 要绘制的区域的宽度
      h - 要绘制的区域的高度
      参见:

    • 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，如果未找到JRootPane则返回null

    • paramString

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

    • hide

      @Deprecated public void hide()
      Deprecated.
      覆盖:
      hide 在类 Component