模块 java.desktop
包 java.awt

类 Component

java.lang.Object
java.awt.Component
所有已实现的接口：
ImageObserver , MenuContainer , Serializable
已知子类：
Button , Canvas , Checkbox , Choice , Container , Label , List , Scrollbar , TextComponent
public abstract class Component extends Object implements ImageObserver , MenuContainer , Serializable
component 是一个具有图形表示的对象，可以显示在屏幕上并可以与用户交互。组件的示例是典型图形用户界面的按钮、复选框和滚动条。

Component 类是非菜单相关的抽象窗口工具包组件的抽象超类。 Component 类也可以直接扩展以创建轻量级组件。轻量级组件是不与本机窗口相关联的组件。相反，重量级组件与本机窗口相关联。 isLightweight() 方法可以用来区分这两种组件。

轻量级和重量级组件可以混合在一个组件层次结构中。然而，为了正确操作这种混合层次结构的组件，整个层次结构必须有效。当层次结构失效时，例如更改组件的边界，或向容器添加/从容器中删除组件后，必须通过在层次结构的最顶层无效容器上调用的 Container.validate() 方法来验证整个层次结构。

连载

重要的是要注意，只有符合Serializable协议的AWT 监听器才会在存储对象时被保存。如果 AWT 对象具有未标记为可序列化的监听器，它们将在 writeObject 时间被删除。一如既往，开发人员需要考虑使对象可序列化的含义。需要注意的一种情况是： 
  import java.awt.*;
  import java.awt.event.*;
  import java.io.Serializable;

  class MyApp implements ActionListener, Serializable
  {
    BigObjectThatShouldNotBeSerializedWithAButton bigOne;
    Button aButton = new Button();

    MyApp()
    {
      // Oops, now aButton has a listener with a reference
      // to bigOne!
      aButton.addActionListener(this);
    }

    public void actionPerformed(ActionEvent e)
    {
      System.out.println("Hello There");
    }
  }
在这个例子中，序列化 aButton 本身会导致 MyApp 和它引用的所有内容也被序列化。问题是监听器是巧合的，而不是设计的。要将有关 MyApp 和 ActionListener 可序列化的决策分开，可以使用嵌套类，如下例所示： 
  import java.awt.*;
  import java.awt.event.*;
  import java.io.Serializable;

  class MyApp implements java.io.Serializable
  {
     BigObjectThatShouldNotBeSerializedWithAButton bigOne;
     Button aButton = new Button();

     static class MyActionListener implements ActionListener
     {
       public void actionPerformed(ActionEvent e)
       {
         System.out.println("Hello There");
       }
     }

     MyApp()
     {
       aButton.addActionListener(new MyActionListener());
     }
  }

笔记：有关 AWT 和 Swing 使用的绘制机制的更多信息，包括有关如何编写最有效的绘制代码的信息，请参阅 在 AWT 和 Swing 中绘画。

有关焦点子系统的详细信息，请参阅 如何使用焦点子系统、The Java Tutorial 中的一节和 对焦规格 了解更多信息。

参见：

  • 字段详细信息

    • TOP_ALIGNMENT

      public static final float TOP_ALIGNMENT
      getAlignmentY() 的易用性常量。指定与组件顶部的对齐方式。
      参见：

    • CENTER_ALIGNMENT

      public static final float CENTER_ALIGNMENT
      getAlignmentY 和 getAlignmentX 的易用性常量。指定与组件中心的对齐方式
      参见：

    • BOTTOM_ALIGNMENT

      public static final float BOTTOM_ALIGNMENT
      getAlignmentY 的易用性常量。指定与组件底部的对齐方式。
      参见：

    • LEFT_ALIGNMENT

      public static final float LEFT_ALIGNMENT
      getAlignmentX 的易用性常量。指定组件左侧的对齐方式。
      参见：

    • RIGHT_ALIGNMENT

      public static final float RIGHT_ALIGNMENT
      getAlignmentX 的易用性常量。指定与组件右侧的对齐方式。
      参见：

    • accessibleContext

      protected AccessibleContext  accessibleContext
      与此 Component 关联的 AccessibleContext。

  • 构造方法详细信息

    • Component

      protected Component()
      构造一个新组件。 Component 类可以直接扩展以创建不使用不透明本机窗口的轻量级组件。轻量级组件必须由组件树中较高位置的本机容器托管（例如，由 Frame 对象）。

  • 方法详情

    • getName

      public String  getName()
      获取组件的名称。
      返回：
      该组件的名称
      自从：
      1.1
      参见：

    • setName

      public void setName(String  name)
      将组件的名称设置为指定的字符串。
      参数：
      name - 该组件名称的字符串
      自从：
      1.1
      参见：

    • getParent

      public Container  getParent()
      获取此组件的父级。
      返回：
      该组件的父容器
      自从：
      1.0

    • setDropTarget

      public void setDropTarget(DropTarget  dt)
      将 DropTarget 与此组件相关联。 Component 仅在启用时才会接收丢弃。
      参数：
      dt - DropTarget
      参见：

    • getDropTarget

      public DropTarget  getDropTarget()
      获取与此 Component 关联的 DropTarget。
      返回：
      下降目标

    • getGraphicsConfiguration

      public GraphicsConfiguration  getGraphicsConfiguration()
      获取与此 Component 关联的 GraphicsConfiguration。如果 Component 尚未分配特定的 GraphicsConfiguration ，则返回 Component 对象的顶级容器的 GraphicsConfiguration。如果 Component 已创建，但尚未添加到 Container ，则此方法返回 null 。
      返回：
      Component 或 null 使用的 GraphicsConfiguration
      自从：
      1.3

    • getTreeLock

      public final Object  getTreeLock()
      为 AWT 组件树和布局操作获取此组件的锁定对象（拥有线程同步监视器的对象）。
      返回：
      该组件的锁定对象

    • getToolkit

      public Toolkit  getToolkit()
      获取该组件的工具包。请注意，包含组件的框架控制该组件使用哪个工具包。因此，如果组件从一个框架移动到另一个框架，它使用的工具包可能会改变。
      返回：
      该组件的工具包
      自从：
      1.0

    • isValid

      public boolean isValid()
      确定此组件是否有效。当一个组件在其父容器中的大小和位置正确时，它是有效的，并且它的所有子容器也是有效的。为了考虑对等点的大小要求，组件在首次显示在屏幕上之前会失效。到父容器完全实现时，其所有组件都将有效。
      返回：
      true 如果组件有效，false 否则
      自从：
      1.0
      参见：

    • isDisplayable

      public boolean isDisplayable()
      确定此组件是否可显示。当组件连接到本机屏幕资源时，它是可显示的。

      当一个组件被添加到一个可显示的包含层次结构中或者当它的包含层次结构变得可显示时，它就变得可显示了。当包含层次结构的祖先窗口被打包或可见时，它就可以显示了。

      当组件从可显示的包含层次结构中移除或当其包含层次结构变得不可显示时，组件将变得不可显示。包含层次结构在其祖先窗口被处置时变得不可显示。

      返回：
      true 如果组件是可显示的，false 否则
      自从：
      1.2
      参见：

    • isVisible

      public boolean isVisible()
      确定此组件在其父级可见时是否应可见。组件最初是可见的，但顶级组件除外，例如 Frame 对象。
      返回：
      true 如果组件可见，false 否则
      自从：
      1.0
      参见：

    • getMousePosition

      public Point  getMousePosition() throws HeadlessException
      如果 Component 直接位于鼠标指针下方，则返回鼠标指针在此 Component 的坐标空间中的位置，否则返回 null 。如果 Component 未显示在屏幕上，此方法将返回 null，即使鼠标指针位于显示 Component 的区域上方也是如此。如果 Component 被其他 Component 或本机窗口部分或完全遮挡，则仅当鼠标指针位于 Component 的未遮挡部分上方时，此方法才返回非空值。

      对于 Container s，如果鼠标位于 Container 本身或其任何后代之上，则它返回一个非空值。如果您需要排除儿童，请使用 Container.getMousePosition(boolean) 。

      有时准确的鼠标坐标并不重要，唯一重要的是鼠标指针下是否有特定的Component。如果此方法的返回值为 null ，则鼠标指针不在 Component 正上方。

      返回：
      相对于此 Component 的鼠标坐标，或 null
      抛出：
      HeadlessException - 如果 GraphicsEnvironment.isHeadless() 返回 true
      自从：
      1.5
      参见：

    • isShowing

      public boolean isShowing()
      确定此组件是否显示在屏幕上。这意味着该组件必须是可见的，并且它必须位于一个可见且正在显示的容器中。

      Note: 有时无法检测 Component 是否对用户实际可见。这可能发生在：

      • 该组件已添加到可见的 ScrollPane 但 Component 当前不在滚动窗格的视口中。
      • Component 被另一个 Component 或 Container 遮挡。
      返回：
      true 如果显示组件，false 否则
      自从：
      1.0
      参见：

    • isEnabled

      public boolean isEnabled()
      确定是否启用此组件。启用的组件可以响应用户输入并生成事件。默认情况下，组件最初是启用的。可以通过调用其 setEnabled 方法来启用或禁用组件。
      返回：
      true 如果组件已启用，false 否则
      自从：
      1.0
      参见：

    • setEnabled

      public void setEnabled(boolean b)
      启用或禁用此组件，具体取决于参数 b 的值。启用的组件可以响应用户输入并生成事件。默认情况下，组件最初是启用的。

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

      注意：禁用重量级容器会阻止此容器中的所有组件接收任何输入事件。但是禁用轻量级容器只会影响这个容器。

      参数：
      b - 如果为 true ，则此组件已启用；否则该组件被禁用
      自从：
      1.1
      参见：

    • enable

      @Deprecated public void enable()
      已弃用。
      从 JDK 1.1 版开始，由 setEnabled(boolean) 取代。

    • enable

      @Deprecated public void enable(boolean b)
      已弃用。
      从 JDK 1.1 版开始，由 setEnabled(boolean) 取代。
      启用或禁用此组件。
      参数：
      b - true 启用该组件；否则false

    • disable

      @Deprecated public void disable()
      已弃用。
      从 JDK 1.1 版开始，由 setEnabled(boolean) 取代。

    • isDoubleBuffered

      public boolean isDoubleBuffered()
      如果此组件被绘制到稍后复制到屏幕的屏幕外图像（“缓冲区”），则返回 true。如果启用了双缓冲，支持双缓冲的组件子类应该重写此方法以返回 true。
      返回：
      默认为假

    • enableInputMethods

      public void enableInputMethods(boolean enable)
      启用或禁用此组件的输入方法支持。如果启用了输入方法支持并且组件还处理键事件，则传入事件将提供给当前输入方法，并且仅由组件处理或在输入方法不使用它们时分派给其监听。默认情况下，输入方法支持已启用。
      参数：
      enable - true 启用，false 禁用
      自从：
      1.2
      参见：

    • setVisible

      public void setVisible(boolean b)
      根据参数 b 的值显示或隐藏此组件。

      此方法更改与布局相关的信息，因此使组件层次结构无效。

      参数：
      b - 如果是 true ，则显示此组件；否则，隐藏此组件
      自从：
      1.1
      参见：

    • show

      @Deprecated public void show()
      已弃用。
      从 JDK 1.1 版开始，由 setVisible(boolean) 取代。

    • show

      @Deprecated public void show(boolean b)
      已弃用。
      从 JDK 1.1 版开始，由 setVisible(boolean) 取代。
      使该组件可见或不可见。
      参数：
      b - true 使该组件可见；否则false

    • hide

      @Deprecated public void hide()
      已弃用。
      从 JDK 1.1 版开始，由 setVisible(boolean) 取代。

    • getForeground

      public Color  getForeground()
      获取此组件的前景色。
      返回：
      该组件的前景色；如果此组件没有前景颜色，则返回其父组件的前景颜色
      自从：
      1.0
      参见：

    • setForeground

      public void setForeground(Color  c)
      设置此组件的前景色。
      参数：
      c - 成为该组件前景色的颜色；如果这个参数是null 那么这个组件将继承它父组件的前景色
      自从：
      1.0
      参见：

    • isForegroundSet

      public boolean isForegroundSet()
      返回是否已为此 Component 显式设置前景色。如果此方法返回 false ，则此 Component 正在从祖先那里继承其前景色。
      返回：
      true 如果已为此组件显式设置前景色； false否则。
      自从：
      1.4

    • getBackground

      public Color  getBackground()
      获取此组件的背景颜色。
      返回：
      该组件的背景颜色；如果此组件没有背景色，则返回其父组件的背景色
      自从：
      1.0
      参见：

    • setBackground

      public void setBackground(Color  c)
      设置此组件的背景颜色。

      背景颜色对每个组件的影响不同，受背景颜色影响的组件部分可能因操作系统而异。

      参数：
      c - 成为该组件颜色的颜色；如果此参数为 null ，则此组件将继承其父组件的背景色
      自从：
      1.0
      参见：

    • isBackgroundSet

      public boolean isBackgroundSet()
      返回是否已为此 Component 显式设置背景色。如果此方法返回 false ，则此 Component 正在从祖先那里继承其背景颜色。
      返回：
      true 如果已为该组件显式设置背景颜色； false否则。
      自从：
      1.4

    • getFont

      public Font  getFont()
      获取此组件的字体。
      指定者：
      getFont 在接口 MenuContainer 中
      返回：
      该组件的字体；如果没有为此组件设置字体，则返回其父级的字体
      自从：
      1.0
      参见：

    • setFont

      public void setFont(Font  f)
      设置此组件的字体。

      此方法更改与布局相关的信息，因此使组件层次结构无效。

      参数：
      f - 成为该组件字体的字体；如果这个参数是null那么这个组件将继承它父级的字体
      自从：
      1.0
      参见：

    • isFontSet

      public boolean isFontSet()
      返回是否已为此组件显式设置字体。如果此方法返回 false ，则此 Component 正在从祖先那里继承其字体。
      返回：
      true 如果已为此组件显式设置字体； false否则。
      自从：
      1.4

    • getLocale

      public Locale  getLocale()
      获取此组件的locale。
      返回：
      该组件的locale；如果此组件没有区域设置，则返回其父项的区域设置
      抛出：
      IllegalComponentStateException - 如果 Component 没有自己的locale并且尚未添加到包含层次结构中，以便可以从包含的父级确定locale
      自从：
      1.1
      参见：

    • setLocale

      public void setLocale(Locale  l)
      设置此组件的locale。这是绑定属性。

      此方法更改与布局相关的信息，因此使组件层次结构无效。

      参数：
      l - 成为该组件locale的locale
      自从：
      1.1
      参见：

    • getColorModel

      public ColorModel  getColorModel()
      获取用于在输出设备上显示组件的 ColorModel 实例。
      返回：
      该组件使用的颜色模型
      自从：
      1.0
      参见：

    • getLocation

      public Point  getLocation()
      以指定组件左上角的点的形式获取此组件的位置。该位置将相对于父级的坐标空间。

      由于本机事件处理的异步性质，此方法可能会返回过时的值（例如，在快速连续多次调用 setLocation() 之后）。因此，获取组件位置的推荐方法是在 java.awt.event.ComponentListener.componentMoved() 内，它在操作系统完成移动组件后调用。

      返回：
      Point 的实例，表示组件父级坐标空间中组件边界的左上角
      自从：
      1.1
      参见：

    • getLocationOnScreen

      public Point  getLocationOnScreen()
      以指定屏幕坐标空间中组件左上角的点的形式获取此组件的位置。
      返回：
      Point 的实例，表示屏幕坐标空间中组件边界的左上角
      抛出：
      IllegalComponentStateException - 如果组件没有显示在屏幕上
      参见：

    • location

      @Deprecated public Point  location()
      已弃用。
      从 JDK 1.1 版开始，由 getLocation() 取代。
      返回此组件左上角的位置。
      返回：
      该组件左上角的位置

    • setLocation

      public void setLocation(int x, int y)
      将此组件移动到新位置。新位置的左上角由该组件父级坐标空间中的x 和y 参数指定。

      此方法更改与布局相关的信息，因此使组件层次结构无效。

      参数：
      x - 的x-父坐标空间中新位置左上角的坐标
      y - 的y-父坐标空间中新位置左上角的坐标
      自从：
      1.1
      参见：

    • move

      @Deprecated public void move(int x, int y)
      已弃用。
      从 JDK 1.1 版开始，由 setLocation(int, int) 取代。
      将此组件移动到新位置。
      参数：
      x - 的x-父坐标空间中新位置左上角的坐标
      y - 的y-父坐标空间中新位置左上角的坐标

    • setLocation

      public void setLocation(Point  p)
      将此组件移动到新位置。新位置的左上角由点 p 指定。点 p 在父坐标空间中给出。

      此方法更改与布局相关的信息，因此使组件层次结构无效。

      参数：
      p - 定义新位置左上角的点，在该组件父级的坐标空间中给出
      自从：
      1.1
      参见：

    • getSize

      public Dimension  getSize()
      以 Dimension 对象的形式返回此组件的大小。 Dimension 对象的 height 字段包含此组件的高度，Dimension 对象的 width 字段包含此组件的宽度。
      返回：
      指示此组件大小的 Dimension 对象
      自从：
      1.1
      参见：

    • size

      @Deprecated public Dimension  size()
      已弃用。
      从 JDK 1.1 版开始，由 getSize() 取代。
      以 Dimension 对象的形式返回此组件的大小。
      返回：
      指示此组件大小的 Dimension 对象

    • setSize

      public void setSize(int width, int height)
      调整此组件的大小，使其具有宽度 width 和高度 height。

      此方法更改与布局相关的信息，因此使组件层次结构无效。

      参数：
      width - 此组件的新宽度（以像素为单位）
      height - 该组件的新高度（以像素为单位）
      自从：
      1.1
      参见：

    • resize

      @Deprecated public void resize(int width, int height)
      已弃用。
      从 JDK 1.1 版开始，由 setSize(int, int) 取代。
      调整此组件的大小。
      参数：
      width - 组件的新宽度
      height - 组件的新高度

    • setSize

      public void setSize(Dimension  d)
      调整此组件的大小，使其具有宽度 d.width 和高度 d.height。

      此方法更改与布局相关的信息，因此使组件层次结构无效。

      参数：
      d - 指定该组件新尺寸的维度
      抛出：
      NullPointerException - 如果 d 是 null
      自从：
      1.1
      参见：

    • resize

      @Deprecated public void resize(Dimension  d)
      已弃用。
      从 JDK 1.1 版开始，由 setSize(Dimension) 取代。
      调整此组件的大小，使其具有宽度 d.width 和高度 d.height。
      参数：
      d - 该组件的新尺寸

    • getBounds

      public Rectangle  getBounds()
      以 Rectangle 对象的形式获取此组件的边界。边界指定此组件的宽度、高度和相对于其父级的位置。
      返回：
      指示此组件边界的矩形
      参见：

    • bounds

      @Deprecated public Rectangle  bounds()
      已弃用。
      从 JDK 1.1 版开始，由 getBounds() 取代。
      返回此组件的边界矩形。
      返回：
      该组件的边界矩形

    • setBounds

      public void setBounds(int x, int y, int width, int height)
      移动此组件并调整其大小。左上角的新位置由 x 和 y 指定，新大小由 width 和 height 指定。

      此方法更改与布局相关的信息，因此使组件层次结构无效。

      参数：
      x - 新的x- 该组件的坐标
      y - 新的y- 该组件的坐标
      width - 该组件的新 width
      height - 该组件的新 height
      自从：
      1.1
      参见：

    • reshape

      @Deprecated public void reshape(int x, int y, int width, int height)
      已弃用。
      从 JDK 1.1 版开始，由 setBounds(int, int, int, int) 取代。
      重塑此组件的边界矩形。
      参数：
      x - 的x矩形左上角的坐标
      y - 的y矩形左上角的坐标
      width - 矩形的宽度
      height - 矩形的高度

    • setBounds

      public void setBounds(Rectangle  r)
      移动此组件并调整其大小以符合新的边界矩形 r 。该组件的新位置由 r.x 和 r.y 指定，其新大小由 r.width 和 r.height 指定

      此方法更改与布局相关的信息，因此使组件层次结构无效。

      参数：
      r - 该组件的新边界矩形
      抛出：
      NullPointerException - 如果 r 是 null
      自从：
      1.1
      参见：

    • getX

      public int getX()
      返回组件原点的当前 x 坐标。此方法优于编写 component.getBounds().x 或 component.getLocation().x，因为它不会导致任何堆分配。
      返回：
      组件原点的当前 x 坐标
      自从：
      1.2

    • getY

      public int getY()
      返回组件原点的当前 y 坐标。此方法优于编写 component.getBounds().y 或 component.getLocation().y，因为它不会导致任何堆分配。
      返回：
      组件原点的当前 y 坐标
      自从：
      1.2

    • getWidth

      public int getWidth()
      返回此组件的当前宽度。此方法优于编写 component.getBounds().width 或 component.getSize().width 因为它不会导致任何堆分配。
      返回：
      该组件的当前宽度
      自从：
      1.2

    • getHeight

      public int getHeight()
      返回此组件的当前高度。此方法优于编写 component.getBounds().height 或 component.getSize().height，因为它不会导致任何堆分配。
      返回：
      该组件的当前高度
      自从：
      1.2

    • getBounds

      public Rectangle  getBounds(Rectangle  rv)
      将此组件的边界存储到“返回值”中房车并返回房车.如果 rv 是 null，则分配一个新的 Rectangle。如果调用者希望避免在堆上分配新的 Rectangle 对象，则此版本的 getBounds 很有用。
      参数：
      rv - 返回值，修改为组件边界
      返回：
      房车

    • getSize

      public Dimension  getSize(Dimension  rv)
      将此组件的宽度/高度存储到“返回值”中房车并返回房车.如果 rv 是 null，则分配一个新的 Dimension 对象。如果调用者希望避免在堆上分配新的 Dimension 对象，则此版本的 getSize 很有用。
      参数：
      rv - 返回值，修改为组件大小
      返回：
      房车

    • getLocation

      public Point  getLocation(Point  rv)
      将此组件的 x,y 原点存储到“返回值”中房车并返回房车.如果 rv 是 null，则分配一个新的 Point。如果调用者希望避免在堆上分配新的 Point 对象，则此版本的 getLocation 很有用。
      参数：
      rv - 返回值，修改为组件位置
      返回：
      房车

    • isOpaque

      public boolean isOpaque()
      如果此组件完全不透明，则返回 true，默认情况下返回 false。

      不透明组件绘制其矩形区域内的每个像素。非不透明组件仅绘制其部分像素，允许其下方的像素“显示出来”。因此，未完全绘制其像素的组件提供了一定程度的透明度。

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

      返回：
      如果此组件完全不透明，则为真
      自从：
      1.2
      参见：

    • isLightweight

      public boolean isLightweight()
      轻量级组件没有原生工具包对等体。 Component 和 Container 的子类，除了像 Button 或 Scrollbar 这样的包中定义的那些，都是轻量级的。所有 Swing 组件都是轻量级的。

      如果此组件不可显示，则此方法将始终返回 false，因为无法确定不可显示组件的权重。

      返回：
      如果此组件具有轻量级对等体，则为真；如果它有本地对等点或没有对等点则为 false
      自从：
      1.2
      参见：

    • setPreferredSize

      public void setPreferredSize(Dimension  preferredSize)
      将此组件的首选大小设置为常量值。对 getPreferredSize 的后续调用将始终返回此值。将首选大小设置为 null 可恢复默认行为。
      参数：
      preferredSize - 新的首选大小，或 null
      自从：
      1.5
      参见：

    • isPreferredSizeSet

      public boolean isPreferredSizeSet()
      如果首选大小已设置为非 null 值，则返回 true，否则返回 false。
      返回：
      如果 setPreferredSize 已使用非空值调用，则为真。
      自从：
      1.5

    • getPreferredSize

      public Dimension  getPreferredSize()
      获取此组件的首选大小。
      返回：
      指示此组件的首选大小的维度对象
      参见：

    • preferredSize

      @Deprecated public Dimension  preferredSize()
      已弃用。
      从 JDK 1.1 版开始，由 getPreferredSize() 取代。
      返回组件的首选大小。
      返回：
      组件的首选大小

    • setMinimumSize

      public void setMinimumSize(Dimension  minimumSize)
      将此组件的最小大小设置为常量值。对 getMinimumSize 的后续调用将始终返回此值。将最小大小设置为 null 可恢复默认行为。
      参数：
      minimumSize - 该组件的新最小尺寸
      自从：
      1.5
      参见：

    • isMinimumSizeSet

      public boolean isMinimumSizeSet()
      返回 setMinimumSize 是否已使用非空值调用。
      返回：
      如果 setMinimumSize 已使用非空值调用，则为真。
      自从：
      1.5

    • getMinimumSize

      public Dimension  getMinimumSize()
      获取此组件的最小大小。
      返回：
      指示此组件的最小尺寸的维度对象
      参见：

    • minimumSize

      @Deprecated public Dimension  minimumSize()
      已弃用。
      从 JDK 1.1 版开始，由 getMinimumSize() 取代。
      返回此组件的最小尺寸。
      返回：
      该组件的最小尺寸

    • setMaximumSize

      public void setMaximumSize(Dimension  maximumSize)
      将此组件的最大大小设置为常量值。对 getMaximumSize 的后续调用将始终返回此值。将最大大小设置为 null 可恢复默认行为。
      参数：
      maximumSize - 包含所需的最大允许大小的 Dimension
      自从：
      1.5
      参见：

    • isMaximumSizeSet

      public boolean isMaximumSizeSet()
      如果已将最大大小设置为非 null 值，则返回 true，否则返回 false。
      返回：
      如果 maximumSize 是非 null 则为真，否则为假
      自从：
      1.5

    • getMaximumSize

      public Dimension  getMaximumSize()
      获取此组件的最大大小。
      返回：
      指示此组件的最大尺寸的维度对象
      参见：

    • getAlignmentX

      public float getAlignmentX()
      返回沿 x 轴的对齐方式。这指定组件如何相对于其他组件对齐。该值应为 0 到 1 之间的数字，其中 0 表示沿原点对齐，1 表示离原点最远，0.5 表示居中，等等。
      返回：
      该组件的水平对齐方式

    • getAlignmentY

      public float getAlignmentY()
      返回沿 y 轴的对齐方式。这指定组件如何相对于其他组件对齐。该值应为 0 到 1 之间的数字，其中 0 表示沿原点对齐，1 表示离原点最远，0.5 表示居中，等等。
      返回：
      该组件的垂直对齐方式

    • getBaseline

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

      默认实现返回 -1。支持基线的子类应该适当地覆盖。如果返回值 >= 0，则组件具有任何大小的有效基线 >= 最小大小，getBaselineResizeBehavior 可用于确定基线如何随大小变化。

      参数：
      width - 获取基线的宽度
      height - 获取基线的高度
      返回：
      基线或 < 0 表示没有合理的基线
      抛出：
      IllegalArgumentException - 如果宽度或高度 < 0
      自从：
      1.6
      参见：

    • getBaselineResizeBehavior

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

      默认实现返回 BaselineResizeBehavior.OTHER 。具有基线的子类应该适当地覆盖。子类不应该返回 null ；如果无法计算基线，则返回 BaselineResizeBehavior.OTHER 。调用者应首先使用 getBaseline 请求基线，如果返回值 >= 0，请使用此方法。此方法返回 BaselineResizeBehavior.OTHER 以外的值是可以接受的，即使 getBaseline 返回的值小于 0。

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

    • doLayout

      public void doLayout()
      提示布局管理器布置此组件。这通常在验证组件（更具体地说，容器）时调用。
      参见：

    • layout

      @Deprecated public void layout()
      已弃用。
      从 JDK 1.1 版开始，由 doLayout() 取代。

    • validate

      public void validate()
      验证此组件。

      术语的含义证实由此类的祖先定义。有关详细信息，请参阅 Container.validate() 。

      自从：
      1.0
      参见：

    • invalidate

      public void invalidate()
      使该组件及其祖先无效。

      默认情况下，组件的所有祖先直到层次结构的最顶层容器都被标记为无效。如果 java.awt.smartInvalidate 系统属性设置为 true ，失效会在该组件最近的验证根上停止。标记容器无效的表示需要对容器进行布局。

      当任何与布局相关的信息发生变化时（例如，设置组件的边界，或将组件添加到容器中），将自动调用此方法。

      这个方法可能会被经常调用，所以它应该工作得很快。

      自从：
      1.0
      参见：

    • revalidate

      public void revalidate()
      重新验证组件层次结构直到最近的验证根。

      此方法首先使从该组件开始直到最近的验证根的组件层次结构失效。之后，从最近的验证根开始验证组件层次结构。

      这是一种旨在帮助应用程序开发人员避免手动查找验证根的便捷方法。基本上，它相当于首先调用此组件上的invalidate() 方法，然后调用最近的验证根上的validate() 方法。

      自从：
      1.7
      参见：

    • getGraphics

      public Graphics  getGraphics()
      为此组件创建图形上下文。如果此组件当前不可显示，此方法将返回 null。
      返回：
      此组件的图形上下文，如果没有则为 null
      自从：
      1.0
      参见：

    • getFontMetrics

      public FontMetrics  getFontMetrics(Font  font)
      获取指定字体的字体指标。警告：由于字体指标受 FontRenderContext 影响，而此方法不提供一个指标，因此它只能返回默认渲染上下文的指标，如果使用 Graphics2D 功能，它可能与在组件上渲染时使用的指标不匹配。相反，可以在呈现时通过调用 Font 类上的 Graphics.getFontMetrics() 或文本测量 API 来获取指标。
      参数：
      font - 要获取字体规格的字体
      返回：
      font 的字体指标
      自从：
      1.0
      参见：

    • setCursor

      public void setCursor(Cursor  cursor)
      将光标图像设置为指定的光标。当此组件的 contains 方法针对当前光标位置返回 true 并且此组件可见、可显示且已启用时，将显示此光标图像。设置 Container 的光标会导致该光标显示在容器的所有子组件中，但具有非 null 光标的子组件除外。

      如果 Java 平台实现和/或本机系统不支持更改鼠标光标形状，则该方法可能没有视觉效果。

      参数：
      cursor - Cursor 类定义的常量之一；如果这个参数是 null 那么这个组件将继承它的父组件的游标
      自从：
      1.1
      参见：

    • getCursor

      public Cursor  getCursor()
      获取组件中的游标集。如果组件没有设置游标，则返回其父组件的游标。如果在整个层次结构中没有设置游标，则返回Cursor.DEFAULT_CURSOR。
      返回：
      该组件的光标
      自从：
      1.1
      参见：

    • isCursorSet

      public boolean isCursorSet()
      返回是否已为此组件显式设置光标。如果此方法返回 false ，则此 Component 正在从祖先那里继承其游标。
      返回：
      true 如果已为此组件显式设置光标； false否则。
      自从：
      1.4

    • paint

      public void paint(Graphics  g)
      绘制此组件。

      当应该绘制组件的内容时调用此方法；例如当组件首次显示或损坏并需要维修时。 Graphics参数中的裁剪矩形设置为需要绘制的区域。覆盖此方法的 Component 的子类不需要调用 super.paint(g) 。

      出于性能原因，宽度或高度为零的 Component s 在首次显示时不被视为需要绘画，也不被视为需要修复。

      笔记：有关 AWT 和 Swing 使用的绘制机制的更多信息，包括有关如何编写最有效的绘制代码的信息，请参阅 在 AWT 和 Swing 中绘画。

      参数：
      g - 用于绘画的图形上下文
      自从：
      1.0
      参见：

    • update

      public void update(Graphics  g)
      更新此组件。

      如果此组件不是轻量级组件，AWT 将调用 update 方法以响应对 repaint 的调用。您可以假设背景没有被清除。

      Component的update方法调用该组件的paint方法重绘该组件。此方法通常被需要做额外工作以响应对 repaint 的调用的子类覆盖。覆盖此方法的组件子类应调用 super.update(g) 或直接从其 update 方法调用 paint(g)。

      图形上下文的原点，它的 (0, 0) 坐标点，是这个组件的左上角。图形上下文的裁剪区域是该组件的边界矩形。

      笔记：有关 AWT 和 Swing 使用的绘制机制的更多信息，包括有关如何编写最有效的绘制代码的信息，请参阅 在 AWT 和 Swing 中绘画。

      参数：
      g - 用于更新的指定上下文
      自从：
      1.0
      参见：

    • paintAll

      public void paintAll(Graphics  g)
      绘制此组件及其所有子组件。

      图形上下文的原点，它的 (0, 0) 坐标点，是这个组件的左上角。图形上下文的裁剪区域是该组件的边界矩形。

      参数：
      g - 用于绘画的图形上下文
      自从：
      1.0
      参见：

    • repaint

      public void repaint()
      重新绘制此组件。

      如果此组件是轻量级组件，则此方法会尽快调用此组件的 paint 方法。否则，此方法会尽快调用此组件的 update 方法。

      笔记：有关 AWT 和 Swing 使用的绘制机制的更多信息，包括有关如何编写最有效的绘制代码的信息，请参阅 在 AWT 和 Swing 中绘画。

      自从：
      1.0
      参见：

    • repaint

      public void repaint(long tm)
      重新绘制组件。如果此组件是轻量级组件，这将导致在 tm 毫秒内调用 paint。

      笔记：有关 AWT 和 Swing 使用的绘制机制的更多信息，包括有关如何编写最有效的绘制代码的信息，请参阅 在 AWT 和 Swing 中绘画。

      参数：
      tm - 更新前的最长时间（以毫秒为单位）
      自从：
      1.0
      参见：

    • repaint

      public void repaint(int x, int y, int width, int height)
      重新绘制此组件的指定矩形。

      如果此组件是轻量级组件，则此方法会尽快调用此组件的 paint 方法。否则，此方法会尽快调用此组件的 update 方法。

      笔记：有关 AWT 和 Swing 使用的绘制机制的更多信息，包括有关如何编写最有效的绘制代码的信息，请参阅 在 AWT 和 Swing 中绘画。

      参数：
      x - 的x协调
      y - 的y协调
      width - 宽度
      height - 高度
      自从：
      1.0
      参见：

    • repaint

      public void repaint(long tm, int x, int y, int width, int height)
      在 tm 毫秒内重新绘制此组件的指定矩形。

      如果此组件是轻量级组件，则此方法会调用此组件的 paint 方法。否则，此方法会调用此组件的 update 方法。

      笔记：有关 AWT 和 Swing 使用的绘制机制的更多信息，包括有关如何编写最有效的绘制代码的信息，请参阅 在 AWT 和 Swing 中绘画。

      参数：
      tm - 更新前的最长时间（以毫秒为单位）
      x - 的x协调
      y - 的y协调
      width - 宽度
      height - 高度
      自从：
      1.0
      参见：

    • print

      public void print(Graphics  g)
      打印此组件。对于在打印前必须进行特殊处理或打印与绘制不同的组件，应用程序应重写此方法。

      此方法的默认实现调用 paint 方法。

      图形上下文的原点，它的 (0, 0) 坐标点，是这个组件的左上角。图形上下文的裁剪区域是该组件的边界矩形。

      参数：
      g - 用于打印的图形上下文
      自从：
      1.0
      参见：

    • printAll

      public void printAll(Graphics  g)
      打印此组件及其所有子组件。

      图形上下文的原点，它的 (0, 0) 坐标点，是这个组件的左上角。图形上下文的裁剪区域是该组件的边界矩形。

      参数：
      g - 用于打印的图形上下文
      自从：
      1.0
      参见：

    • imageUpdate

      public boolean imageUpdate(Image  img, int infoflags, int x, int y, int w, int h)
      当图像改变时重新绘制组件。当有关先前使用异步例程（例如 Graphics 的 drawImage 方法）请求的图像的更多信息可用时，将调用 ImageObserver 的 imageUpdate 方法。有关此方法及其参数的更多信息，请参阅 imageUpdate 的定义。

      随着图像的更多位可用，Component 的 imageUpdate 方法逐渐在组件上绘制图像。

      如果系统属性 awt.image.incrementaldraw 缺失或具有值 true ，则图像以增量方式绘制。如果系统属性有任何其他值，则在完全加载之前不会绘制图像。

      此外，如果增量绘制生效，系统属性 awt.image.redrawrate 的值将被解释为一个整数，以提供最大重绘率（以毫秒为单位）。如果系统属性缺失或无法解释为整数，则重绘速率为每 100 毫秒一次。

      x、y、width 和 height 参数的解释取决于 infoflags 参数的值。

      指定者：
      imageUpdate 在接口 ImageObserver 中
      参数：
      img - 正在观察的图像
      infoflags - 请参阅 imageUpdate 了解更多信息
      x - 的x协调
      y - 的y协调
      w - 宽度
      h - 高度
      返回：
      false 如果信息标志表明图像已完全加载； true否则。
      自从：
      1.0
      参见：

    • createImage

      public Image  createImage(ImageProducer  producer)
      从指定的图像生成器创建图像。
      参数：
      producer - 图像制作者
      返回：
      产生的图像
      自从：
      1.0

    • createImage

      public Image  createImage(int width, int height)
      创建一个用于双缓冲的屏幕外可绘制图像。
      参数：
      width - 指定宽度
      height - 指定高度
      返回：
      屏幕外可绘制图像，可用于双缓冲。 null 值（如果组件不可显示）或 GraphicsEnvironment.isHeadless() 返回 true 。
      自从：
      1.0
      参见：

    • createVolatileImage

      public VolatileImage  createVolatileImage(int width, int height)
      创建一个可变的屏幕外可绘制图像以用于双缓冲。
      参数：
      width - 指定宽度
      height - 指定高度
      返回：
      屏幕外可绘制图像，可用于双缓冲。 null 值（如果组件不可显示）或 GraphicsEnvironment.isHeadless() 返回 true 。
      自从：
      1.4
      参见：

    • createVolatileImage

      public VolatileImage  createVolatileImage(int width, int height, ImageCapabilities  caps) throws AWTException
      使用给定的功能创建一个可变的屏幕外可绘制图像。由于操作系统问题，此映像的内容随时可能丢失，因此必须通过VolatileImage 界面管理映像。
      参数：
      width - 指定宽度
      height - 指定高度
      caps - 图像功能
      返回：
      一个 VolatileImage 对象，可用于管理表面内容丢失和功能。 null 值（如果组件不可显示）或 GraphicsEnvironment.isHeadless() 返回 true 。
      抛出：
      AWTException - 如果无法创建具有指定功能的图像
      自从：
      1.4
      参见：

    • prepareImage

      public boolean prepareImage(Image  image, ImageObserver  observer)
      准备要在此组件上呈现的图像。图像数据在另一个线程中异步下载，并生成图像的适当屏幕表示。
      参数：
      image - 为其准备屏幕表示的 Image
      observer - 在准备图像时要通知的 ImageObserver 对象
      返回：
      true 如果图像已经完全准备好； false否则
      自从：
      1.0

    • prepareImage

      public boolean prepareImage(Image  image, int width, int height, ImageObserver  observer)
      准备图像以指定的宽度和高度在此组件上呈现。

      图像数据在另一个线程中异步下载，并生成适当缩放的图像屏幕表示。

      参数：
      image - 为其准备屏幕表示的 Image 实例
      width - 所需屏幕表示的宽度
      height - 所需屏幕表示的高度
      observer - 在准备图像时要通知的 ImageObserver 对象
      返回：
      true 如果图像已经完全准备好； false否则
      自从：
      1.0
      参见：

    • checkImage

      public int checkImage(Image  image, ImageObserver  observer)
      返回指定图像的屏幕表示的构建状态。

      此方法不会导致图像开始加载。应用程序必须使用 prepareImage 方法来强制加载图像。

      有关此方法返回的标志的信息可以在 ImageObserver 接口的讨论中找到。

      参数：
      image - 正在检查其状态的 Image 对象
      observer - 在准备图像时要通知的 ImageObserver 对象
      返回：
      按位包含ORImageObserver 标志指示有关图像的哪些信息当前可用
      自从：
      1.0
      参见：

    • checkImage

      public int checkImage(Image  image, int width, int height, ImageObserver  observer)
      返回指定图像的屏幕表示的构建状态。

      此方法不会导致图像开始加载。应用程序必须使用 prepareImage 方法来强制加载图像。

      Component 的 checkImage 方法调用其对等方的 checkImage 方法来计算标志。如果此组件还没有对等体，则调用组件工具包的 checkImage 方法。

      有关此方法返回的标志的信息可以在 ImageObserver 接口的讨论中找到。

      参数：
      image - 正在检查其状态的 Image 对象
      width - 要检查其状态的缩放版本的宽度
      height - 要检查其状态的缩放版本的高度
      observer - 在准备图像时要通知的 ImageObserver 对象
      返回：
      按位包含ORImageObserver 标志指示有关图像的哪些信息当前可用
      自从：
      1.0
      参见：

    • setIgnoreRepaint

      public void setIgnoreRepaint(boolean ignoreRepaint)
      设置是否应忽略从操作系统收到的绘制消息。这不会影响 AWT 在软件中生成的绘制事件，除非它们是对操作系统级绘制消息的立即响应。

      这很有用，例如，如果在全屏模式下运行并且需要更好的性能，或者如果使用翻页作为缓冲策略。

      参数：
      ignoreRepaint - true 是否应忽略来自操作系统的绘制消息；否则false
      自从：
      1.4
      参见：

    • getIgnoreRepaint

      public boolean getIgnoreRepaint()
      返回是否应忽略从操作系统收到的绘制消息。
      返回：
      是否应忽略从操作系统收到的绘制消息
      自从：
      1.4
      参见：

    • contains

      public boolean contains(int x, int y)
      检查此组件是否“包含”指定点，其中 x 和 y 定义为相对于此组件的坐标系。
      参数：
      x - 的x点的坐标
      y - 的y点的坐标
      返回：
      true 如果点在组件内；否则false
      自从：
      1.1
      参见：

    • inside

      @Deprecated public boolean inside(int x, int y)
      已弃用。
      从 JDK 1.1 版开始，由 contains(int, int) 取代。
      检查点是否在此组件内部。
      参数：
      x - 的x点的坐标
      y - 的y点的坐标
      返回：
      true 如果点在组件内；否则false

    • contains

      public boolean contains(Point  p)
      检查此组件是否“包含”指定的点，该点的位置x和y坐标定义为相对于该组件的坐标系。
      参数：
      p - 重点
      返回：
      true 如果点在组件内；否则false
      抛出：
      NullPointerException - 如果 p 是 null
      自从：
      1.1
      参见：

    • getComponentAt

      public Component  getComponentAt(int x, int y)
      确定此组件或其直接子组件之一是否包含 (x, y) 位置，如果是，则返回包含组件。这种方法看起来只有一层深。如果点 (x, y) 位于本身具有子组件的子组件内，它不会向下查找子组件树。

      如果 (x, y) 坐标位置在其边界框内，null 否则。

      参数：
      x - 的x协调
      y - 的y协调
      返回：
      包含 (x, y） 地点; null 如果位置在此组件之外
      自从：
      1.0
      参见：

    • locate

      @Deprecated public Component  locate(int x, int y)
      已弃用。
      从 JDK 1.1 版开始，由 getComponentAt(int, int) 取代。
      返回占据指定位置的组件（此组件或直接子组件，如果前两个组件均未占据该位置，则返回 null）。
      参数：
      x - 的x协调以搜索组件
      y - 的y协调以搜索组件
      返回：
      指定位置的组件或null

    • getComponentAt

      public Component  getComponentAt(Point  p)
      返回包含指定点的组件或子组件。
      参数：
      p - 重点
      返回：
      指定位置的组件或null
      自从：
      1.1
      参见：

    • deliverEvent

      @Deprecated public void deliverEvent(Event  e)
      已弃用。
      从 JDK 1.1 版开始，由 dispatchEvent(AWTEvent e) 取代。
      参数：
      e - 要传递的事件

    • dispatchEvent

      public final void dispatchEvent(AWTEvent  e)
      向此组件或其子组件之一调度事件。在为 Component 启用的 1.1 样式事件返回之前调用 processEvent。
      参数：
      e - 事件

    • postEvent

      @Deprecated public boolean postEvent(Event  e)
      已弃用。
      从 JDK 1.1 版开始，由 dispatchEvent(AWTEvent) 取代。
      从接口 MenuContainer 复制的描述
      向监听发布事件。
      指定者：
      postEvent 在接口 MenuContainer 中
      参数：
      e - 要派发的事件
      返回：
      发布事件的结果

    • addComponentListener

      public void addComponentListener(ComponentListener  l)
      添加指定的组件监听器以接收来自该组件的组件事件。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 组件监听器
      自从：
      1.1
      参见：

    • removeComponentListener

      public void removeComponentListener(ComponentListener  l)
      移除指定的组件监听器，使其不再接收来自该组件的组件事件。如果先前未将参数指定的监听器添加到此组件，则此方法不执行任何功能，也不会抛出异常。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 组件监听器
      自从：
      1.1
      参见：

    • getComponentListeners

      public ComponentListener [] getComponentListeners()
      返回在此组件上注册的所有组件监听的数组。
      返回：
      此组件的所有 ComponentListener 或空数组（如果当前没有注册组件监听器）
      自从：
      1.4
      参见：

    • addFocusListener

      public void addFocusListener(FocusListener  l)
      添加指定的焦点监听器以在该组件获得输入焦点时接收来自该组件的焦点事件。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 焦点监听器
      自从：
      1.1
      参见：

    • removeFocusListener

      public void removeFocusListener(FocusListener  l)
      移除指定的焦点监听器，使其不再接收来自该组件的焦点事件。如果先前未将参数指定的监听器添加到此组件，则此方法不执行任何功能，也不会抛出异常。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 焦点监听器
      自从：
      1.1
      参见：

    • getFocusListeners

      public FocusListener [] getFocusListeners()
      返回在此组件上注册的所有焦点监听的数组。
      返回：
      该组件的所有 FocusListener s 或一个空数组（如果当前没有注册组件监听器）
      自从：
      1.4
      参见：

    • addHierarchyListener

      public void addHierarchyListener(HierarchyListener  l)
      当此容器所属的层次结构更改时，添加指定的层次结构监听器以从该组件接收层次结构更改事件。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 层次监听器
      自从：
      1.3
      参见：

    • removeHierarchyListener

      public void removeHierarchyListener(HierarchyListener  l)
      删除指定的层次结构监听器，以便它不再接收来自该组件的层次结构更改事件。如果先前未将参数指定的监听器添加到此组件，则此方法不执行任何功能，也不会抛出异常。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 层次监听器
      自从：
      1.3
      参见：

    • getHierarchyListeners

      public HierarchyListener [] getHierarchyListeners()
      返回在此组件上注册的所有层次结构监听的数组。
      返回：
      该组件的所有 HierarchyListener 或一个空数组（如果当前没有注册任何层次结构监听器）
      自从：
      1.4
      参见：

    • addHierarchyBoundsListener

      public void addHierarchyBoundsListener(HierarchyBoundsListener  l)
      添加指定的层级边界监听器，以在该容器所属的层级发生变化时接收来自该组件的层级边界事件。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 层次结构边界监听器
      自从：
      1.3
      参见：

    • removeHierarchyBoundsListener

      public void removeHierarchyBoundsListener(HierarchyBoundsListener  l)
      删除指定的层次结构边界监听器，以便它不再接收来自该组件的层次结构边界事件。如果先前未将参数指定的监听器添加到此组件，则此方法不执行任何功能，也不会抛出异常。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 层次结构边界监听器
      自从：
      1.3
      参见：

    • getHierarchyBoundsListeners

      public HierarchyBoundsListener [] getHierarchyBoundsListeners()
      返回在此组件上注册的所有层次结构边界监听的数组。
      返回：
      该组件的所有 HierarchyBoundsListener s 或一个空数组（如果当前没有注册层次结构边界监听器）
      自从：
      1.4
      参见：

    • addKeyListener

      public void addKeyListener(KeyListener  l)
      添加指定的按键监听以接收来自该组件的按键事件。如果 l 为 null，则不会抛出异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 关键监听器。
      自从：
      1.1
      参见：

    • removeKeyListener

      public void removeKeyListener(KeyListener  l)
      移除指定的按键监听器，使其不再接收来自该组件的按键事件。如果先前未将参数指定的监听器添加到此组件，则此方法不执行任何功能，也不会抛出异常。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 关键监听器
      自从：
      1.1
      参见：

    • getKeyListeners

      public KeyListener [] getKeyListeners()
      返回在此组件上注册的所有关键监听的数组。
      返回：
      该组件的所有 KeyListener s 或一个空数组（如果当前没有注册关键监听器）
      自从：
      1.4
      参见：

    • addMouseListener

      public void addMouseListener(MouseListener  l)
      添加指定的鼠标监听器以接收来自此组件的鼠标事件。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 鼠标监听器
      自从：
      1.1
      参见：

    • removeMouseListener

      public void removeMouseListener(MouseListener  l)
      移除指定的鼠标监听器，使其不再接收来自该组件的鼠标事件。如果先前未将参数指定的监听器添加到此组件，则此方法不执行任何功能，也不会抛出异常。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 鼠标监听器
      自从：
      1.1
      参见：

    • getMouseListeners

      public MouseListener [] getMouseListeners()
      返回在此组件上注册的所有鼠标监听的数组。
      返回：
      该组件的所有 MouseListener s 或一个空数组（如果当前没有注册鼠标监听器）
      自从：
      1.4
      参见：

    • addMouseMotionListener

      public void addMouseMotionListener(MouseMotionListener  l)
      添加指定的鼠标动作监听器以接收来自该组件的鼠标动作事件。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 鼠标运动监听器
      自从：
      1.1
      参见：

    • removeMouseMotionListener

      public void removeMouseMotionListener(MouseMotionListener  l)
      移除指定的鼠标动作监听器，使其不再接收来自该组件的鼠标动作事件。如果先前未将参数指定的监听器添加到此组件，则此方法不执行任何功能，也不会抛出异常。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 鼠标运动监听器
      自从：
      1.1
      参见：

    • getMouseMotionListeners

      public MouseMotionListener [] getMouseMotionListeners()
      返回在此组件上注册的所有鼠标移动监听的数组。
      返回：
      该组件的所有 MouseMotionListener s 或一个空数组（如果当前没有注册鼠标移动监听器）
      自从：
      1.4
      参见：

    • addMouseWheelListener

      public void addMouseWheelListener(MouseWheelListener  l)
      添加指定的鼠标滚轮监听以接收来自该组件的鼠标滚轮事件。容器还接收来自子组件的鼠标滚轮事件。

      有关如何调度鼠标滚轮事件的信息，请参阅 MouseWheelEvent 的类描述。

      如果 l 是 null ，则不会抛出异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 鼠标滚轮监听器
      自从：
      1.4
      参见：

    • removeMouseWheelListener

      public void removeMouseWheelListener(MouseWheelListener  l)
      移除指定的鼠标滚轮监听，使其不再接收来自该组件的鼠标滚轮事件。如果先前未将参数指定的监听添加到此组件，则此方法不执行任何功能，也不会抛出异常。如果 l 为 null，则不会抛出异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 鼠标滚轮监听器。
      自从：
      1.4
      参见：

    • getMouseWheelListeners

      public MouseWheelListener [] getMouseWheelListeners()
      返回在此组件上注册的所有鼠标滚轮监听的数组。
      返回：
      该组件的所有 MouseWheelListener s 或空数组（如果当前没有注册鼠标滚轮监听器）
      自从：
      1.4
      参见：

    • addInputMethodListener

      public void addInputMethodListener(InputMethodListener  l)
      添加指定的输入法监听器以接收来自该组件的输入法事件。如果组件还覆盖 getInputMethodRequests 以返回 InputMethodRequests 实例，则该组件将仅从输入法接收输入法事件。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 输入法监听器
      自从：
      1.2
      参见：

    • removeInputMethodListener

      public void removeInputMethodListener(InputMethodListener  l)
      移除指定的输入法监听器，使其不再接收来自该组件的输入法事件。如果先前未将参数指定的监听器添加到此组件，则此方法不执行任何功能，也不会抛出异常。如果监听器 l 是 null，则不会抛出任何异常并且不会执行任何操作。

      有关 AWT 线程模型的详细信息，请参阅 AWT 线程问题。

      参数：
      l - 输入法监听器
      自从：
      1.2
      参见：

    • getInputMethodListeners

      public InputMethodListener [] getInputMethodListeners()
      返回在此组件上注册的所有输入方法监听的数组。
      返回：
      该组件的所有 InputMethodListener 或一个空数组（如果当前没有注册输入法监听器）
      自从：
      1.4
      参见：

    • getListeners

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

      您可以使用类文字指定 listenerType 参数，例如 FooListener.class 。例如，您可以使用以下代码查询 Component c 的鼠标监听器：

      MouseListener[] mls = (MouseListener[])(c.getListeners(MouseListener.class));
      如果不存在这样的监听器，则此方法返回一个空数组。
      类型参数：
      T - 监听器的类型
      参数：
      listenerType - 请求的监听器类型；此参数应指定从 java.util.EventListener 派生的接口
      返回：
      在此组件上注册为 FooListener 的所有对象的数组，如果没有添加此类监听器，则为空数组
      抛出：
      ClassCastException - 如果 listenerType 没有指定实现 java.util.EventListener 的类或接口
      NullPointerException - 如果 listenerType 是 null
      自从：
      1.3
      参见：

    • getInputMethodRequests

      public InputMethodRequests  getInputMethodRequests()
      获取输入法请求处理程序，该处理程序支持来自此组件的输入法请求。支持现场文本输入的组件必须覆盖此方法以返回一个InputMethodRequests实例。同时，它还要处理输入法事件。
      返回：
      该组件的输入法请求处理程序，默认为null
      自从：
      1.2
      参见：

    • getInputContext

      public InputContext  getInputContext()
      在此组件中输入文本时，获取此组件用于处理与输入方法的通信的输入上下文。默认情况下，返回用于父组件的输入上下文。组件可以重写它以返回私有输入上下文。
      返回：
      该组件使用的输入上下文； null 如果无法确定上下文
      自从：
      1.2

    • enableEvents

      protected final void enableEvents(long eventsToEnable)
      使由指定事件掩码参数定义的事件能够传送到此组件。

      当该事件类型的监听添加到组件时，事件类型会自动启用。

      此方法只需要由 Component 的子类调用，这些子类希望将指定的事件类型传递给 processEvent，而不管监听器是否已注册。

      参数：
      eventsToEnable - 定义事件类型的事件掩码
      自从：
      1.1
      参见：

    • disableEvents

      protected final void disableEvents(long eventsToDisable)
      禁止将指定事件掩码参数定义的事件传送到此组件。
      参数：
      eventsToDisable - 定义事件类型的事件掩码
      自从：
      1.1
      参见：

    • coalesceEvents

      protected AWTEvent  coalesceEvents(AWTEvent  existingEvent, AWTEvent  newEvent)
      可能合并正在发布的事件与现有事件。如果在队列中发现与要发布的事件具有相同 ID 的事件（两个事件都必须将此组件作为其源），则由 EventQueue.postEvent 调用此方法。此方法要么返回替换现有事件的合并事件（然后丢弃新事件），要么返回 null 以指示不应进行合并（将第二个事件添加到队列末尾）。可以修改和返回任一事件参数，因为另一个参数将被丢弃，除非返回 null。

      coalesceEvents 的这种实现结合了两种事件类型：鼠标移动（和拖动）事件，以及绘画（和更新）事件。对于鼠标移动事件，总是返回最后一个事件，导致中间移动被丢弃。对于绘画事件，新事件在对等体中合并为一个复杂的RepaintArea。总是返回新的 AWTEvent。

      参数：
      existingEvent - 事件已经在 EventQueue
      newEvent - 发布到 EventQueue 的事件
      返回：
      合并事件，或 null 表示未完成合并

    • processEvent

      protected void processEvent(AWTEvent  e)
      处理在此组件上发生的事件。默认情况下，此方法会为给定的事件类调用适当的 process<event type>Event 方法。

      请注意，如果事件参数为 null，则行为未指定且可能导致异常。

      参数：
      e - 事件
      自从：
      1.1
      参见：

    • processComponentEvent

      protected void processComponentEvent(ComponentEvent  e)
      通过将发生在该组件上的组件事件分派给任何已注册的 ComponentListener 对象来处理它们。

      除非为此组件启用了组件事件，否则不会调用此方法。当发生以下情况之一时，将启用组件事件：

      • ComponentListener 对象通过 addComponentListener 注册。
      • 组件事件通过 enableEvents 启用。

      请注意，如果事件参数为 null，则行为未指定且可能导致异常。

      参数：
      e - 组件事件
      自从：
      1.1
      参见：

    • processFocusEvent

      protected void processFocusEvent(FocusEvent  e)
      处理发生在该组件上的焦点事件，方法是将它们分派给任何已注册的 FocusListener 对象。

      除非为此组件启用焦点事件，否则不会调用此方法。当发生以下情况之一时，将启用焦点事件：

      • FocusListener 对象通过 addFocusListener 注册。
      • 焦点事件通过 enableEvents 启用。

      如果为 Component 启用焦点事件，则当前 KeyboardFocusManager 确定是否应将焦点事件分派给已注册的 FocusListener 对象。如果要分派事件，则 KeyboardFocusManager 会调用 Component 的 dispatchEvent 方法，这会调用 Component 的 processFocusEvent 方法。

      如果为 Component 启用焦点事件，则使用 FocusEvent 作为参数调用 Component 的 dispatchEvent 方法将导致调用 Component 的 processFocusEvent 方法，而不管当前的 KeyboardFocusManager 。

      请注意，如果事件参数为 null，则行为未指定且可能导致异常。

      参数：
      e - 焦点事件
      自从：
      1.1
      参见：

    • processKeyEvent

      protected void processKeyEvent(KeyEvent  e)
      通过将它们分派给任何已注册的 KeyListener 对象来处理此组件上发生的关键事件。

      除非为此组件启用了按键事件，否则不会调用此方法。当发生以下情况之一时，将启用按键事件：

      • KeyListener 对象通过 addKeyListener 注册。
      • 按键事件通过 enableEvents 启用。

      如果为 Component 启用了按键事件，则当前 KeyboardFocusManager 确定是否应将按键事件分派给已注册的 KeyListener 对象。 DefaultKeyboardFocusManager 不会将按键事件分派给不是焦点所有者或未显示的 Component。

      从 J2SE 1.4 开始，KeyEvent 被重定向到焦点所有者。请参阅 对焦规格 了解更多信息。

      使用 KeyEvent 作为参数调用 Component 的 dispatchEvent 方法将导致调用 Component 的 processKeyEvent 方法，而不管当前的 KeyboardFocusManager 只要组件正在显示、聚焦和启用，并且在其上启用了键事件.

      如果事件参数是 null，则行为未指定并且可能导致异常。

      参数：
      e - 关键事件
      自从：
      1.1
      参见：

    • processMouseEvent

      protected void processMouseEvent(MouseEvent  e)
      通过将鼠标事件分派给任何已注册的 MouseListener 对象来处理此组件上发生的鼠标事件。

      除非为此组件启用鼠标事件，否则不会调用此方法。当发生以下情况之一时，将启用鼠标事件：

      • MouseListener 对象通过 addMouseListener 注册。
      • 鼠标事件通过 enableEvents 启用。

      请注意，如果事件参数为 null，则行为未指定且可能导致异常。

      参数：
      e - 鼠标事件
      自从：
      1.1
      参见：

    • processMouseMotionEvent

      protected void processMouseMotionEvent(MouseEvent  e)
      通过将鼠标移动事件分派到任何已注册的 MouseMotionListener 对象来处理此组件上发生的鼠标移动事件。

      除非为此组件启用鼠标移动事件，否则不会调用此方法。当发生以下情况之一时，将启用鼠标移动事件：

      • MouseMotionListener 对象通过 addMouseMotionListener 注册。
      • 鼠标运动事件通过 enableEvents 启用。

      请注意，如果事件参数为 null，则行为未指定且可能导致异常。

      参数：
      e - 鼠标移动事件
      自从：
      1.1
      参见：

    • processMouseWheelEvent

      protected void processMouseWheelEvent(MouseWheelEvent  e)
      通过将鼠标滚轮事件分派给任何已注册的 MouseWheelListener 对象来处理此组件上发生的鼠标滚轮事件。

      除非为此组件启用鼠标滚轮事件，否则不会调用此方法。当发生以下情况之一时，将启用鼠标滚轮事件：

      • MouseWheelListener 对象通过 addMouseWheelListener 注册。
      • 鼠标滚轮事件通过 enableEvents 启用。

      有关如何调度鼠标滚轮事件的信息，请参阅 MouseWheelEvent 的类描述。

      请注意，如果事件参数为 null，则行为未指定且可能导致异常。

      参数：
      e - 鼠标滚轮事件
      自从：
      1.4
      参见：

    • processInputMethodEvent

      protected void processInputMethodEvent(InputMethodEvent  e)
      通过将输入法事件分派给任何已注册的 InputMethodListener 对象来处理在此组件上发生的输入法事件。

      除非为此组件启用了输入方法事件，否则不会调用此方法。当发生以下情况之一时，将启用输入方法事件：

      • InputMethodListener 对象通过 addInputMethodListener 注册。
      • 输入法事件通过 enableEvents 启用。

      请注意，如果事件参数为 null，则行为未指定且可能导致异常。

      参数：
      e - 输入法事件
      自从：
      1.2
      参见：

    • processHierarchyEvent

      protected void processHierarchyEvent(HierarchyEvent  e)
      通过将此组件上发生的层次结构事件分派给任何已注册的 HierarchyListener 对象来处理它们。

      除非为此组件启用层次结构事件，否则不会调用此方法。当发生以下情况之一时，将启用层次结构事件：

      • HierarchyListener 对象通过 addHierarchyListener 注册。
      • 层级事件通过 enableEvents 启用。

      请注意，如果事件参数为 null，则行为未指定且可能导致异常。

      参数：
      e - 层次结构事件
      自从：
      1.3
      参见：

    • processHierarchyBoundsEvent

      protected void processHierarchyBoundsEvent(HierarchyEvent  e)
      通过将发生在该组件上的事件分派给任何已注册的 HierarchyBoundsListener 对象来处理层次结构边界事件。

      除非为此组件启用层次结构边界事件，否则不会调用此方法。发生以下情况之一时，将启用层次结构边界事件：

      • HierarchyBoundsListener 对象通过 addHierarchyBoundsListener 注册。
      • 层级边界事件通过 enableEvents 启用。

      请注意，如果事件参数为 null，则行为未指定且可能导致异常。

      参数：
      e - 层次结构事件
      自从：
      1.3
      参见：

    • handleEvent

      @Deprecated public boolean handleEvent(Event  evt)
      已弃用。
      从 JDK 版本 1.1 开始，由 processEvent(AWTEvent) 取代。
      参数：
      evt - 要处理的事件
      返回：
      true 如果事件已处理，false 否则

    • mouseDown

      @Deprecated public boolean mouseDown(Event  evt, int x, int y)
      已弃用。
      从 JDK 1.1 版开始，由 processMouseEvent(MouseEvent) 取代。
      参数：
      evt - 要处理的事件
      x - x 坐标
      y - y 坐标
      返回：
      false

    • mouseDrag

      @Deprecated public boolean mouseDrag(Event  evt, int x, int y)
      已弃用。
      从 JDK 1.1 版开始，由 processMouseMotionEvent(MouseEvent) 取代。
      参数：
      evt - 要处理的事件
      x - x 坐标
      y - y 坐标
      返回：
      false

    • mouseUp

      @Deprecated public boolean mouseUp(Event  evt, int x, int y)
      已弃用。
      从 JDK 1.1 版开始，由 processMouseEvent(MouseEvent) 取代。
      参数：
      evt - 要处理的事件
      x - x 坐标
      y - y 坐标
      返回：
      false

    • mouseMove

      @Deprecated public boolean mouseMove(Event  evt, int x, int y)
      已弃用。
      从 JDK 1.1 版开始，由 processMouseMotionEvent(MouseEvent) 取代。
      参数：
      evt - 要处理的事件
      x - x 坐标
      y - y 坐标
      返回：
      false

    • mouseEnter

      @Deprecated public boolean mouseEnter(Event  evt, int x, int y)
      已弃用。
      从 JDK 1.1 版开始，由 processMouseEvent(MouseEvent) 取代。
      参数：
      evt - 要处理的事件
      x - x 坐标
      y - y 坐标
      返回：
      false

    • mouseExit

      @Deprecated public boolean mouseExit(Event  evt, int x, int y)
      已弃用。
      从 JDK 1.1 版开始，由 processMouseEvent(MouseEvent) 取代。
      参数：
      evt - 要处理的事件
      x - x 坐标
      y - y 坐标
      返回：
      false

    • keyDown

      @Deprecated public boolean keyDown(Event  evt, int key)
      已弃用。
      从 JDK 1.1 版开始，由 processKeyEvent(KeyEvent) 取代。
      参数：
      evt - 要处理的事件
      key - 按下的键
      返回：
      false

    • keyUp

      @Deprecated public boolean keyUp(Event  evt, int key)
      已弃用。
      从 JDK 1.1 版开始，由 processKeyEvent(KeyEvent) 取代。
      参数：
      evt - 要处理的事件
      key - 按下的键
      返回：
      false

    • action

      @Deprecated public boolean action(Event  evt, Object  what)
      已弃用。
      从 JDK 1.1 版开始，应该将此组件注册为触发动作事件的组件上的 ActionListener。
      参数：
      evt - 要处理的事件
      what - 作用于的对象
      返回：
      false

    • addNotify

      public void addNotify()
      通过将它连接到本机屏幕资源，使其可显示。此方法由工具包内部调用，不应由程序直接调用。

      此方法更改与布局相关的信息，因此使组件层次结构无效。

      自从：
      1.0
      参见：

    • removeNotify

      public void removeNotify()
      通过销毁它的本机屏幕资源使其无法显示。

      此方法由工具包内部调用，不应由程序直接调用。覆盖此方法的代码应调用 super.removeNotify 作为覆盖方法的第一行。

      自从：
      1.0
      参见：

    • gotFocus

      @Deprecated public boolean gotFocus(Event  evt, Object  what)
      已弃用。
      从 JDK 1.1 版开始，由 processFocusEvent(FocusEvent) 取代。
      参数：
      evt - 要处理的事件
      what - 聚焦的对象
      返回：
      false

    • lostFocus

      @Deprecated public boolean lostFocus(Event  evt, Object  what)
      已弃用。
      从 JDK 1.1 版开始，由 processFocusEvent(FocusEvent) 取代。
      参数：
      evt - 要处理的事件
      what - 聚焦的对象
      返回：
      false

    • isFocusTraversable

      @Deprecated public boolean isFocusTraversable()
      已弃用。
      从 1.4 开始，由 isFocusable() 取代。
      返回此 Component 是否可以成为焦点所有者。
      返回：
      true 如果这个 Component 是可聚焦的； false否则
      自从：
      1.1
      参见：

    • isFocusable

      public boolean isFocusable()
      返回此 Component 是否可以获得焦点。
      返回：
      true 如果这个组件是可聚焦的； false否则。
      自从：
      1.4
      参见：

    • setFocusable

      public void setFocusable(boolean focusable)
      将此 Component 的可聚焦状态设置为指定值。此值会重写组件的默认可聚焦性。
      参数：
      focusable - 指示此组件是否可聚焦
      自从：
      1.4
      参见：

    • setFocusTraversalKeys

      public void setFocusTraversalKeys(int id, Set <? extends AWTKeyStroke > keystrokes)
      为此组件的给定遍历操作设置焦点遍历键。

      组件的焦点遍历键的默认值是依赖于实现的。 Sun 建议特定本机平台的所有实现都使用相同的默认值。下面列出了针对 Windows 和 Unix 的建议。这些建议用于 Sun AWT 实现。

      组件焦点遍历键的推荐默认值
      Identifier 意义 默认
      KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS 正常的正向键盘遍历 KEY_PRESSED 上的 TAB，KEY_PRESSED 上的 CTRL-TAB
      KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS 正常反向键盘遍历 KEY_PRESSED 上的 SHIFT-TAB，KEY_PRESSED 上的 CTRL-SHIFT-TAB
      KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS 上一个焦点遍历循环 没有任何
      要禁用遍历键，请使用空 Set；推荐使用 Collections.EMPTY_SET。

      使用 AWTKeyStroke API，客户端代码可以指定两个特定的 KeyEvents，KEY_PRESSED 或 KEY_RELEASED 中的哪一个，将发生焦点遍历操作。但是，无论指定哪个KeyEvent，所有与焦点遍历键相关的KeyEvents，包括关联的KEY_TYPED事件，都将被消费，并且不会被派发给任何Component。将 KEY_TYPED 事件指定为映射到焦点遍历操作，或将同一事件映射到多个默认焦点遍历操作是运行时错误。

      如果为 Set 指定了 null 值，则此 Component 从其父级继承 Set。如果此 Component 的所有祖先都为 Set 指定了 null，则使用当前 KeyboardFocusManager 的默认 Set。

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

      参数：
      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.4
      参见：

    • getFocusTraversalKeys

      public Set <AWTKeyStroke > getFocusTraversalKeys(int id)
      返回此组件的给定遍历操作的焦点遍历键集。 （有关每个键的完整说明，请参阅 setFocusTraversalKeys。）

      如果没有为该 Component 显式定义一组遍历键，则返回该 Component 的父级 Set。如果没有为此 Component 的任何祖先显式定义 Set，则返回当前 KeyboardFocusManager 的默认 Set。

      参数：
      id - KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS、KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS 或 KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS 之一
      返回：
      指定操作的 AWTKeyStrokes 集合。 Set 将不可修改，并且可能为空。永远不会返回 null。
      抛出：
      IllegalArgumentException - 如果 id 不是 KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS、KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS 或 KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS 之一
      自从：
      1.4
      参见：

    • areFocusTraversalKeysSet

      public boolean areFocusTraversalKeysSet(int id)
      返回是否已为此组件显式定义给定焦点遍历操作的焦点遍历键集。如果此方法返回 false ，则此 Component 正在从祖先或当前的 KeyboardFocusManager 继承 Set。
      参数：
      id - KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS、KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS 或 KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS 之一
      返回：
      true 如果给定焦点遍历操作的焦点遍历键集已经明确定义给这个组件； false否则。
      抛出：
      IllegalArgumentException - 如果 id 不是 KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS、KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS 或 KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS 之一
      自从：
      1.4

    • setFocusTraversalKeysEnabled

      public void setFocusTraversalKeysEnabled(boolean focusTraversalKeysEnabled)
      设置是否为此组件启用焦点遍历键。禁用焦点遍历键的组件接收焦点遍历键的键事件。启用焦点遍历键的组件看不到这些事件；相反，事件会自动转换为遍历操作。
      参数：
      focusTraversalKeysEnabled - 是否为此组件启用焦点遍历键
      自从：
      1.4
      参见：

    • getFocusTraversalKeysEnabled

      public boolean getFocusTraversalKeysEnabled()
      返回是否为此组件启用了焦点遍历键。禁用焦点遍历键的组件接收焦点遍历键的键事件。启用焦点遍历键的组件看不到这些事件；相反，事件会自动转换为遍历操作。
      返回：
      是否为此组件启用了焦点遍历键
      自从：
      1.4
      参见：

    • requestFocus

      public void requestFocus()
      请求此 Component 获得输入焦点，并且此 Component 的顶级祖先成为焦点窗口。该组件必须是可显示的、可聚焦的、可见的，并且它的所有祖先（顶级 Window 除外）都必须可见才能授予请求。将尽一切努力满足要求；然而，在某些情况下，这样做可能是不可能的。在该组件收到 FOCUS_GAINED 事件之前，开发人员绝不能假设该组件是焦点所有者。如果此请求因为此组件的顶级窗口无法成为焦点窗口而被拒绝，则该请求将被记住并在该窗口稍后被用户聚焦时被授予。

      此方法不能用于将焦点所有者设置为根本没有组件。请改用 KeyboardFocusManager.clearGlobalFocusOwner()。

      由于此方法的焦点行为取决于平台，因此强烈建议开发人员尽可能使用 requestFocusInWindow。

      注意：并非所有焦点转移都是调用此方法的结果。因此，一个组件可能会在没有调用 Component 的这个或任何其他 requestFocus 方法的情况下获得焦点。

      自从：
      1.0
      参见：

    • requestFocus

      public void requestFocus(FocusEvent.Cause  cause)
      由于 cause 的原因请求此 Component 获得输入焦点，并且此 Component 的顶级祖先成为焦点窗口。该组件必须是可显示的、可聚焦的、可见的，并且它的所有祖先（顶级 Window 除外）都必须可见才能授予请求。将尽一切努力满足要求；然而，在某些情况下，这样做可能是不可能的。在该组件收到 FOCUS_GAINED 事件之前，开发人员绝不能假设该组件是焦点所有者。

      焦点请求效果也可能取决于提供的原因值。如果此请求成功，结果中生成的 FocusEvent 将接收指定为方法参数的原因值。如果此请求因为此组件的顶级窗口无法成为焦点窗口而被拒绝，则该请求将被记住并在该窗口稍后被用户聚焦时被授予。

      此方法不能用于将焦点所有者设置为根本没有组件。请改用 KeyboardFocusManager.clearGlobalFocusOwner()。

      由于此方法的焦点行为取决于平台，因此强烈建议开发人员尽可能使用 requestFocusInWindow(FocusEvent.Cause)。

      注意：并非所有焦点转移都是调用此方法的结果。因此，一个组件可能会在没有调用 Component 的这个或任何其他 requestFocus 方法的情况下获得焦点。

      参数：
      cause - 请求焦点的原因
      自从：
      9
      参见：

    • requestFocus

      protected boolean requestFocus(boolean temporary)
      请求此 Component 获得输入焦点，并且此 Component 的顶级祖先成为焦点 Window。该组件必须是可显示的、可聚焦的、可见的，并且它的所有祖先（顶级 Window 除外）都必须可见才能授予请求。将尽一切努力满足要求；然而，在某些情况下，这样做可能是不可能的。在该组件接收到 FOCUS_GAINED 事件之前，开发人员绝不能假设该组件是焦点所有者。如果此请求因为此组件的顶级窗口无法成为焦点窗口而被拒绝，则该请求将被记住并在该窗口稍后被用户聚焦时将被授予。

      此方法返回一个boolean。如果返回false，则请求是保证失败.如果返回true，则请求成功除非它被否决，或者在本机窗口系统允许请求之前发生异常事件，例如组件的对等体的处置。同样，虽然 true 的返回值表示请求可能成功，但开发人员绝不能假设此组件是焦点所有者，直到此组件收到 FOCUS_GAINED 事件。

      此方法不能用于将焦点所有者设置为根本没有组件。请改用 KeyboardFocusManager.clearGlobalFocusOwner。

      由于此方法的焦点行为取决于平台，因此强烈建议开发人员尽可能使用 requestFocusInWindow。

      将尽一切努力确保由于此请求而生成的 FocusEvent 具有指定的临时值。但是，由于指定任意临时状态可能无法在所有本机窗口系统上实现，因此只能为轻量级 Component s 保证此方法的正确行为。此方法不适用于一般用途，而是作为轻量级组件库（例如 Swing）的挂钩而存在。

      注意：并非所有焦点转移都是调用此方法的结果。因此，一个组件可能会在没有调用 Component 的这个或任何其他 requestFocus 方法的情况下获得焦点。

      参数：
      temporary - 如果焦点变化是暂时的，则为真，例如当窗口失去焦点时；有关临时焦点更改的更多信息，请参阅 对焦规格
      返回：
      false 如果焦点更改请求一定会失败； true是否有可能成功
      自从：
      1.4
      参见：

    • requestFocus

      protected boolean requestFocus(boolean temporary, FocusEvent.Cause  cause)
      由于 cause 的原因请求此 Component 获得输入焦点，并且此 Component 的顶级祖先成为焦点 Window 。该组件必须是可显示的、可聚焦的、可见的，并且它的所有祖先（顶级 Window 除外）都必须可见才能授予请求。将尽一切努力满足要求；然而，在某些情况下，这样做可能是不可能的。在该组件接收到 FOCUS_GAINED 事件之前，开发人员绝不能假设该组件是焦点所有者。如果此请求因为此组件的顶级窗口无法成为焦点窗口而被拒绝，则该请求将被记住并在该窗口稍后被用户聚焦时将被授予。

      此方法返回一个boolean。如果返回false，则请求是保证失败.如果返回true，则请求成功除非它被否决，或者在本机窗口系统允许请求之前发生异常事件，例如组件的对等体的处置。同样，虽然 true 的返回值表示请求可能成功，但开发人员绝不能假设此组件是焦点所有者，直到此组件收到 FOCUS_GAINED 事件。

      焦点请求效果也可能取决于提供的原因值。如果此请求成功，结果中生成的 {FocusEvent} 将接收指定为方法参数的原因值。

      此方法不能用于将焦点所有者设置为根本没有组件。请改用 KeyboardFocusManager.clearGlobalFocusOwner。

      由于此方法的焦点行为取决于平台，因此强烈建议开发人员尽可能使用 requestFocusInWindow。

      将尽一切努力确保由于此请求而生成的 FocusEvent 具有指定的临时值。但是，由于指定任意临时状态可能无法在所有本机窗口系统上实现，因此只能为轻量级 Component s 保证此方法的正确行为。此方法不适用于一般用途，而是作为轻量级组件库（例如 Swing）的挂钩而存在。

      注意：并非所有焦点转移都是调用此方法的结果。因此，一个组件可能会在没有调用 Component 的这个或任何其他 requestFocus 方法的情况下获得焦点。

      参数：
      temporary - 如果焦点变化是暂时的，则为真，例如当窗口失去焦点时；有关临时焦点更改的更多信息，请参阅 对焦规格
      cause - 请求焦点的原因
      返回：
      false 如果焦点更改请求一定会失败； true是否有可能成功
      自从：
      9
      参见：

    • requestFocusInWindow

      public boolean requestFocusInWindow()
      如果此 Component 的顶级祖先已经是获得焦点的 Window，则请求此 Component 获得输入焦点。该组件必须是可显示的、可聚焦的、可见的，并且它的所有祖先（顶级 Window 除外）都必须可见才能授予请求。将尽一切努力满足要求；然而，在某些情况下，这样做可能是不可能的。在该组件收到 FOCUS_GAINED 事件之前，开发人员绝不能假设该组件是焦点所有者。

      此方法返回一个boolean。如果返回false，则请求是保证失败.如果返回true，则请求成功除非它被否决，或者在请求可以被本机窗口系统授予之前发生异常事件，例如处置组件的对等体。同样，虽然返回值 true 表示请求可能成功，但开发人员绝不能假设此组件是焦点所有者，直到此组件收到 FOCUS_GAINED 事件。

      此方法不能用于将焦点所有者设置为根本没有组件。请改用 KeyboardFocusManager.clearGlobalFocusOwner()。

      此方法的焦点行为可以跨平台统一实现，因此强烈建议开发人员尽可能在 requestFocus 上使用此方法。依赖于 requestFocus 的代码可能会在不同平台上表现出不同的焦点行为。

      注意：并非所有焦点转移都是调用此方法的结果。因此，一个组件可能会在没有调用 Component 的这个或任何其他 requestFocus 方法的情况下获得焦点。

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

    • requestFocusInWindow

      public boolean requestFocusInWindow(FocusEvent.Cause  cause)
      由于 cause 的原因请求此 Component 获得输入焦点，如果此 Component 的顶级祖先已经是焦点窗口。该组件必须是可显示的、可聚焦的、可见的，并且它的所有祖先（顶级 Window 除外）都必须可见才能授予请求。将尽一切努力满足要求；然而，在某些情况下，这样做可能是不可能的。在该组件收到 FOCUS_GAINED 事件之前，开发人员绝不能假设该组件是焦点所有者。

      此方法返回一个boolean。如果返回false，则请求是保证失败.如果返回true，则请求成功除非它被否决，或者在请求可以被本机窗口系统授予之前发生异常事件，例如处置组件的对等体。同样，虽然返回值 true 表示请求可能成功，但开发人员绝不能假设此组件是焦点所有者，直到此组件收到 FOCUS_GAINED 事件。

      焦点请求效果也可能取决于提供的原因值。如果此请求成功，结果中生成的 FocusEvent 将接收指定为方法参数的原因值。

      此方法不能用于将焦点所有者设置为根本没有组件。请改用 KeyboardFocusManager.clearGlobalFocusOwner()。

      此方法的焦点行为可以跨平台统一实现，因此强烈建议开发人员尽可能在 requestFocus(FocusEvent.Cause) 上使用此方法。依赖于 requestFocus(FocusEvent.Cause) 的代码可能会在不同平台上表现出不同的焦点行为。

      注意：并非所有焦点转移都是调用此方法的结果。因此，一个组件可能会在没有调用 Component 的这个或任何其他 requestFocus 方法的情况下获得焦点。

      参数：
      cause - 请求焦点的原因
      返回：
      false 如果焦点更改请求一定会失败； true是否有可能成功
      自从：
      9
      参见：

    • requestFocusInWindow

      protected boolean requestFocusInWindow(boolean temporary)
      请求此 Component 获得输入焦点，如果此 Component 的顶级祖先已经是焦点 Window 。该组件必须是可显示的、可聚焦的、可见的，并且它的所有祖先（顶级 Window 除外）都必须可见才能授予请求。将尽一切努力满足要求；然而，在某些情况下，这样做可能是不可能的。在该组件接收到 FOCUS_GAINED 事件之前，开发人员绝不能假设该组件是焦点所有者。

      此方法返回一个boolean。如果返回false，则请求是保证失败.如果返回true，则请求成功除非它被否决，或者在本机窗口系统允许请求之前发生异常事件，例如组件的对等体的处置。同样，虽然 true 的返回值表示请求可能成功，但开发人员绝不能假设此组件是焦点所有者，直到此组件收到 FOCUS_GAINED 事件。

      此方法不能用于将焦点所有者设置为根本没有组件。请改用 KeyboardFocusManager.clearGlobalFocusOwner。

      此方法的焦点行为可以跨平台统一实现，因此强烈建议开发人员尽可能在 requestFocus 上使用此方法。依赖于 requestFocus 的代码可能会在不同平台上表现出不同的焦点行为。

      将尽一切努力确保由于此请求而生成的 FocusEvent 具有指定的临时值。但是，由于指定任意临时状态可能无法在所有本机窗口系统上实现，因此只能为轻量级组件保证此方法的正确行为。此方法不适用于一般用途，而是作为轻量级组件库（例如 Swing）的挂钩而存在。

      注意：并非所有焦点转移都是调用此方法的结果。因此，一个组件可能会在没有调用 Component 的这个或任何其他 requestFocus 方法的情况下获得焦点。

      参数：
      temporary - 如果焦点变化是暂时的，则为真，例如当窗口失去焦点时；有关临时焦点更改的更多信息，请参阅 对焦规格
      返回：
      false 如果焦点更改请求一定会失败； true是否有可能成功
      自从：
      1.4
      参见：

    • getFocusCycleRootAncestor

      public Container  getFocusCycleRootAncestor()
      返回作为此 Component 的焦点遍历循环的焦点循环根的 Container。每个焦点遍历循环只有一个焦点循环根，每个不是容器的组件都只属于一个焦点遍历循环。作为焦点循环根的容器属于两个循环：一个以容器本身为根，另一个以容器最近的焦点循环根祖先为根。对于此类 Container，此方法将返回 Container 最近的 focus-cycle-root 祖先。
      返回：
      此组件最近的 focus-cycle-root 祖先
      自从：
      1.4
      参见：

    • isFocusCycleRoot

      public boolean isFocusCycleRoot(Container  container)
      返回指定的Container是否是该Component的焦点遍历循环的焦点循环根。每个焦点遍历循环只有一个焦点循环根，每个不是容器的组件都只属于一个焦点遍历循环。
      参数：
      container - 要测试的容器
      返回：
      true 如果指定的容器是该组件的焦点循环根； false否则
      自从：
      1.4
      参见：

    • transferFocus

      public void transferFocus()
      将焦点转移到下一个组件，就好像此 Component 是焦点所有者一样。
      自从：
      1.1
      参见：

    • nextFocus

      @Deprecated public void nextFocus()
      已弃用。
      从 JDK 1.1 版开始，由 transferFocus() 取代。

    • transferFocusBackward

      public void transferFocusBackward()
      将焦点转移到前一个组件，就好像此 Component 是焦点所有者一样。
      自从：
      1.4
      参见：

    • transferFocusUpCycle

      public void transferFocusUpCycle()
      将焦点向上转移一个焦点遍历周期。通常，焦点所有者设置为此 Component 的焦点循环根，当前焦点循环根设置为新焦点所有者的焦点循环根。但是，如果此 Component 的焦点循环根是一个 Window，则焦点所有者设置为焦点循环根的默认要焦点的 Component，并且当前焦点循环根不变。
      自从：
      1.4
      参见：

    • hasFocus

      public boolean hasFocus()
      如果此 Component 是焦点所有者，则返回 true。此方法已过时，已被 isFocusOwner() 取代。
      返回：
      true 如果这个 Component 是焦点所有者； false否则
      自从：
      1.2

    • isFocusOwner

      public boolean isFocusOwner()
      如果此 Component 是焦点所有者，则返回 true。
      返回：
      true 如果这个 Component 是焦点所有者； false否则
      自从：
      1.4

    • add

      public void add(PopupMenu  popup)
      将指定的弹出菜单添加到组件。
      参数：
      popup - 要添加到组件的弹出菜单。
      抛出：
      NullPointerException - 如果 popup 是 null
      自从：
      1.1
      参见：

    • remove

      public void remove(MenuComponent  popup)
      从组件中移除指定的弹出菜单。
      指定者：
      remove 在接口 MenuContainer 中
      参数：
      popup - 要删除的弹出菜单
      自从：
      1.1
      参见：

    • paramString

      protected String  paramString()
      返回表示此组件状态的字符串。此方法仅用于调试目的，返回字符串的内容和格式可能因实现而异。返回的字符串可能为空，但可能不是 null 。
      返回：
      此组件状态的字符串表示形式
      自从：
      1.0

    • toString

      public String  toString()
      返回此组件及其值的字符串表示形式。
      重写：
      toString 在类 Object 中
      返回：
      此组件的字符串表示形式
      自从：
      1.0

    • list

      public void list()
      将此组件的列表打印到标准系统输出流 System.out 。
      自从：
      1.0
      参见：

    • list

      public void list(PrintStream  out)
      将此组件的列表打印到指定的输出流。
      参数：
      out - 打印流
      抛出：
      NullPointerException - 如果 out 是 null
      自从：
      1.0

    • list

      public void list(PrintStream  out, int indent)
      从指定的缩进开始，打印出一个列表到指定的打印流。
      参数：
      out - 打印流
      indent - 要缩进的空格数
      抛出：
      NullPointerException - 如果 out 是 null
      自从：
      1.0
      参见：

    • list

      public void list(PrintWriter  out)
      将列表打印到指定的打印器。
      参数：
      out - 要打印到的打印编写器
      抛出：
      NullPointerException - 如果 out 是 null
      自从：
      1.1

    • list

      public void list(PrintWriter  out, int indent)
      从指定的缩进开始，将列表打印到指定的打印器。
      参数：
      out - 要打印到的打印编写器
      indent - 要缩进的空格数
      抛出：
      NullPointerException - 如果 out 是 null
      自从：
      1.1
      参见：

    • addPropertyChangeListener

      public void addPropertyChangeListener(PropertyChangeListener  listener)
      将 PropertyChangeListener 添加到监听列表。监听已为此类的所有绑定属性注册，包括以下内容：
      • 此组件的字体（“字体”）
      • 此组件的背景颜色（“背景”）
      • 此组件的前景色（“前景”）
      • 此组件的可聚焦性（“可聚焦”）
      • 此组件的焦点遍历键启用状态（“focusTraversalKeysEnabled”）
      • 此组件的一组 FORWARD_TRAVERSAL_KEYS（“forwardFocusTraversalKeys”）
      • 此组件的一组 BACKWARD_TRAVERSAL_KEYS（“backwardFocusTraversalKeys”）
      • 此组件的 UP_CYCLE_TRAVERSAL_KEYS 集合（“upCycleFocusTraversalKeys”）
      • 此组件的首选大小（“preferredSize”）
      • 此组件的最小尺寸（“minimumSize”）
      • 此组件的最大尺寸（“maximumSize”）
      • 此组件的名称（“名称”）
      请注意，如果此 Component 继承了绑定属性，则不会触发任何事件来响应继承属性的更改。

      如果 listener 是 null ，则不会抛出异常并且不会执行任何操作。

      参数：
      listener - 要添加的属性更改监听器
      参见：

    • removePropertyChangeListener

      public void removePropertyChangeListener(PropertyChangeListener  listener)
      从监听列表中删除 PropertyChangeListener。此方法应用于删除为此类的所有绑定属性注册的 PropertyChangeListeners。

      如果 listener 为 null，则不会抛出异常并且不会执行任何操作。

      参数：
      listener - 要删除的 PropertyChangeListener
      参见：

    • getPropertyChangeListeners

      public PropertyChangeListener [] getPropertyChangeListeners()
      返回在此组件上注册的所有属性更改监听的数组。
      返回：
      该组件的所有 PropertyChangeListener 或一个空数组（如果当前没有注册属性更改监听器）
      自从：
      1.4
      参见：

    • addPropertyChangeListener

      public void addPropertyChangeListener(String  propertyName, PropertyChangeListener  listener)
      将 PropertyChangeListener 添加到特定属性的监听列表。指定的属性可以是用户定义的，也可以是以下之一：
      • 此组件的字体（“字体”）
      • 此组件的背景颜色（“背景”）
      • 此组件的前景色（“前景”）
      • 此组件的可聚焦性（“可聚焦”）
      • 此组件的焦点遍历键启用状态（“focusTraversalKeysEnabled”）
      • 此组件的一组 FORWARD_TRAVERSAL_KEYS（“forwardFocusTraversalKeys”）
      • 此组件的一组 BACKWARD_TRAVERSAL_KEYS（“backwardFocusTraversalKeys”）
      • 此组件的 UP_CYCLE_TRAVERSAL_KEYS 集合（“upCycleFocusTraversalKeys”）
      请注意，如果此 Component 继承了绑定属性，则不会触发任何事件来响应继承属性的更改。

      如果 propertyName 或 listener 是 null ，则不会抛出异常并且不会采取任何操作。

      参数：
      propertyName - 上面列出的属性名称之一
      listener - 要添加的属性更改监听器
      参见：

    • removePropertyChangeListener

      public void removePropertyChangeListener(String  propertyName, PropertyChangeListener  listener)
      从特定属性的监听器列表中删除 PropertyChangeListener。此方法应用于删除为特定绑定属性注册的 PropertyChangeListener 。

      如果 propertyName 或 listener 是 null ，则不会抛出异常并且不会采取任何操作。

      参数：
      propertyName - 有效的属性名称
      listener - 要删除的 PropertyChangeListener
      参见：

    • getPropertyChangeListeners

      public PropertyChangeListener [] getPropertyChangeListeners(String  propertyName)
      返回与指定属性关联的所有监听的数组。
      参数：
      propertyName - 属性名称
      返回：
      所有与命名属性关联的 PropertyChangeListener ；如果没有添加这样的监听器或者如果 propertyName 是 null ，则返回一个空数组
      自从：
      1.4
      参见：

    • firePropertyChange

      protected void firePropertyChange(String  propertyName, Object  oldValue, Object  newValue)
      支持报告对象属性的绑定属性更改。当绑定的属性发生更改时可以调用此方法，它会将适当的 PropertyChangeEvent 发送到任何已注册的 PropertyChangeListeners。
      参数：
      propertyName - 值已更改的属性
      oldValue - 属性的先前值
      newValue - 属性的新值

    • firePropertyChange

      protected void firePropertyChange(String  propertyName, boolean oldValue, boolean newValue)
      支持报告布尔属性的绑定属性更改。当绑定的属性发生更改时可以调用此方法，它会将适当的 PropertyChangeEvent 发送到任何已注册的 PropertyChangeListeners。
      参数：
      propertyName - 值已更改的属性
      oldValue - 属性的先前值
      newValue - 属性的新值
      自从：
      1.4

    • firePropertyChange

      protected void firePropertyChange(String  propertyName, int oldValue, int newValue)
      支持报告整数属性的绑定属性更改。当绑定的属性发生更改时可以调用此方法，它会将适当的 PropertyChangeEvent 发送到任何已注册的 PropertyChangeListeners。
      参数：
      propertyName - 值已更改的属性
      oldValue - 属性的先前值
      newValue - 属性的新值
      自从：
      1.4

    • firePropertyChange

      public void firePropertyChange(String  propertyName, byte oldValue, byte newValue)
      报告绑定的属性更改。
      参数：
      propertyName - 已更改属性的编程名称
      oldValue - 属性的旧值（作为字节）
      newValue - 属性的新值（作为字节）
      自从：
      1.5
      参见：

    • firePropertyChange

      public void firePropertyChange(String  propertyName, char oldValue, char newValue)
      报告绑定的属性更改。
      参数：
      propertyName - 已更改属性的编程名称
      oldValue - 属性的旧值（作为字符）
      newValue - 属性的新值（作为字符）
      自从：
      1.5
      参见：

    • firePropertyChange

      public void firePropertyChange(String  propertyName, short oldValue, short newValue)
      报告绑定的属性更改。
      参数：
      propertyName - 已更改属性的编程名称
      oldValue - 属性的旧值（简称）
      newValue - 属性的新值（简称）
      自从：
      1.5
      参见：

    • firePropertyChange

      public void firePropertyChange(String  propertyName, long oldValue, long newValue)
      报告绑定的属性更改。
      参数：
      propertyName - 已更改属性的编程名称
      oldValue - 属性的旧值（长）
      newValue - 属性的新值（长）
      自从：
      1.5
      参见：

    • firePropertyChange

      public void firePropertyChange(String  propertyName, float oldValue, float newValue)
      报告绑定的属性更改。
      参数：
      propertyName - 已更改属性的编程名称
      oldValue - 属性的旧值（作为浮点数）
      newValue - 属性的新值（作为浮点数）
      自从：
      1.5
      参见：

    • firePropertyChange

      public void firePropertyChange(String  propertyName, double oldValue, double newValue)
      报告绑定的属性更改。
      参数：
      propertyName - 已更改属性的编程名称
      oldValue - 属性的旧值（作为双精度值）
      newValue - 属性的新值（作为双精度值）
      自从：
      1.5
      参见：

    • setComponentOrientation

      public void setComponentOrientation(ComponentOrientation  o)
      设置用于对该组件中的元素或文本进行排序的语言敏感方向。语言敏感的 LayoutManager 和 Component 子类将使用此属性来确定如何布局和绘制组件。

      在构造时，组件的方向设置为 ComponentOrientation.UNKNOWN ，表示尚未明确指定。未知方向的行为与 ComponentOrientation.LEFT_TO_RIGHT 相同。

      要设置单个组件的方向，请使用此方法。要设置整个组件层次结构的方向，请使用 applyComponentOrientation 。

      此方法更改与布局相关的信息，因此使组件层次结构无效。

      参数：
      o - 要设置的方向
      参见：

    • getComponentOrientation

      public ComponentOrientation  getComponentOrientation()
      检索用于对该组件中的元素或文本进行排序的语言敏感方向。希望遵守方向的 LayoutManager 和 Component 子类应在执行布局或绘制之前调用此方法以获取组件的方向。
      返回：
      排列元素或文本的方向
      参见：

    • applyComponentOrientation

      public void applyComponentOrientation(ComponentOrientation  orientation)
      设置此组件及其中包含的所有组件的 ComponentOrientation 属性。

      此方法更改与布局相关的信息，因此使组件层次结构无效。

      参数：
      orientation - 此组件及其中包含的组件的新组件方向。
      抛出：
      NullPointerException - 如果 orientation 为空。
      自从：
      1.4
      参见：

    • getAccessibleContext

      public AccessibleContext  getAccessibleContext()
      获取与此 Component 关联的 AccessibleContext。此基类实现的方法返回 null。扩展 Component 的类应实现此方法以返回与子类关联的 AccessibleContext。
      返回：
      这个Component的AccessibleContext
      自从：
      1.3

    • setMixingCutoutShape

      public void setMixingCutoutShape(Shape  shape)
      为这个轻量级组件设置一个“mixing-cutout”形状。此方法专门用于重量级/轻量级组件混合功能，如果应用于重量级组件则不会产生任何效果。默认情况下，出于重量级/轻量级组件混合功能的目的，轻量级组件被视为不透明矩形。此方法使开发人员能够设置任意形状，以从位于 z 顺序中轻量级组件下方的重量级组件中剪切。

      shape 参数可能具有以下值：

      • null - 恢复默认的切口形状（矩形等于组件的 getBounds() ）
      • 空形- 不会从重量级组件中删除任何内容。这使得这个轻量级组件有效透明。请注意，轻量级组件的后代仍会影响重量级组件的形状。一个示例空形是new Rectangle()。
      • 非空形状- 给定的形状将从重量级组件中切出。

      需要“混合切口”形状的最常见示例是玻璃板组件。 JRootPane.setGlassPane(java.awt.Component) 方法自动设置空形作为给定玻璃板组件的“混合切口”形状。如果开发人员需要玻璃面板的其他“混合切口”形状（这种情况很少见），则必须在将玻璃面板安装到根面板后手动更改。

      参数：
      shape - 新的“混合切口”形状
      自从：
      9