Module java.desktop
Package java.awt

Class 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也可以直接扩展以创建轻量级组件。轻量级组件是不与本地窗口关联的组件。相反，重量级组件与本地窗口关联。可以使用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()
        {
            // 糟糕，现在aButton具有一个引用到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中的绘制。

有关焦点子系统的详细信息，请参阅如何使用焦点子系统，这是Java教程中的一个部分，以及有关更多信息的焦点规范。

参见:

  • Field Details

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

  • Constructor Details

    • Component

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

  • Method Details

    • 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。
      返回:
      drop target

    • getGraphicsConfiguration

      public GraphicsConfiguration getGraphicsConfiguration()
      获取与此 Component 关联的 GraphicsConfiguration。如果尚未为 Component 分配特定的 GraphicsConfiguration，则返回 Component 对象的顶层容器的 GraphicsConfiguration。如果已创建但尚未添加到 Container 中，此方法返回 null。
      返回:
      此 Component 使用的 GraphicsConfiguration 或 null
      自从:
      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()
      确定此组件是否在屏幕上显示。这意味着组件必须可见，并且必须在一个可见且显示的容器中。

      注意: 有时无法检测到组件实际对用户可见。这可能发生在以下情况下：

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

    • isVisible

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

    • getMousePosition

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

      对于 Container，如果鼠标位于 Container 本身或其任何后代上方，则返回非空值。如果需要排除子组件，请使用 Container.getMousePosition(boolean)。

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

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

    • isShowing

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

      注意: 有时无法检测到组件实际对用户可见。这可能发生在以下情况下：

      • 组件已添加到可见的 ScrollPane，但组件当前不在滚动窗格的视口中。
      • 组件被另一个组件或容器遮挡。
      返回:
      如果组件正在显示，则返回 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()
      Deprecated.
      As of JDK version 1.1, replaced by setEnabled(boolean).

    • enable

      @Deprecated public void enable(boolean b)
      Deprecated.
      As of JDK version 1.1, replaced by setEnabled(boolean).
      启用或禁用此组件。
      参数:
      b - true 以启用此组件；否则 false

    • disable

      @Deprecated public void disable()
      Deprecated.
      As of JDK version 1.1, replaced by setEnabled(boolean).

    • isDoubleBuffered

      public boolean isDoubleBuffered()
      如果此组件绘制到稍后复制到屏幕的离屏图像（"缓冲区"）上，则返回 true。支持双缓冲的组件子类应重写此方法，以在启用双缓冲时返回 true。
      返回:
      默认为 false

    • 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()
      Deprecated.
      As of JDK version 1.1, replaced by setVisible(boolean).

    • show

      @Deprecated public void show(boolean b)
      Deprecated.
      As of JDK version 1.1, replaced by setVisible(boolean).
      使此组件可见或不可见。
      参数:
      b - true 表示使此组件可见；否则为 false

    • hide

      @Deprecated public void hide()
      Deprecated.
      As of JDK version 1.1, replaced by setVisible(boolean).

    • getForeground

      public Color getForeground()
      获取此组件的前景色。
      返回:
      此组件的前景色；如果此组件没有前景色，则返回其父级的前景色
      自版本:
      1.0
      另请参阅:

    • setForeground

      public void setForeground(Color c)
      设置此组件的前景色。
      参数:
      c - 要设置为此组件前景色的颜色；如果此参数为 null，则此组件将继承其父级的前景色
      自版本:
      1.0
      另请参阅:

    • isForegroundSet

      public boolean isForegroundSet()
      返回此组件的前景色是否已明确设置。如果此方法返回 false，则此组件正在从祖先继承其前景色。
      返回:
      如果此组件的前景色已明确设置，则返回 true；否则返回 false。
      自版本:
      1.4

    • getBackground

      public Color getBackground()
      获取此组件的背景色。
      返回:
      此组件的背景色；如果此组件没有背景色，则返回其父级的背景色
      自版本:
      1.0
      另请参阅:

    • setBackground

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

      背景色会影响每个组件的不同部分，受背景色影响的组件部分在操作系统之间可能有所不同。

      参数:
      c - 要设置为此组件颜色的颜色；如果此参数为 null，则此组件将继承其父级的背景色
      自版本:
      1.0
      另请参阅:

    • isBackgroundSet

      public boolean isBackgroundSet()
      返回此组件的背景色是否已明确设置。如果此方法返回 false，则此组件正在从祖先继承其背景色。
      返回:
      如果此组件的背景色已明确设置，则返回 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，则此组件正在从祖先继承其字体。
      返回:
      如果此组件的字体已明确设置，则返回 true；否则返回 false。
      自版本:
      1.4

    • getLocale

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

    • setLocale

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

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

      参数:
      l - 要设置为此组件区域设置的区域设置
      自版本:
      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()
      Deprecated.
      As of JDK version 1.1, replaced by 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)
      Deprecated.
      As of JDK version 1.1, replaced by 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()
      Deprecated.
      As of JDK version 1.1, replaced by 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)
      Deprecated.
      As of JDK version 1.1, replaced by 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)
      Deprecated.
      As of JDK version 1.1, replaced by setSize(Dimension).
      调整此组件的大小，使其具有宽度d.width和高度d.height。
      参数:
      d - 此组件的新大小

    • getBounds

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

    • bounds

      @Deprecated public Rectangle bounds()
      Deprecated.
      As of JDK version 1.1, replaced by 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)
      Deprecated.
      As of JDK version 1.1, replaced by 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中并返回rv。如果rv为null，则会分配一个新的Rectangle。如果调用者想要避免在堆上分配新的Rectangle对象，则此版本的getBounds很有用。
      参数:
      rv - 返回值，修改为组件的边界
      返回:
      rv

    • getSize

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

    • getLocation

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

    • isOpaque

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

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

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

      返回:
      如果此组件完全不透明，则为true
      自版本:
      1.2
      另请参阅:

    • isLightweight

      public boolean isLightweight()
      一个轻量级组件没有本地工具包对等体。除了在这个包中定义的类似于Button或Scrollbar的Component和Container的子类是轻量级的。所有的Swing组件都是轻量级的。

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

      返回：
      如果这个组件有一个轻量级对等体，则返回true；如果它有一个本地对等体或没有对等体，则返回false
      自：
      1.2
      参见：

    • setPreferredSize

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

    • isPreferredSizeSet

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

    • getPreferredSize

      public Dimension getPreferredSize()
      获取此组件的首选大小。
      返回：
      一个表示此组件首选大小的尺寸对象
      参见：

    • preferredSize

      @Deprecated public Dimension preferredSize()
      Deprecated.
      As of JDK version 1.1, replaced by getPreferredSize().
      返回组件的首选大小。
      返回：
      组件的首选大小

    • setMinimumSize

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

    • isMinimumSizeSet

      public boolean isMinimumSizeSet()
      返回setMinimumSize是否已使用非null值调用。
      返回：
      如果使用非null值调用了setMinimumSize，则返回true。
      自：
      1.5

    • getMinimumSize

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

    • minimumSize

      @Deprecated public Dimension minimumSize()
      Deprecated.
      As of JDK version 1.1, replaced by getMinimumSize().
      返回此组件的最小大小。
      返回：
      此组件的最小大小

    • setMaximumSize

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

    • isMaximumSizeSet

      public boolean isMaximumSizeSet()
      如果最大大小已设置为非null值，则返回true，否则返回false。
      返回：
      如果maximumSize为非null，则返回true，否则返回false
      自：
      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表示此组件没有合理的基线，LayoutManager不应该将此组件与其基线对齐。

      默认实现返回-1。支持基线的子类应适当重写。如果返回值>= 0，则表示组件对于任何大小>=最小大小都有有效的基线，并且getBaselineResizeBehavior可用于确定基线随大小变化的方式。

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

    • getBaselineResizeBehavior

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

      默认实现返回BaselineResizeBehavior.OTHER。支持基线的子类应适当重写。子类不应返回null；如果无法计算基线，则返回BaselineResizeBehavior.OTHER。调用者应首先使用getBaseline请求基线，如果返回值>= 0，则使用此方法。即使getBaseline返回小于0的值，此方法也可以返回BaselineResizeBehavior.OTHER之外的值。

      返回：
      一个枚举，指示组件大小变化时基线的变化方式
      自：
      1.6
      参见：

    • doLayout

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

    • layout

      @Deprecated public void layout()
      Deprecated.
      As of JDK version 1.1, replaced by 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的影响，而此方法不提供FontRenderContext，因此它只能返回默认呈现上下文的度量，这可能与在组件上呈现时使用的不匹配，如果使用Graphics2D功能。相反，可以通过调用Graphics.getFontMetrics()或Font类上的文本测量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，则此组件正在从祖先继承其光标。
      返回:
      如果此组件已明确设置光标，则返回true；否则返回false。
      自从:
      1.4

    • paint

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

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

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

      注意：有关AWT和Swing使用的绘制机制的更多信息，包括如何编写最有效的绘制代码的信息，请参见AWT和Swing中的绘制。

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

    • update

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

      如果此组件不是轻量级组件，则AWT会在调用repaint时调用update方法。可以假定背景未清除。

      Component的update方法调用此组件的paint方法以重新绘制此组件。通常情况下，覆盖此方法的Component子类需要在对repaint的调用中执行其他工作。覆盖此方法的Component子类应该从其update方法中直接调用super.update(g)，或直接调用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 - 高度
      返回:
      如果infoflags指示图像已完全加载，则为false；否则为true。
      自从:
      1.0
      参见:

    • createImage

      public Image createImage(ImageProducer producer)
      从指定的图像生成图像生产者。
      参数:
      producer - 图像生产者
      返回:
      生成的图像
      自从:
      1.0

    • createImage

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

    • createVolatileImage

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

    • createVolatileImage

      public VolatileImage createVolatileImage(int width, int height, ImageCapabilities caps) throws AWTException
      创建具有给定功能的易失性离屏可绘制图像。由于操作系统问题，此图像的内容可能随时丢失，因此必须通过VolatileImage接口来管理图像。
      参数:
      width - 指定的宽度
      height - 指定的高度
      caps - 图像功能
      返回:
      一个VolatileImage对象，可用于管理表面内容丢失和功能。如果组件不可显示或GraphicsEnvironment.isHeadless()返回true，则返回null值。
      抛出:
      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对象
      返回:
      指示有关图像当前可用信息的ImageObserver标志的按位包含OR
      自从:
      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对象
      返回:
      当前可用有关图像信息的ImageObserver标志的按位包含OR
      自版本:
      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)
      Deprecated.
      As of JDK version 1.1, replaced by 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）在一个具有子组件的子组件内部，则不会继续查找子组件树。

      Component的locate方法只是在其边界框内部时返回组件本身，否则返回null。

      参数:
      x - x坐标
      y - y坐标
      返回:
      包含（x，y）位置的组件或子组件；如果位置在此组件外部，则为null
      自版本:
      1.0
      另请参阅:

    • locate

      @Deprecated public Component locate(int x, int y)
      Deprecated.
      As of JDK version 1.1, replaced by 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)
      Deprecated.
      As of JDK version 1.1, replaced by dispatchEvent(AWTEvent e).
      参数:
      e - 要传递的事件

    • dispatchEvent

      public final void dispatchEvent(AWTEvent e)
      将事件分派到此组件或其子组件之一。在返回1.1样式事件之前调用Component上已启用的processEvent。
      参数:
      e - 事件

    • postEvent

      @Deprecated public boolean postEvent(Event e)
      Deprecated.
      As of JDK version 1.1, replaced by 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或如果当前未注册组件监听器则返回空数组
      自版本:
      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或如果当前未注册层次结构边界监听器则返回空数组
      自版本:
      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或如果当前未注册键盘监听器则返回空数组
      自版本:
      1.4
      参见:

    • addMouseListener

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

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

      参数:
      l - 鼠标监听器
      自 JDK 版本:
      1.1
      参见:

    • removeMouseListener

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

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

      参数:
      l - 鼠标监听器
      自 JDK 版本:
      1.1
      参见:

    • getMouseListeners

      public MouseListener[] getMouseListeners()
      返回在此组件上注册的所有鼠标监听器的数组。
      返回:
      所有此组件的 MouseListener，如果当前未注册鼠标监听器，则返回空数组
      自 JDK 版本:
      1.4
      参见:

    • addMouseMotionListener

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

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

      参数:
      l - 鼠标移动监听器
      自 JDK 版本:
      1.1
      参见:

    • removeMouseMotionListener

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

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

      参数:
      l - 鼠标移动监听器
      自 JDK 版本:
      1.1
      参见:

    • getMouseMotionListeners

      public MouseMotionListener[] getMouseMotionListeners()
      返回在此组件上注册的所有鼠标移动监听器的数组。
      返回:
      所有此组件的 MouseMotionListener，如果当前未注册鼠标移动监听器，则返回空数组
      自 JDK 版本:
      1.4
      参见:

    • addMouseWheelListener

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

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

      如果 l 为 null，则不会抛出异常，也不会执行任何操作。

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

      参数:
      l - 鼠标滚轮监听器
      自 JDK 版本:
      1.4
      参见:

    • removeMouseWheelListener

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

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

      参数:
      l - 鼠标滚轮监听器
      自 JDK 版本:
      1.4
      参见:

    • getMouseWheelListeners

      public MouseWheelListener[] getMouseWheelListeners()
      返回在此组件上注册的所有鼠标滚轮监听器的数组。
      返回:
      所有此组件的 MouseWheelListener，如果当前未注册鼠标滚轮监听器，则返回空数组
      自 JDK 版本:
      1.4
      参见:

    • addInputMethodListener

      public void addInputMethodListener(InputMethodListener l)
      添加指定的输入法监听器以接收来自此组件的输入法事件。只有当组件还重写 getInputMethodRequests 以返回一个 InputMethodRequests 实例时，组件才会从输入法接收输入法事件。如果监听器 l 为 null，则不会抛出异常，也不会执行任何操作。

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

      参数:
      l - 输入法监听器
      自 JDK 版本:
      1.2
      参见:

    • removeInputMethodListener

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

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

      参数:
      l - 输入法监听器
      自 JDK 版本:
      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对象来处理在此组件上发生的组件事件。

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

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

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

      参数:
      e - 组件事件
      自版本:
      1.1
      另请参阅:

    • processFocusEvent

      protected void processFocusEvent(FocusEvent e)
      通过将焦点事件分派给任何已注册的FocusListener对象来处理在此组件上发生的焦点事件。

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

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

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

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

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

      参数:
      e - 焦点事件
      自1.1版本起:
      1.1
      参见:

    • processKeyEvent

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

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

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

      如果为Component启用了键事件，则当前的KeyboardFocusManager将决定是否将键事件分派给已注册的KeyListener对象。只要组件正在显示、聚焦且启用，并且已在其上启用了键事件，DefaultKeyboardFocusManager将不会将键事件分派给非焦点所有者或未显示的Component。

      从J2SE 1.4开始，KeyEvent将被重定向到焦点所有者。有关更多信息，请参阅焦点规范。

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

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

      参数:
      e - 键事件
      自1.1版本起:
      1.1
      参见:

    • processMouseEvent

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

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

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

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

      参数:
      e - 鼠标事件
      自1.1版本起:
      1.1
      参见:

    • processMouseMotionEvent

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

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

      • 通过addMouseMotionListener注册了一个MouseMotionListener对象。
      • 通过enableEvents启用了鼠标移动事件。

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

      参数:
      e - 鼠标移动事件
      自1.1版本起:
      1.1
      参见:

    • processMouseWheelEvent

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

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

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

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

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

      参数:
      e - 鼠标滚轮事件
      自1.4版本起:
      1.4
      参见:

    • processInputMethodEvent

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

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

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

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

      参数:
      e - 输入法事件
      自1.2版本起:
      1.2
      参见:

    • processHierarchyEvent

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

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

      • 通过addHierarchyListener注册了一个HierarchyListener对象。
      • 通过enableEvents启用了层次结构事件。

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

      参数:
      e - 层次结构事件
      自1.3版本起:
      1.3
      参见:

    • processHierarchyBoundsEvent

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

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

      • 通过addHierarchyBoundsListener注册了一个HierarchyBoundsListener对象。
      • 通过enableEvents启用了层次结构边界事件。

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

      参数:
      e - 层次结构事件
      自1.3版本起:
      1.3
      参见:

    • handleEvent

      @Deprecated public boolean handleEvent(Event evt)
      Deprecated.
      As of JDK version 1.1 replaced by processEvent(AWTEvent).
      参数:
      evt - 要处理的事件
      返回:
      如果事件已处理，则返回true，否则返回false

    • mouseDown

      @Deprecated public boolean mouseDown(Event evt, int x, int y)
      Deprecated.
      As of JDK version 1.1, replaced by processMouseEvent(MouseEvent).
      参数:
      evt - 要处理的事件
      x - x坐标
      y - y坐标
      返回:
      false

    • mouseDrag

      @Deprecated public boolean mouseDrag(Event evt, int x, int y)
      Deprecated.
      As of JDK version 1.1, replaced by processMouseMotionEvent(MouseEvent).
      参数:
      evt - 要处理的事件
      x - x坐标
      y - y坐标
      返回:
      false

    • mouseUp

      @Deprecated public boolean mouseUp(Event evt, int x, int y)
      Deprecated.
      As of JDK version 1.1, replaced by processMouseEvent(MouseEvent).
      参数:
      evt - 要处理的事件
      x - x坐标
      y - y坐标
      返回:
      false

    • mouseMove

      @Deprecated public boolean mouseMove(Event evt, int x, int y)
      Deprecated.
      As of JDK version 1.1, replaced by processMouseMotionEvent(MouseEvent).
      参数:
      evt - 要处理的事件
      x - x坐标
      y - y坐标
      返回:
      false

    • mouseEnter

      @Deprecated public boolean mouseEnter(Event evt, int x, int y)
      Deprecated.
      As of JDK version 1.1, replaced by processMouseEvent(MouseEvent).
      参数:
      evt - 要处理的事件
      x - x坐标
      y - y坐标
      返回:
      false

    • mouseExit

      @Deprecated public boolean mouseExit(Event evt, int x, int y)
      Deprecated.
      As of JDK version 1.1, replaced by processMouseEvent(MouseEvent).
      参数:
      evt - 要处理的事件
      x - x坐标
      y - y坐标
      返回:
      false

    • keyDown

      @Deprecated public boolean keyDown(Event evt, int key)
      Deprecated.
      As of JDK version 1.1, replaced by processKeyEvent(KeyEvent).
      参数:
      evt - 要处理的事件
      key - 按下的键
      返回:
      false

    • keyUp

      @Deprecated public boolean keyUp(Event evt, int key)
      Deprecated.
      As of JDK version 1.1, replaced by processKeyEvent(KeyEvent).
      参数:
      evt - 要处理的事件
      key - 按下的键
      返回:
      false

    • action

      @Deprecated public boolean action(Event evt, Object what)
      Deprecated.
      As of JDK version 1.1, should register this component as ActionListener on component which fires action events.
      参数:
      evt - 要处理的事件
      what - 操作的对象
      返回:
      false

    • addNotify

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

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

      自：
      1.0
      另请参阅：

    • removeNotify

      public void removeNotify()
      使此Component通过销毁其本机屏幕资源而不可显示。

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

      自：
      1.0
      另请参阅：

    • gotFocus

      @Deprecated public boolean gotFocus(Event evt, Object what)
      Deprecated.
      As of JDK version 1.1, replaced by processFocusEvent(FocusEvent).
      参数:
      evt - 要处理的事件
      what - 焦点对象
      返回:
      false

    • lostFocus

      @Deprecated public boolean lostFocus(Event evt, Object what)
      Deprecated.
      As of JDK version 1.1, replaced by processFocusEvent(FocusEvent).
      参数:
      evt - 要处理的事件
      what - 焦点对象
      返回:
      false

    • isFocusTraversable

      @Deprecated public boolean isFocusTraversable()
      Deprecated.
      As of 1.4, replaced by isFocusable().
      返回此Component是否可以成为焦点所有者。
      返回:
      如果此Component可获得焦点，则为true; 否则为false
      自：
      1.1
      另请参阅：

    • isFocusable

      public boolean isFocusable()
      返回此组件是否可以获得焦点。
      返回:
      如果此组件可以获得焦点，则为true; 否则为false。
      自：
      1.4
      另请参阅：

    • setFocusable

      public void setFocusable(boolean focusable)
      将此组件的可获得焦点状态设置为指定值。此值覆盖组件的默认可获得焦点性。
      参数:
      focusable - 指示此组件是否可获得焦点
      自：
      1.4
      另请参阅：

    • setFocusTraversalKeys

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

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

      组件焦点遍历键的推荐默认值
      标识符 含义 默认值
      KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS 正常前向键盘遍历 按下TAB，按下CTRL-TAB
      KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS 正常反向键盘遍历 按下SHIFT-TAB，按下CTRL-SHIFT-TAB
      KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS 向上一个焦点遍历周期 无
      要禁用遍历键，请使用空Set；建议使用Collections.EMPTY_SET。

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

      如果为Set指定了null值，则此组件继承自其父级的Set。如果此组件的所有祖先都为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之一，或者keystrokes包含null，或者任何keystroke表示KEY_TYPED事件，或者任何keystroke已经映射到此组件的另一个焦点遍历操作
      自：
      1.4
      另请参阅：

    • getFocusTraversalKeys

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

      如果未为此组件明确定义遍历键集合，则返回此组件的父级的集合。如果未为此组件的任何祖先明确定义集合，则返回当前KeyboardFocusManager的默认集合。

      参数:
      id - KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS、KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS或KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS之一
      返回:
      指定操作的AWTKeyStrokes集合。该集合是不可修改的，可能为空。不会返回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，则此组件正在从祖先或当前KeyboardFocusManager继承集合。
      参数:
      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()
      请求此组件获取输入焦点，并使此组件的顶层祖先成为焦点窗口。此组件必须是可显示的、可聚焦的、可见的，并且其所有祖先（顶层窗口除外）必须可见，才能授予请求。将尽一切努力来尊重请求；但在某些情况下可能无法实现。开发人员绝不能假设此组件是焦点所有者，直到此组件接收到FOCUS_GAINED事件。如果由于此组件的顶层窗口无法成为焦点窗口而拒绝此请求，则该请求将被记住，并在稍后由用户将窗口聚焦时授予。

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

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

      注意：并非所有焦点转移都是通过调用此方法实现的。因此，组件可能会在未调用此方法或Component的任何其他requestFocus方法的情况下接收焦点。

      自从:
      1.0
      参见:

    • requestFocus

      public void requestFocus(FocusEvent.Cause cause)
      通过cause的原因请求此组件获取输入焦点，并使此组件的顶层祖先成为焦点窗口。此组件必须是可显示的、可聚焦的、可见的，并且其所有祖先（顶层窗口除外）必须可见，才能授予请求。将尽一切努力来尊重请求；但在某些情况下可能无法实现。开发人员绝不能假设此组件是焦点所有者，直到此组件接收到FOCUS_GAINED事件。

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

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

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

      注意：并非所有焦点转移都是通过调用此方法实现的。因此，组件可能会在未调用此方法或Component的任何其他requestFocus方法的情况下接收焦点。

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

    • requestFocus

      protected boolean requestFocus(boolean temporary)
      请求此Component获取输入焦点，并使此Component的顶层祖先成为焦点Window。此组件必须是可显示的、可聚焦的、可见的，并且其所有祖先（顶层窗口除外）必须可见，才能授予请求。将尽一切努力来尊重请求；但在某些情况下可能无法实现。开发人员绝不能假设此组件是焦点所有者，直到此组件接收到FOCUS_GAINED事件。如果由于此组件的顶层窗口无法成为焦点窗口而拒绝此请求，则该请求将被记住，并在稍后由用户将窗口聚焦时授予。

      此方法返回一个布尔值。如果返回false，则请求肯定会失败。如果返回true，则请求将成功除非被否决，或在本地窗口系统授予请求之前发生特殊事件，例如组件对等体的销毁。再次强调，尽管返回值为true表示请求很可能成功，但开发人员绝不能假设此组件是焦点所有者，直到此组件接收到FOCUS_GAINED事件。

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

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

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

      注意：并非所有焦点转移都是通过调用此方法实现的。因此，组件可能会在未调用此方法或Component的任何其他requestFocus方法的情况下接收焦点。

      参数:
      temporary - 如果焦点更改是临时的，例如窗口失去焦点；有关临时焦点更改的更多信息，请参阅焦点规范
      返回:
      如果焦点更改请求肯定会失败，则返回false; 如果可能会成功，则返回true
      自从:
      1.4
      参见:

    • requestFocus

      protected boolean requestFocus(boolean temporary, FocusEvent.Cause cause)
      Requests by the reason of cause that this Component get the input focus, and that this Component's top-level ancestor become the focused Window. This component must be displayable, focusable, visible and all of its ancestors (with the exception of the top-level Window) must be visible for the request to be granted. Every effort will be made to honor the request; however, in some cases it may be impossible to do so. Developers must never assume that this component is the focus owner until this component receives a FOCUS_GAINED event. If this request is denied because this component's top-level window cannot become the focused window, the request will be remembered and will be granted when the window is later focused by the user.

      This method returns a boolean value. If false is returned, the request is guaranteed to fail. If true is returned, the request will succeed unless it is vetoed, or an extraordinary event, such as disposal of the component's peer, occurs before the request can be granted by the native windowing system. Again, while a return value of true indicates that the request is likely to succeed, developers must never assume that this component is the focus owner until this component receives a FOCUS_GAINED event.

      The focus request effect may also depend on the provided cause value. If this request is succeed the {FocusEvent} generated in the result will receive the cause value specified as the argument of the method.

      This method cannot be used to set the focus owner to no component at all. Use KeyboardFocusManager.clearGlobalFocusOwner instead.

      Because the focus behavior of this method is platform-dependent, developers are strongly encouraged to use requestFocusInWindow when possible.

      Every effort will be made to ensure that FocusEvents generated as a result of this request will have the specified temporary value. However, because specifying an arbitrary temporary state may not be implementable on all native windowing systems, correct behavior for this method can be guaranteed only for lightweight Components. This method is not intended for general use, but exists instead as a hook for lightweight component libraries, such as Swing.

      Note: Not all focus transfers result from invoking this method. As such, a component may receive focus without this or any of the other requestFocus methods of Component being invoked.

      Parameters:
      temporary - true if the focus change is temporary, such as when the window loses the focus; for more information on temporary focus changes see the Focus Specification
      cause - the cause why the focus is requested
      Returns:
      false if the focus change request is guaranteed to fail; true if it is likely to succeed
      Since:
      9
      See Also:

    • requestFocusInWindow

      public boolean requestFocusInWindow()
      Requests that this Component get the input focus, if this Component's top-level ancestor is already the focused Window. This component must be displayable, focusable, visible and all of its ancestors (with the exception of the top-level Window) must be visible for the request to be granted. Every effort will be made to honor the request; however, in some cases it may be impossible to do so. Developers must never assume that this Component is the focus owner until this Component receives a FOCUS_GAINED event.

      This method returns a boolean value. If false is returned, the request is guaranteed to fail. If true is returned, the request will succeed unless it is vetoed, or an extraordinary event, such as disposal of the Component's peer, occurs before the request can be granted by the native windowing system. Again, while a return value of true indicates that the request is likely to succeed, developers must never assume that this Component is the focus owner until this Component receives a FOCUS_GAINED event.

      This method cannot be used to set the focus owner to no Component at all. Use KeyboardFocusManager.clearGlobalFocusOwner() instead.

      The focus behavior of this method can be implemented uniformly across platforms, and thus developers are strongly encouraged to use this method over requestFocus when possible. Code which relies on requestFocus may exhibit different focus behavior on different platforms.

      Note: Not all focus transfers result from invoking this method. As such, a component may receive focus without this or any of the other requestFocus methods of Component being invoked.

      Returns:
      false if the focus change request is guaranteed to fail; true if it is likely to succeed
      Since:
      1.4
      See Also:

    • requestFocusInWindow

      public boolean requestFocusInWindow(FocusEvent.Cause cause)
      Requests by the reason of cause that this Component get the input focus, if this Component's top-level ancestor is already the focused Window. This component must be displayable, focusable, visible and all of its ancestors (with the exception of the top-level Window) must be visible for the request to be granted. Every effort will be made to honor the request; however, in some cases it may be impossible to do so. Developers must never assume that this Component is the focus owner until this Component receives a FOCUS_GAINED event.

      This method returns a boolean value. If false is returned, the request is guaranteed to fail. If true is returned, the request will succeed unless it is vetoed, or an extraordinary event, such as disposal of the Component's peer, occurs before the request can be granted by the native windowing system. Again, while a return value of true indicates that the request is likely to succeed, developers must never assume that this Component is the focus owner until this Component receives a FOCUS_GAINED event.

      The focus request effect may also depend on the provided cause value. If this request is succeed the FocusEvent generated in the result will receive the cause value specified as the argument of the method.

      This method cannot be used to set the focus owner to no Component at all. Use KeyboardFocusManager.clearGlobalFocusOwner() instead.

      The focus behavior of this method can be implemented uniformly across platforms, and thus developers are strongly encouraged to use this method over requestFocus(FocusEvent.Cause) when possible. Code which relies on requestFocus(FocusEvent.Cause) may exhibit different focus behavior on different platforms.

      Note: Not all focus transfers result from invoking this method. As such, a component may receive focus without this or any of the other requestFocus methods of Component being invoked.

      Parameters:
      cause - the cause why the focus is requested
      Returns:
      false if the focus change request is guaranteed to fail; true if it is likely to succeed
      Since:
      9
      See Also:

    • requestFocusInWindow

      protected boolean requestFocusInWindow(boolean temporary)
      请求使此组件获得输入焦点，如果此组件的顶级祖先已经是具有焦点的窗口。该组件必须是可显示的、可聚焦的、可见的，并且所有祖先（顶级窗口除外）必须可见才能授予请求。将尽一切努力来满足请求；但是，在某些情况下可能无法做到。开发人员绝不能假设此组件是焦点所有者，直到此组件接收到FOCUS_GAINED事件为止。

      此方法返回一个布尔值。如果返回false，则请求肯定会失败。如果返回true，则请求将成功除非被否决，或者在本地窗口系统授予请求之前发生异常事件，例如组件的对等体被处理。再次强调，虽然返回值为true表示请求很可能成功，但开发人员绝不能假设此组件是焦点所有者，直到此组件接收到FOCUS_GAINED事件。

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

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

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

      注意：并非所有焦点转移都是通过调用此方法而发生的。因此，组件可能在未调用此方法或任何其他Component的requestFocus方法的情况下接收焦点。

      参数:
      temporary - 如果焦点更改是临时的，则为true，例如当窗口失去焦点时；有关临时焦点更改的更多信息，请参见焦点规范
      返回:
      如果焦点更改请求肯定会失败，则返回false；如果可能会成功，则返回true
      自版本:
      1.4
      另请参阅:

    • getFocusCycleRootAncestor

      public Container getFocusCycleRootAncestor()
      返回此组件焦点遍历周期的焦点循环根容器。每个焦点遍历周期只有一个焦点循环根，而不是容器的每个组件只属于一个焦点遍历周期。作为焦点循环根的容器属于两个周期：一个根在容器本身，另一个根在容器的最近焦点循环根祖先。对于这样的容器，此方法将返回容器的最近焦点循环根祖先。
      返回:
      此组件的最近焦点循环根祖先
      自版本:
      1.4
      另请参阅:

    • isFocusCycleRoot

      public boolean isFocusCycleRoot(Container container)
      返回指定容器是否是此组件焦点遍历周期的焦点循环根。每个焦点遍历周期只有一个焦点循环根，而不是容器的每个组件只属于一个焦点遍历周期。
      参数:
      container - 要测试的容器
      返回:
      如果指定容器是此组件的焦点循环根，则返回true；否则返回false
      自版本:
      1.4
      另请参阅:

    • transferFocus

      public void transferFocus()
      将焦点转移到下一个组件，就好像此组件是焦点所有者一样。
      自版本:
      1.1
      另请参阅:

    • nextFocus

      @Deprecated public void nextFocus()
      Deprecated.
      As of JDK version 1.1, replaced by transferFocus().

    • transferFocusBackward

      public void transferFocusBackward()
      将焦点转移到上一个组件，就好像此组件是焦点所有者一样。
      自版本:
      1.4
      另请参阅:

    • transferFocusUpCycle

      public void transferFocusUpCycle()
      将焦点向上移动一个焦点遍历周期。通常，焦点所有者设置为此组件的焦点循环根，并且当前焦点循环根设置为新焦点所有者的焦点循环根。但是，如果此组件的焦点循环根是一个窗口，则焦点所有者设置为焦点循环根的默认焦点组件，并且当前焦点循环根不变。
      自版本:
      1.4
      另请参阅:

    • hasFocus

      public boolean hasFocus()
      如果此组件是焦点所有者，则返回true。此方法已过时，已被isFocusOwner()替代。
      返回:
      如果此组件是焦点所有者，则返回true；否则返回false
      自版本:
      1.2

    • isFocusOwner

      public boolean isFocusOwner()
      如果此组件是焦点所有者，则返回true。
      返回:
      如果此组件是焦点所有者，则返回true；否则返回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。该监听器将注册所有此类的绑定属性，包括以下内容：
      • 此组件的字体（"font"）
      • 此组件的背景颜色（"background"）
      • 此组件的前景颜色（"foreground"）
      • 此组件的可聚焦性（"focusable"）
      • 此组件的焦点遍历键启用状态（"focusTraversalKeysEnabled"）
      • 此组件的FORWARD_TRAVERSAL_KEYS集合（"forwardFocusTraversalKeys"）
      • 此组件的BACKWARD_TRAVERSAL_KEYS集合（"backwardFocusTraversalKeys"）
      • 此组件的UP_CYCLE_TRAVERSAL_KEYS集合（"upCycleFocusTraversalKeys"）
      • 此组件的首选大小（"preferredSize"）
      • 此组件的最小大小（"minimumSize"）
      • 此组件的最大大小（"maximumSize"）
      • 此组件的名称（"name"）
      请注意，如果此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。指定的属性可以是用户定义的，也可以是以下之一：
      • 此组件的字体（"font"）
      • 此组件的背景颜色（"background"）
      • 此组件的前景颜色（"foreground"）
      • 此组件的可聚焦性（"focusable"）
      • 此组件的焦点遍历键启用状态（"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 - 属性的旧值（作为short）
      newValue - 属性的新值（作为short）
      自版本:
      1.5
      另请参阅:

    • firePropertyChange

      public void firePropertyChange(String propertyName, long oldValue, long newValue)
      报告绑定属性更改。
      参数:
      propertyName - 已更改的属性的程序名称
      oldValue - 属性的旧值（作为long）
      newValue - 属性的新值（作为long）
      自版本:
      1.5
      另请参阅:

    • firePropertyChange

      public void firePropertyChange(String propertyName, float oldValue, float newValue)
      报告绑定属性更改。
      参数:
      propertyName - 已更改的属性的程序名称
      oldValue - 属性的旧值（作为float）
      newValue - 属性的新值（作为float）
      自版本:
      1.5
      另请参阅:

    • firePropertyChange

      public void firePropertyChange(String propertyName, double oldValue, double newValue)
      报告绑定属性更改。
      参数:
      propertyName - 已更改的属性的程序名称
      oldValue - 属性的旧值（作为double）
      newValue - 属性的新值（作为double）
      自版本:
      1.5
      另请参阅:

    • setComponentOrientation

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

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

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

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

      参数:
      o - 要设置的方向
      另请参阅:

    • getComponentOrientation

      public ComponentOrientation getComponentOrientation()
      检索用于对此组件中的元素或文本进行排序的与语言有关的方向。希望尊重方向的LayoutManager和Component子类在执行布局或绘制之前应调用此方法以获取组件的方向。
      返回:
      用于对元素或文本进行排序的方向
      另请参阅:

    • applyComponentOrientation

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

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

      参数:
      orientation - 此组件及其中包含的组件的新组件方向。
      抛出:
      NullPointerException - 如果orientation为null。
      自版本:
      1.4
      另请参阅:

    • getAccessibleContext

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

    • setMixingCutoutShape

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

      shape参数可能具有以下值：

      • null - 恢复默认切割形状（等于组件的getBounds()的矩形）
      • empty-shape - 不从重量级组件中切出任何内容。这使得此轻量级组件实际上是透明的。请注意，轻量级组件的后代仍会影响重量级组件的形状。一个empty-shape的示例是new Rectangle()。
      • non-empty-shape - 给定形状将从重量级组件中切出。

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

      参数:
      shape - 新的“混合切割”形状
      自版本:
      9