模块 java.desktop
包 javax.swing

类 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 delegate 提供——一个从 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 派生的任何对象相关联。
  • 一种绘画基础设施，包括双缓冲和对边界的支持。有关详细信息，请参阅 Painting 和 如何使用边框，它们都是 The Java Tutorial 中的部分。
有关这些主题的更多信息，请参阅 Swing package description 和 The Java Tutorial 部分 JComponent 类。

JComponent 及其子类记录了某些属性的默认值。例如，JTable 将默认行高记录为 16。每个具有 ComponentUI 的 JComponent 子类都将创建 ComponentUI 作为其构造函数的一部分。为了提供特定的外观和感觉，每个 ComponentUI 都可以将属性设置回创建它的 JComponent。例如，自定义外观可能需要 JTable 的行高为 24。记录的默认值是安装 ComponentUI 之前的属性值。如果您需要特定属性的特定值，您应该显式设置它。

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

在 1.4 版中，焦点子系统被重新设计。有关更多信息，请参阅 如何使用焦点子系统，The Java Tutorial 中的一个部分。

Warning: Swing 不是线程安全的。有关详细信息，请参阅 Swing 的线程策略。

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

自从：
1.2
参见：

  • 字段详细信息

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

  • 构造方法详细信息

    • JComponent

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

  • 方法详情

    • setInheritsPopupMenu

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

      这个的默认值为 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 - - 将分配给该组件的弹出窗口可能为空
      自从：
      1.5
      参见：

    • getComponentPopupMenu

      public JPopupMenu  getComponentPopupMenu()
      返回分配给该组件的 JPopupMenu。如果此组件没有分配给它的 JPopupMenu 并且 getInheritsPopupMenu 为真，这将返回 getParent().getComponentPopupMenu()（假设父项有效。）
      返回：
      JPopupMenu 分配给这个组件或 null 如果没有分配弹出窗口
      自从：
      1.5
      参见：

    • updateUI

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

    • getUI

      public ComponentUI  getUI()
      返回呈现此组件的外观委托。
      返回：
      呈现此组件的 ComponentUI 对象
      自从：
      9

    • setUI

      @BeanProperty (hidden =true, visualUpdate =true, description ="The component\'s look and feel delegate.") protected void setUI(ComponentUI  newUI)
      设置此组件的外观委托。 JComponent 子类通常重写此方法以缩小参数类型。例如，在 JSlider 中： 
       public void setUI(SliderUI newUI) {
   super.setUI(newUI);
 }

      此外，JComponent 子类必须提供返回正确类型的 getUI 方法。例如：

       public SliderUI getUI() {
   return (SliderUI)ui;
 }
      参数：
      newUI - 新的 UI 委托
      参见：

    • getUIClassID

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

    • 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 的实现，则必须遵守不透明属性，也就是说，如果此组件是不透明的，则必须用不透明的颜色完全填充背景。如果您不尊重不透明属性，您可能会看到视觉伪影。

      传入的 Graphics 对象可能具有安装在其上的识别转换以外的转换。在这种情况下，如果您累积应用另一个转换，您可能会得到意想不到的结果。

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

    • paintChildren

      protected void paintChildren(Graphics  g)
      绘制此组件的子项。如果 shouldUseBuffer 为真，则没有组件祖先有缓冲区，如果有缓冲区，子组件可以使用缓冲区。否则，一个祖先有一个当前正在使用的缓冲区，孩子不应该使用缓冲区来绘画。
      参数：
      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。它们按列出的顺序调用，以确保子组件出现在组件本身的顶部。一般来说，组件及其子组件不应在分配给边框的insets区域中绘制。子类可以一如既往地覆盖此方法。只想专门化 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，将为另一个图块再次调用 paint。如果您没有绘制瓷砖或最后一个瓷砖已绘制，则此方法返回 false。使用此方法可以在图块之间保持您可能需要的某些状态。
      返回：
      如果组件当前正在绘制图块，则为 true，否则为 false

    • isPaintingForPrint

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

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

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

      返回：
      如果此组件上的当前绘制操作是打印操作的一部分，则为真
      自从：
      1.6
      参见：

    • isManagingFocus

      @Deprecated @BeanProperty (bound =false) public boolean isManagingFocus()
      已弃用。
      从 1.4 开始，由 Component.setFocusTraversalKeys(int, Set) 和 Container.setFocusCycleRoot(boolean) 取代。
      在 1.4 版中，焦点子系统被重新设计。有关更多信息，请参阅 如何使用焦点子系统，The Java Tutorial 中的一个部分。

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

      返回：
      false
      参见：

    • setNextFocusableComponent

      @Deprecated public void setNextFocusableComponent(Component  aComponent)
      已弃用。
      从 1.4 开始，由 FocusTraversalPolicy 取代
      在 1.4 版中，焦点子系统被重新设计。有关更多信息，请参阅 如何使用焦点子系统，The Java Tutorial 中的一个部分。

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

      参数：
      aComponent - 在焦点遍历循环中应该跟在这个 JComponent 之后的 Component
      参见：

    • getNextFocusableComponent

      @Deprecated public Component  getNextFocusableComponent()
      已弃用。
      从 1.4 开始，由 FocusTraversalPolicy 取代。
      在 1.4 版中，焦点子系统被重新设计。有关更多信息，请参阅 如何使用焦点子系统，The Java Tutorial 中的一个部分。

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

      返回：
      在焦点遍历循环中将跟随此 JComponent 的 Component，如果未明确指定，则为 null
      参见：

    • setRequestFocusEnabled

      public void setRequestFocusEnabled(boolean requestFocusEnabled)
      提供关于此 JComponent 是否应获得焦点的提示。这只是一个提示，这取决于要求关注此属性的消费者。这通常适用于鼠标操作，但不适用于键盘操作。例如，外观可以在鼠标操作期间请求焦点之前验证此属性是否为真。如果您不希望在 JComponent 上按下鼠标以窃取焦点，但又希望 JComponent 可通过键盘遍历，则通常会使用此方法。如果您根本不想让这个 JComponent 可聚焦，请改用 setFocusable 方法。

      请参阅 如何使用焦点子系统，The Java Tutorial 中的一个部分，了解更多信息。

      参数：
      requestFocusEnabled - 指示您是否希望此 JComponent 可聚焦
      参见：

    • isRequestFocusEnabled

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

      请参阅 如何使用焦点子系统，The Java Tutorial 中的一个部分，了解更多信息。

      返回：
      true 如果该组件应该获得焦点，否则返回 false
      参见：

    • requestFocus

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

      请注意，不鼓励使用此方法，因为它的行为取决于平台。相反，我们建议使用 requestFocusInWindow() 。如果您想了解有关焦点的更多信息，请参阅 如何使用焦点子系统，The Java Tutorial 中的一个部分。

      重写：
      requestFocus 在类 Component 中
      自从：
      1.4
      参见：

    • requestFocus

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

      请注意，不鼓励使用此方法，因为它的行为取决于平台。相反，我们建议使用 requestFocusInWindow(boolean) 。如果您想了解有关焦点的更多信息，请参阅 如何使用焦点子系统，The Java Tutorial 中的一个部分。

      重写：
      requestFocus 在类 Component 中
      参数：
      temporary - 指示焦点更改是否为临时的boolean
      返回：
      false 如果焦点更改请求一定会失败； true是否有可能成功
      自从：
      1.4
      参见：

    • requestFocusInWindow

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

      如果您想了解有关焦点的更多信息，请参阅 如何使用焦点子系统，The Java Tutorial 中的一个部分。

      重写：
      requestFocusInWindow 在类 Component 中
      返回：
      false 如果焦点更改请求一定会失败； true是否有可能成功
      自从：
      1.4
      参见：

    • requestFocusInWindow

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

      如果您想了解有关焦点的更多信息，请参阅 如何使用焦点子系统，The Java Tutorial 中的一个部分。

      重写：
      requestFocusInWindow 在类 Component 中
      参数：
      temporary - 指示焦点更改是否为临时的boolean
      返回：
      false 如果焦点更改请求一定会失败； true是否有可能成功
      自从：
      1.4
      参见：

    • grabFocus

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

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

      参见：

    • setVerifyInputWhenFocusTarget

      @BeanProperty (description ="Whether the Component verifies input before accepting focus.") public void setVerifyInputWhenFocusTarget(boolean verifyInputWhenFocusTarget)
      设置值以指示是否在此组件请求焦点之前调用当前焦点所有者的输入验证程序。默认为真。在取消按钮或滚动条等组件上设置为 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 为空
      自从：
      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，则为真
      参见：

    • setBorder

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

      尽管从技术上讲，您可以在继承自 JComponent 的任何对象上设置边框，但许多标准 Swing 组件的外观实现与用户设置的边框配合不佳。一般情况下，当你想在JPanel或JLabel以外的标准Swing组件上设置边框时，我们建议你将组件放在JPanel中，并在JPanel上设置边框。

      这是绑定属性。

      参数：
      border - 要为此组件呈现的边框
      参见：

    • getBorder

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

    • getInsets

      @BeanProperty (expert =true) public Insets  getInsets()
      如果已在此组件上设置了边框，则返回边框的 insets；否则调用 super.getInsets 。
      重写：
      getInsets 在类 Container 中
      返回：
      insets 属性的值
      参见：

    • getInsets

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

    • getInputVerifier

      public InputVerifier  getInputVerifier()
      返回此组件的输入验证器。
      返回：
      inputVerifier 属性
      自从：
      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 按位或运算到当前值

    • getDebugGraphicsOptions

      public int getDebugGraphicsOptions()
      返回图形调试的状态。
      返回：
      零个或多个以下选项的按位或标志：
      • 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
      当击键发生时组件具有焦点或组件位于具有焦点的窗口中时将调用该操作。请注意，组件不必是窗口的直接后代——它可以位于窗口包含层次结构中的任何位置。换句话说，只要窗口中的 any 组件获得焦点，就会调用向该组件注册的操作。
      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 之一
      返回：
      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()
      返回用于确定为特定 KeyStroke 绑定触发什么 Action 的 ActionMap。除非另有设置，否则返回的 ActionMap 会将 UI 中的 ActionMap 设置为父级。
      返回：
      包含键/操作绑定的 ActionMap
      自从：
      1.3

    • getBaseline

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

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

      重写：
      getBaselineResizeBehavior 在类 Component 中
      返回：
      一个枚举，指示基线如何随着组件大小的变化而变化
      自从：
      1.6
      参见：

    • requestDefaultFocus

      @Deprecated public boolean requestDefaultFocus()
      已弃用。
      从 1.4 开始，由 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 的locale属性的默认locale。默认locale具有“AppContext”范围，因此小程序（以及可能在单个 VM 中运行的多个轻量级应用程序）可以有自己的设置。 applet 可以安全地更改其默认locale，因为它不会影响其他 applet（或浏览器）。
      返回：
      默认 Locale 。
      自从：
      1.4
      参见：

    • setDefaultLocale

      public static void setDefaultLocale(Locale  l)
      设置用于在创建时初始化每个 JComponent 的locale属性的默认locale。初始值是 VM 的默认区域设置。默认locale具有“AppContext”范围，因此小程序（以及可能在单个 VM 中运行的多个轻量级应用程序）可以有自己的设置。 applet 可以安全地更改其默认locale，因为它不会影响其他 applet（或浏览器）。传递 null 会将当前locale重置回 VM 的默认locale。
      参数：
      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 的键绑定作为 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
      自从：
      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 中的 如何使用工具提示。

      参数：
      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（JTable、JList、JTree、JTextArea 和 JEditorPane）中的 Swing 组件都已经以这种方式处理了鼠标拖动事件。要在任何其他组件中启用自动滚动，请添加一个调用 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

      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 ，此方法还会安装一个newDropTarget 在组件上通过 TransferHandler 激活掉落处理并激活任何内置支持（例如计算和显示潜在的掉落位置）。如果您不希望此组件以任何方式响应掉落，您可以通过删除掉落目标 (setDropTarget(null)) 或停用它 (getDropTaget().setActive(false)) 来完全禁用掉落支持。

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

      在两种情况下，此方法不会修改放置目标：首先，如果此组件上的现有放置目标已由开发人员明确设置为 non-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()
      已弃用。
      从 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 中

    • 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 之一，或者如果击键包含 null，或者如果任何击键表示 KEY_TYPED 事件，或者如果任何击键已经映射到此组件的另一个焦点遍历操作
      自从：
      1.5
      参见：

    • isLightweightComponent

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

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

    • 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 中
      返回：
      如果此组件完全不透明，则为真
      参见：

    • setOpaque

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

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

      参数：
      isOpaque - 如果该组件不透明则为真
      参见：

    • 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 s 或一个空数组（如果当前没有注册可否决的更改监听器）
      自从：
      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 的所有对象的数组。 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
      参见：

    • 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 将导致验证以该根开头的整个树。默认返回假。 JScrollPane 覆盖此方法并返回 true。
      重写：
      isValidateRoot 在类 Container 中
      返回：
      总是返回 false
      参见：

    • isOptimizedDrawingEnabled

      @BeanProperty (bound =false) public boolean isOptimizedDrawingEnabled()
      如果此组件平铺其子项，则返回 true —— 也就是说，如果它可以保证子项不会重叠。在这种常见情况下，重绘系统的效率要高得多。 JComponent 无法做出此保证的子类，例如 JLayeredPane ，应覆盖此方法以返回 false。
      返回：
      总是返回真

    • 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 - 如果为真，则将此组件设置为双缓冲

    • 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()
      已弃用。
      重写：
      hide 在类 Component 中