模块  java.desktop
软件包  java.awt

Class Component

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

    Component类是非菜单相关的Abstract Window Toolkit组件的抽象超类。 也可以直接扩展类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使用的绘制机制的更多信息，包括有关如何编写最有效绘制代码的信息，请参阅Painting in AWT and Swing 。

    有关焦点子系统的详细信息，请参阅How to Use the Focus Subsystem ，在Java教程一节，并Focus Specification获取更多信息。

    另请参见：
    Serialized Form

    • 字段详细信息

      • TOP_ALIGNMENT

        public static final float TOP_ALIGNMENT
        易用性常数为getAlignmentY() 。 指定组件顶部的对齐方式。
        另请参见：
        getAlignmentY() ， 常数字段值

      • BOTTOM_ALIGNMENT

        public static final float BOTTOM_ALIGNMENT
        易用性常数为getAlignmentY 。 指定组件底部的对齐方式。
        另请参见：
        getAlignmentY() ， 常数字段值

      • LEFT_ALIGNMENT

        public static final float LEFT_ALIGNMENT
        易用性常数为getAlignmentX 。 指定组件左侧的对齐方式。
        另请参见：
        getAlignmentX() ， 常数字段值

      • RIGHT_ALIGNMENT

        public static final float RIGHT_ALIGNMENT
        易于使用的常数为getAlignmentX 。 指定组件右侧的对齐方式。
        另请参见：
        getAlignmentX() ， 常数字段值

      • accessibleContext

        protected AccessibleContext accessibleContext
        AccessibleContext与此 Component相关联。

    • 构造方法详细信息

      • Component

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

    • 方法详细信息

      • getName

        public String getName()
        获取组件的名称。
        结果
        这个组件的名称
        从以下版本开始：
        1.1
        另请参见：
        setName(java.lang.String)

      • setName

        public void setName​(String name)
        将组件的名称设置为指定的字符串。
        参数
        name - 该组件名称的字符串
        从以下版本开始：
        1.1
        另请参见：
        getName()

      • getParent

        public Container getParent()
        获取此组件的父级。
        结果
        此组件的父容器
        从以下版本开始：
        1.0

      • setDropTarget

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

      • getDropTarget

        public DropTarget getDropTarget()
        获取 DropTarget与此相关 Component 。
        结果
        下降目标

      • getGraphicsConfiguration

        public GraphicsConfiguration getGraphicsConfiguration()
        获取GraphicsConfiguration与此相关Component 。 如果Component尚未分配一个特定的GraphicsConfiguration ，该GraphicsConfiguration的的Component返回对象的顶级容器。 如果已创建Component但尚未添加到Container ，则此方法返回null 。
        结果
        所述 GraphicsConfiguration此使用 Component或 null
        从以下版本开始：
        1.3

      • getTreeLock

        public final Object getTreeLock()
        获取此组件的锁定对象（拥有线程同步监视器的对象），用于AWT组件树和布局操作。
        结果
        这个组件的锁定对象

      • getToolkit

        public Toolkit getToolkit()
        获取此组件的工具包。 请注意，包含组件的框架控制该组件使用的工具包。 因此，如果组件从一个帧移动到另一个帧，它使用的工具包可能会更改。
        结果
        该组件的工具包
        从以下版本开始：
        1.0

      • isValid

        public boolean isValid()
        确定此组件是否有效。 如果组件的大小正确并且位于其父容器中且其所有子组件也有效，则该组件有效。 为了考虑对等体的大小要求，组件在首次显示在屏幕上之前无效。 到父容器完全实现时，其所有组件都将有效。
        结果
        true如果组件有效，否则为 false
        从以下版本开始：
        1.0
        另请参见：
        validate() ， invalidate()

      • isDisplayable

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

        在将组件添加到可显示的包含层次结构中或使其包含层次结构可显示时，组件可显示。 当包含层次结构打包或使其可见时，可以显示包含层次结构。

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

        结果
        true如果组件可显示， false
        从以下版本开始：
        1.2
        另请参见：
        Container.add(Component) ， Window.pack() ， Window.show() ， Container.remove(Component) ， Window.dispose()

      • isVisible

        public boolean isVisible()
        确定当其父组件可见时此组件是否应该可见。 组件最初是可见的，但顶级组件（例如Frame对象） Frame 。
        结果
        true如果组件可见，否则为 false
        从以下版本开始：
        1.0
        另请参见：
        setVisible(boolean)

      • 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() ， Container.getMousePosition(boolean)

      • isShowing

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

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

        • 该组件已添加到可见的ScrollPane但Component当前不在滚动窗格的视图端口中。
        • Component被另一个Component或Container 。
        结果
        true如果组件显示， false
        从以下版本开始：
        1.0
        另请参见：
        setVisible(boolean)

      • isEnabled

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

      • setEnabled

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

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

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

        参数
        b - 如果是true ，则启用此组件; 否则此组件被禁用
        从以下版本开始：
        1.1
        另请参见：
        isEnabled() ， isLightweight()

      • 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
        另请参见：
        processKeyEvent(java.awt.event.KeyEvent)

      • setVisible

        public void setVisible​(boolean b)
        显示或隐藏此组件，具体取决于参数b的值。

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

        参数
        b - 如果是true ，则显示此组件; 否则，隐藏此组件
        从以下版本开始：
        1.1
        另请参见：
        isVisible() ， invalidate()

      • 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(java.awt.Color)

      • setForeground

        public void setForeground​(Color c)
        设置此组件的前景色。
        参数
        c - 成为此组件前景色的颜色; 如果此参数为null则此组件将继承其父级的前景色
        从以下版本开始：
        1.0
        另请参见：
        getForeground()

      • isForegroundSet

        public boolean isForegroundSet()
        返回是否已为此Component显式设置前景色。 如果此方法返回false ，则此Component将从祖先继承其前景色。
        结果
        true如果已为此Component显式设置了前景色; 否则为false 。
        从以下版本开始：
        1.4

      • getBackground

        public Color getBackground()
        获取此组件的背景颜色。
        结果
        这个组件的背景颜色; 如果此组件没有背景颜色，则返回其父级的背景颜色
        从以下版本开始：
        1.0
        另请参见：
        setBackground(java.awt.Color)

      • setBackground

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

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

        参数
        c - 成为此组件颜色的颜色; 如果此参数为null ，则此组件将继承其父级的背景颜色
        从以下版本开始：
        1.0
        另请参见：
        getBackground()

      • isBackgroundSet

        public boolean isBackgroundSet()
        返回是否已为此Component显式设置背景颜色。 如果此方法返回false ，则此Component将从祖先继承其背景颜色。
        结果
        true如果已为此Component显式设置背景颜色; 否则为false 。
        从以下版本开始：
        1.4

      • getFont

        public Font getFont()
        获取此组件的字体。
        Specified by:
        getFont in interface MenuContainer
        结果
        这个组件的字体; 如果尚未为此组件设置字体，则返回其父级的字体
        从以下版本开始：
        1.0
        另请参见：
        setFont(java.awt.Font)

      • setFont

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

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

        参数
        f - 成为此组件字体的字体; 如果此参数为null则此组件将继承其父级的字体
        从以下版本开始：
        1.0
        另请参见：
        getFont() ， invalidate()

      • isFontSet

        public boolean isFontSet()
        返回是否已为此Component显式设置字体。 如果此方法返回false ，则此Component从祖先继承其字体。
        结果
        true如果已为此Component显式设置了字体; 否则为false 。
        从以下版本开始：
        1.4

      • getLocale

        public Locale getLocale()
        获取此组件的语言环境。
        结果
        这个组件的语言环境; 如果此组件没有语言环境，则返回其父组件的语言环境
        异常
        IllegalComponentStateException - 如果 Component没有自己的语言环境且尚未添加到包含层次结构中，则可以从包含父项确定语言环境
        从以下版本开始：
        1.1
        另请参见：
        setLocale(java.util.Locale)

      • setLocale

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

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

        参数
        l - 成为此组件的语言环境的语言环境
        从以下版本开始：
        1.1
        另请参见：
        getLocale() ， invalidate()

      • getColorModel

        public ColorModel getColorModel()
        获取用于在输出设备上显示组件的 ColorModel的实例。
        结果
        此组件使用的颜色模型
        从以下版本开始：
        1.0
        另请参见：
        ColorModel ， ComponentPeer.getColorModel() ， Toolkit.getColorModel()

      • getLocation

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

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

        结果
        Point的实例，表示组件父级坐标空间中组件边界的左上角
        从以下版本开始：
        1.1
        另请参见：
        setLocation(int, int) ， getLocationOnScreen()

      • getLocationOnScreen

        public Point getLocationOnScreen()
        以点的形式获取此组件的位置，指定组件在屏幕坐标空间中的左上角。
        结果
        Point的实例，表示屏幕坐标空间中组件边界的左上角
        异常
        IllegalComponentStateException - 如果组件未显示在屏幕上
        另请参见：
        setLocation(int, int) ， getLocation()

      • 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
        另请参见：
        getLocation() ， setBounds(int, int, int, int) ， invalidate()

      • 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
        另请参见：
        getLocation() ， setBounds(int, int, int, int) ， invalidate()

      • getSize

        public Dimension getSize()
        以Dimension对象的形式返回此组件的大小。 Dimension对象的height字段包含此组件的高度， Dimension对象的width字段包含此组件的宽度。
        结果
        一个 Dimension对象，指示此组件的大小
        从以下版本开始：
        1.1
        另请参见：
        setSize(int, int)

      • 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
        另请参见：
        getSize() ， setBounds(int, int, int, int) ， invalidate()

      • resize

        @Deprecated
public void resize​(int width,
                   int height)
        Deprecated.
        As of JDK version 1.1, replaced by setSize(int, int).
        调整此组件的大小。
        参数
        width - 组件的新宽度
        height - 组件的新高度

      • resize

        @Deprecated
public void resize​(Dimension d)
        Deprecated.
        As of JDK version 1.1, replaced by setSize(Dimension).
        调整此组件的大小，使其宽度为 d.width ，高度为 d.height 。
        参数
        d - 此组件的新大小

      • 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 -coordinate
        y - 此组件的新 y -coordinate
        width - 该组件的新 width
        height - 此组件的新 height
        从以下版本开始：
        1.1
        另请参见：
        getBounds() ， setLocation(int, int) ， setLocation(Point) ， setSize(int, int) ， setSize(Dimension) ， invalidate()

      • 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 - 矩形的高度

      • 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()

      • isLightweight

        public boolean isLightweight()
        轻量级组件没有本机工具包同级。 Component和Container子类（ Component包括此包中定义的子类，如Button或Scrollbar ）是轻量级的。 所有Swing组件都是轻量级。

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

        结果
        如果此组件具有轻量级对等方，则为true; 如果它有本地对等或没有对等，则为false
        从以下版本开始：
        1.2
        另请参见：
        isDisplayable()

      • setPreferredSize

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

      • isPreferredSizeSet

        public boolean isPreferredSizeSet()
        如果首选大小已设置为非 null值，则返回true，否则返回false。
        结果
        如果已使用非null值调用 setPreferredSize则 setPreferredSize true。
        从以下版本开始：
        1.5

      • getPreferredSize

        public Dimension getPreferredSize()
        获取此组件的首选大小。
        结果
        一个维度对象，指示此组件的首选大小
        另请参见：
        getMinimumSize() ， LayoutManager

      • 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
        另请参见：
        getMinimumSize() ， isMinimumSizeSet()

      • isMinimumSizeSet

        public boolean isMinimumSizeSet()
        返回是否已使用非null值调用 setMinimumSize 。
        结果
        如果已使用非null值调用 setMinimumSize则 setMinimumSize true。
        从以下版本开始：
        1.5

      • 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
        另请参见：
        getMaximumSize() ， isMaximumSizeSet()

      • isMaximumSizeSet

        public boolean isMaximumSizeSet()
        如果已将最大大小设置为非 null值，则返回true，否则返回false。
        结果
        如果 maximumSize为非 null ， null true，否则为false
        从以下版本开始：
        1.5

      • 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() ， FontMetrics

      • getBaselineResizeBehavior

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

        默认实现返回BaselineResizeBehavior.OTHER 。 具有基线的子类应适当地覆盖。 子类永远不应该返回null ; 如果基线无法计算则返回BaselineResizeBehavior.OTHER 。 呼叫者应首先使用getBaseline询问基线，如果返回值> = 0，请使用此方法。 即使getBaseline返回小于0的值，此方法也可以返回BaselineResizeBehavior.OTHER getBaseline的值。

        结果
        一个枚举，指示基线随组件大小的变化而变化的方式
        从以下版本开始：
        1.6
        另请参见：
        getBaseline(int, int)

      • doLayout

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

      • layout

        @Deprecated
public void layout()
        Deprecated.
        As of JDK version 1.1, replaced by doLayout().

      • invalidate

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

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

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

        可能经常调用此方法，因此它应该可以快速工作。

        从以下版本开始：
        1.0
        另请参见：
        validate() ， doLayout() ， LayoutManager ， Container.isValidateRoot()

      • revalidate

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

        此方法首先使从此组件开始的组件层次结构无效，直至最近的验证根。 然后，从最近的验证根开始验证组件层次结构。

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

        从以下版本开始：
        1.7
        另请参见：
        Container.isValidateRoot()

      • getGraphics

        public Graphics getGraphics()
        为此组件创建图形上下文。 如果此组件当前不可显示，则此方法将返回null 。
        结果
        此组件的图形上下文，如果没有， null
        从以下版本开始：
        1.0
        另请参见：
        paint(java.awt.Graphics)

      • getFontMetrics

        public FontMetrics getFontMetrics​(Font font)
        获取指定字体的字体度量标准。 警告：由于字体度量受FontRenderContext的影响，并且此方法不提供，因此它只能返回默认渲染上下文的度量，这可能与在组件上呈现时使用的度量不匹配（如果正在使用Graphics2D功能）。 而是可以通过在Font类上调用Graphics.getFontMetrics()或文本测量API在渲染时获取度量。
        参数
        font - 要获取字体度量的字体
        结果
        font的字体指标
        从以下版本开始：
        1.0
        另请参见：
        getFont() ， ComponentPeer.getFontMetrics(Font) ， Toolkit.getFontMetrics(Font)

      • setCursor

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

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

        参数
        cursor - Cursor类定义的常量Cursor ; 如果此参数为null则此组件将继承其父级的游标
        从以下版本开始：
        1.1
        另请参见：
        isEnabled() ， isShowing() ， getCursor() ， contains(int, int) ， Toolkit.createCustomCursor(java.awt.Image, java.awt.Point, java.lang.String) ， Cursor

      • getCursor

        public Cursor getCursor()
        获取组件中设置的光标。 如果组件没有设置游标，则返回其父级的游标。 如果未在整个层次结构中设置游标，则返回Cursor.DEFAULT_CURSOR 。
        结果
        此组件的光标
        从以下版本开始：
        1.1
        另请参见：
        setCursor(java.awt.Cursor)

      • isCursorSet

        public boolean isCursorSet()
        返回是否已为此Component显式设置游标。 如果此方法返回false ，则此Component从祖先继承其游标。
        结果
        true如果已为此Component显式设置了游标; 否则为false 。
        从以下版本开始：
        1.4

      • paint

        public void paint​(Graphics g)
        绘制这个组件。

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

        出于性能原因，零宽度或高度的Component在首次显示时不被认为需要涂漆，也不认为需要修理。

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

        参数
        g - 用于绘画的图形上下文
        从以下版本开始：
        1.0
        另请参见：
        update(java.awt.Graphics)

      • update

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

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

        update方法Component调用此组件的paint方法来重绘此组件。 此方法通常由子类重写，子类需要执行其他工作以响应对repaint的调用。 重写此方法的Component子类应调用super.update(g) ，或直接从其update方法调用paint(g) 。

        图形上下文的原点，其（ 0 ， 0 ）坐标点，是该组件的左上角。 图形上下文的剪切区域是该组件的边界矩形。

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

        参数
        g - 用于更新的指定上下文
        从以下版本开始：
        1.0
        另请参见：
        paint(java.awt.Graphics) ， repaint()

      • paintAll

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

        图形上下文的原点，其（ 0 ， 0 ）坐标点，是该组件的左上角。 图形上下文的剪切区域是该组件的边界矩形。

        参数
        g - 用于绘画的图形上下文
        从以下版本开始：
        1.0
        另请参见：
        paint(java.awt.Graphics)

      • repaint

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

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

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

        从以下版本开始：
        1.0
        另请参见：
        update(Graphics)

      • repaint

        public void repaint​(long tm)
        重新绘制组件。 如果此组件是轻量级组件，这将导致一个呼叫paint内tm毫秒。

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

        参数
        tm - 更新前的最长时间（以毫秒为单位）
        从以下版本开始：
        1.0
        另请参见：
        paint(java.awt.Graphics) ， update(Graphics)

      • repaint

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

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

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

        参数
        x - x坐标
        y - y坐标
        width - 宽度
        height - 身高
        从以下版本开始：
        1.0
        另请参见：
        update(Graphics)

      • repaint

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

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

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

        参数
        tm - 更新前的最长时间（以毫秒为单位）
        x - x坐标
        y - y坐标
        width - 宽度
        height - 身高
        从以下版本开始：
        1.0
        另请参见：
        update(Graphics)

      • print

        public void print​(Graphics g)
        打印此组件。 对于必须在打印前进行特殊处理的组件，应该应用此方法，或者应该以不同于它们的方式进行打印。

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

        图形上下文的原点，其（ 0 ， 0 ）坐标点，是该组件的左上角。 图形上下文的剪切区域是该组件的边界矩形。

        参数
        g - 用于打印的图形上下文
        从以下版本开始：
        1.0
        另请参见：
        paint(Graphics)

      • printAll

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

        图形上下文的原点，其（ 0 ， 0 ）坐标点，是该组件的左上角。 图形上下文的剪切区域是该组件的边界矩形。

        参数
        g - 用于打印的图形上下文
        从以下版本开始：
        1.0
        另请参见：
        print(Graphics)

      • 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
        另请参见：
        isDisplayable() ， GraphicsEnvironment.isHeadless()

      • createVolatileImage

        public VolatileImage createVolatileImage​(int width,
                                         int height)
        创建用于双缓冲的易失性屏幕外可绘制图像。
        参数
        width - 指定的宽度
        height - 指定的高度
        结果
        屏幕外可绘制图像，可用于双缓冲。 所述null值，如果组件是不可显示或GraphicsEnvironment.isHeadless()返回true 。
        从以下版本开始：
        1.4
        另请参见：
        VolatileImage ， isDisplayable() ， GraphicsEnvironment.isHeadless()

      • createVolatileImage

        public VolatileImage createVolatileImage​(int width,
                                         int height,
                                         ImageCapabilities caps)
                                  throws AWTException
        使用给定的功能创建易失的屏幕外可绘制图像。 由于操作系统问题，此映像的内容可能随时丢失，因此必须通过VolatileImage界面管理VolatileImage 。
        参数
        width - 指定的宽度
        height - 指定的高度
        caps - 图像功能
        结果
        VolatileImage对象，可用于管理表面内容丢失和功能。 所述null值，如果组件是不可显示或GraphicsEnvironment.isHeadless()返回true 。
        异常
        AWTException - 如果无法创建具有指定功能的图像
        从以下版本开始：
        1.4
        另请参见：
        VolatileImage

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

      • checkImage

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

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

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

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

        参数
        image - 正在检查其状态的 Image对象
        width - 要检查其状态的缩放版本的宽度
        height - 要检查其状态的缩放版本的高度
        observer - 正在准备图像时要通知的 ImageObserver对象
        结果
        ImageObserver标志的按位包含 OR表示当前可用的图像信息
        从以下版本开始：
        1.0
        另请参见：
        prepareImage(Image, int, int, java.awt.image.ImageObserver) ， Toolkit.checkImage(Image, int, int, java.awt.image.ImageObserver) ， ImageObserver

      • getIgnoreRepaint

        public boolean getIgnoreRepaint()
        结果
        是否应忽略从操作系统接收的绘制消息。
        从以下版本开始：
        1.4
        另请参见：
        setIgnoreRepaint(boolean)

      • contains

        public boolean contains​(int x,
                        int y)
        检查此组件是否“包含”指定的点，其中 x和 y定义为相对于此组件的坐标系。
        参数
        x - 该点的 x坐标
        y - 该点的 y坐标
        结果
        true如果该点在组件内; 否则false
        从以下版本开始：
        1.1
        另请参见：
        getComponentAt(int, int)

      • 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(Point)

      • getComponentAt

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

        如果（ x ， y ）坐标位于其边界框内，则locate方法（ Component仅返回组件本身，否则返回null 。

        参数
        x - x坐标
        y - y坐标
        结果
        包含（ x ， y ）位置的组件或子组件; null如果位置在此组件之外
        从以下版本开始：
        1.0
        另请参见：
        contains(int, int)

      • 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
        另请参见：
        contains(int, int)

      • 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)
        将事件调度到此组件或其子组件之一。 电话processEvent返回的，已为启用的1.1类型的事件，之前Component 。
        参数
        e - 活动

      • postEvent

        @Deprecated
public boolean postEvent​(Event e)
        Deprecated.
        As of JDK version 1.1, replaced by dispatchEvent(AWTEvent).
        从界面复制的说明： MenuContainer
        将事件发布给听众。
        Specified by:
        postEvent在界面 MenuContainer
        参数
        e - 要发送的事件
        结果
        发布活动的结果

      • removeFocusListener

        public void removeFocusListener​(FocusListener l)
        删除指定的焦点侦听器，以便它不再从此组件接收焦点事件。 如果先前未将参数指定的侦听器添加到此组件，则此方法不执行任何功能，也不会引发异常。 如果监听器l是null ，则不会抛出异常并且不执行任何操作。

        有关AWT螺纹模型的详细信息，请参阅AWT Threading Issues 。

        参数
        l - 焦点监听器
        从以下版本开始：
        1.1
        另请参见：
        FocusEvent ， FocusListener ， addFocusListener(java.awt.event.FocusListener) ， getFocusListeners()

      • removeKeyListener

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

        有关AWT螺纹模型的详细信息，请参阅AWT Threading Issues 。

        参数
        l - 关键的倾听者
        从以下版本开始：
        1.1
        另请参见：
        KeyEvent ， KeyListener ， addKeyListener(java.awt.event.KeyListener) ， getKeyListeners()

      • removeMouseListener

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

        有关AWT螺纹模型的详细信息，请参阅AWT Threading Issues 。

        参数
        l - 鼠标侦听器
        从以下版本开始：
        1.1
        另请参见：
        MouseEvent ， MouseListener ， addMouseListener(java.awt.event.MouseListener) ， getMouseListeners()

      • getInputMethodRequests

        public InputMethodRequests getInputMethodRequests()
        获取输入方法请求处理程序，它支持来自此组件的输入方法的请求。 支持现场文本输入的组件必须覆盖此方法才能返回InputMethodRequests实例。 同时，它还必须处理输入方法事件。
        结果
        此组件的输入方法请求处理程序，默认为 null
        从以下版本开始：
        1.2
        另请参见：
        addInputMethodListener(java.awt.event.InputMethodListener)

      • getInputContext

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

      • enableEvents

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

        将该事件类型的侦听器添加到组件时，将自动启用事件类型。

        此方法只需要由Component的子类调用，无论是否注册了侦听器，都希望将指定的事件类型传递给processEvent 。

        参数
        eventsToEnable - 定义事件类型的事件掩码
        从以下版本开始：
        1.1
        另请参见：
        processEvent(java.awt.AWTEvent) ， disableEvents(long) ， AWTEvent

      • disableEvents

        protected final void disableEvents​(long eventsToDisable)
        禁用由指定的事件掩码参数定义的事件传递给此组件。
        参数
        eventsToDisable - 定义事件类型的事件掩码
        从以下版本开始：
        1.1
        另请参见：
        enableEvents(long)

      • coalesceEvents

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

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

        参数
        existingEvent - 该活动已在 EventQueue
        newEvent - 该活动被发布到 EventQueue
        结果
        合并的事件，或 null表示没有完成合并

      • processComponentEvent

        protected void processComponentEvent​(ComponentEvent e)
        处理在此组件上发生的组件事件，方法是将它们分派给任何已注册的ComponentListener对象。

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

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

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

        参数
        e - 组件事件
        从以下版本开始：
        1.1
        另请参见：
        ComponentEvent ， ComponentListener ， addComponentListener(java.awt.event.ComponentListener) ， enableEvents(long)

      • 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
        另请参见：
        FocusEvent ， FocusListener ， KeyboardFocusManager ， addFocusListener(java.awt.event.FocusListener) ， enableEvents(long) ， dispatchEvent(java.awt.AWTEvent)

      • processKeyEvent

        protected void processKeyEvent​(KeyEvent e)
        处理在此组件上发生的关键事件，方法是将它们分派给任何已注册的KeyListener对象。

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

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

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

        从J2SE 1.4开始， KeyEvent被重定向到焦点所有者。 有关详细信息，请参阅Focus Specification 。

        调用Component的dispatchEvent方法与KeyEvent作为参数会导致对呼叫Component的processKeyEvent方法，而不管当前的KeyboardFocusManager只要正在显示组件，突出重点，并启用和关键事件上启用。

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

        参数
        e - 关键事件
        从以下版本开始：
        1.1
        另请参见：
        KeyEvent ， KeyListener ， KeyboardFocusManager ， DefaultKeyboardFocusManager ， processEvent(java.awt.AWTEvent) ， dispatchEvent(java.awt.AWTEvent) ， addKeyListener(java.awt.event.KeyListener) ， enableEvents(long) ， isShowing()

      • processMouseEvent

        protected void processMouseEvent​(MouseEvent e)
        处理在此组件上发生的鼠标事件，方法是将它们分派给任何已注册的MouseListener对象。

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

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

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

        参数
        e - 鼠标事件
        从以下版本开始：
        1.1
        另请参见：
        MouseEvent ， MouseListener ， addMouseListener(java.awt.event.MouseListener) ， enableEvents(long)

      • processMouseMotionEvent

        protected void processMouseMotionEvent​(MouseEvent e)
        处理在此组件上发生的鼠标移动事件，方法是将它们分派给任何已注册的MouseMotionListener对象。

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

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

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

        参数
        e - 鼠标移动事件
        从以下版本开始：
        1.1
        另请参见：
        MouseEvent ， MouseMotionListener ， addMouseMotionListener(java.awt.event.MouseMotionListener) ， enableEvents(long)

      • processMouseWheelEvent

        protected void processMouseWheelEvent​(MouseWheelEvent e)
        处理在此组件上发生的鼠标滚轮事件，方法是将它们分派给任何已注册的MouseWheelListener对象。

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

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

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

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

        参数
        e - 鼠标滚轮事件
        从以下版本开始：
        1.4
        另请参见：
        MouseWheelEvent ， MouseWheelListener ， addMouseWheelListener(java.awt.event.MouseWheelListener) ， enableEvents(long)

      • processInputMethodEvent

        protected void processInputMethodEvent​(InputMethodEvent e)
        处理在此组件上发生的输入方法事件，方法是将它们分派给任何已注册的InputMethodListener对象。

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

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

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

        参数
        e - 输入法事件
        从以下版本开始：
        1.2
        另请参见：
        InputMethodEvent ， InputMethodListener ， addInputMethodListener(java.awt.event.InputMethodListener) ， enableEvents(long)

      • processHierarchyEvent

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

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

        • HierarchyListener对象是通过addHierarchyListener注册的。
        • 通过enableEvents启用层次结构事件。

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

        参数
        e - 层次结构事件
        从以下版本开始：
        1.3
        另请参见：
        HierarchyEvent ， HierarchyListener ， addHierarchyListener(java.awt.event.HierarchyListener) ， enableEvents(long)

      • processHierarchyBoundsEvent

        protected void processHierarchyBoundsEvent​(HierarchyEvent e)
        处理此组件上发生的层次结构边界事件，方法是将它们分派给任何已注册的HierarchyBoundsListener对象。

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

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

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

        参数
        e - 层次结构事件
        从以下版本开始：
        1.3
        另请参见：
        HierarchyEvent ， HierarchyBoundsListener ， addHierarchyBoundsListener(java.awt.event.HierarchyBoundsListener) ， enableEvents(long)

      • 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
        另请参见：
        isDisplayable() ， removeNotify() ， invalidate()

      • removeNotify

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

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

        从以下版本开始：
        1.0
        另请参见：
        isDisplayable() ， addNotify()

      • 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是否可以成为焦点所有者。
        结果
        true若Component可Component ; 否则为false
        从以下版本开始：
        1.1
        另请参见：
        setFocusable(boolean)

      • isFocusable

        public boolean isFocusable()
        返回是否可以聚焦此Component。
        结果
        true如果此组件是可聚焦的; 否则为false 。
        从以下版本开始：
        1.4
        另请参见：
        setFocusable(boolean)

      • setFocusable

        public void setFocusable​(boolean focusable)
        将此Component的可聚焦状态设置为指定值。 此值将覆盖Component的默认可聚焦性。
        参数
        focusable - 指示此Component是否可聚焦
        从以下版本开始：
        1.4
        另请参见：
        isFocusable()

      • setFocusTraversalKeys

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

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

        Recommended default values for a Component's focus traversal keys Identifier Meaning Default KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS Normal forward keyboard traversal TAB on KEY_PRESSED, CTRL-TAB on KEY_PRESSED KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS Normal reverse keyboard traversal SHIFT-TAB on KEY_PRESSED, CTRL-SHIFT-TAB on KEY_PRESSED KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS Go up one focus traversal cycle none
        要禁用遍历键，请使用空集; 建议使用Collections.EMPTY_SET。

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

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

        这种方法可能抛出ClassCastException如有Object在keystrokes不是AWTKeyStroke 。

        参数
        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事件，或者任何击键已经映射到此Component的另一个焦点遍历操作
        从以下版本开始：
        1.4
        另请参见：
        getFocusTraversalKeys(int) ， KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS ， KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS ， KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS

      • areFocusTraversalKeysSet

        public boolean areFocusTraversalKeysSet​(int id)
        返回是否已为此Component显式定义了给定焦点遍历操作的焦点遍历键Set。 如果此方法返回false ，则此Component从祖先或当前KeyboardFocusManager继承Set。
        参数
        id - KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS，KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS或KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS之一
        结果
        true如果已为此Component明确定义了给定焦点遍历操作的焦点遍历键集; 否则为false 。
        异常
        IllegalArgumentException - 如果id不是KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS，KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS或KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS之一
        从以下版本开始：
        1.4

      • requestFocus

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

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

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

        注意：并非所有焦点传输都是通过调用此方法产生的。 这样，组件可以接收焦点没有这种或任何其他requestFocus的方法Component被调用。

        从以下版本开始：
        1.0
        另请参见：
        requestFocusInWindow() ， FocusEvent ， addFocusListener(java.awt.event.FocusListener) ， isFocusable() ， isDisplayable() ， KeyboardFocusManager.clearGlobalFocusOwner()

      • requestFocus

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

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

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

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

        注意：并非所有焦点传输都是通过调用此方法产生的。 这样，组件可以接收焦点没有这种或任何其他requestFocus的方法Component被调用。

        参数
        cause - 请求焦点的原因
        从以下版本开始：
        9
        另请参见：
        FocusEvent ， FocusEvent.Cause ， requestFocusInWindow(FocusEvent.Cause) ， FocusEvent ， addFocusListener(java.awt.event.FocusListener) ， isFocusable() ， isDisplayable() ， KeyboardFocusManager.clearGlobalFocusOwner()

      • requestFocus

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

        此方法返回一个布尔值。 如果返回false ，则保证请求失败 。 如果返回true ，则除非被否决， 否则请求将成功，或者在本机窗口系统授予请求之前发生特殊事件（例如处理组件的对等方）。 同样，虽然返回值true表示请求可能成功，但开发人员必须永远不要假设此组件是焦点所有者，直到此组件收到FOCUS_GAINED事件。

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

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

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

        注意：并非所有焦点传输都是通过调用此方法产生的。 这样，组件可以接收焦点没有这种或任何其他requestFocus的方法Component被调用。

        参数
        temporary - 如果焦点更改是临时的， temporary true，例如窗口失去焦点时; 有关临时焦点更改的更多信息，请参阅Focus Specification
        结果
        false如果焦点变更请求保证失败; true是否有可能成功
        从以下版本开始：
        1.4
        另请参见：
        FocusEvent ， addFocusListener(java.awt.event.FocusListener) ， isFocusable() ， isDisplayable() ， KeyboardFocusManager.clearGlobalFocusOwner()

      • requestFocus

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

        此方法返回一个布尔值。 如果返回false ，则保证请求失败 。 如果返回true ，则除非被否决， 否则请求将成功，或者在本机窗口系统授予请求之前发生特殊事件（例如处置组件的对等方）。 同样，虽然返回值true表明请求可能成功，但开发人员必须永远不要假设此组件是焦点所有者，直到此组件收到FOCUS_GAINED事件。

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

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

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

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

        注意：并非所有焦点传输都是通过调用此方法产生的。 这样，组件可以接收焦点没有这种或任何其他requestFocus的方法Component被调用。

        参数
        temporary - 如果焦点更改是临时的， temporary true，例如当窗口失去焦点时; 有关临时焦点更改的更多信息，请参阅Focus Specification
        cause - 请求关注的原因
        结果
        false如果焦点变更请求保证失败; true是否有可能成功
        从以下版本开始：
        9
        另请参见：
        FocusEvent ， FocusEvent.Cause ， addFocusListener(java.awt.event.FocusListener) ， isFocusable() ， isDisplayable() ， KeyboardFocusManager.clearGlobalFocusOwner()

      • requestFocusInWindow

        public boolean requestFocusInWindow()
        如果此Component的顶级祖先已经是焦点窗口，则请求此Component获取输入焦点。 此组件必须是可显示的，可聚焦的，可见的，并且其所有祖先（顶级窗口除外）必须对于要授予的请求是可见的。 将尽一切努力履行要求; 但是，在某些情况下，可能无法这样做。 在此Component收到FOCUS_GAINED事件之前，开发人员绝不能假定此Component是焦点所有者。

        此方法返回一个布尔值。 如果返回false ，则保证请求失败 。 如果返回true ，则除非被否决， 否则请求将成功，或者在本机窗口系统授予请求之前发生特殊事件（例如处置组件的对等方）。 同样，虽然返回值true表明请求可能成功，但开发人员必须永远不要假设此Component是焦点所有者，直到此Component收到FOCUS_GAINED事件。

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

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

        注意：并非所有焦点传输都是通过调用此方法产生的。 这样，组件可以接收焦点没有这种或任何其他requestFocus的方法Component被调用。

        结果
        false如果焦点变更请求保证失败; true如果它可能成功
        从以下版本开始：
        1.4
        另请参见：
        requestFocus() ， FocusEvent ， addFocusListener(java.awt.event.FocusListener) ， isFocusable() ， isDisplayable() ， KeyboardFocusManager.clearGlobalFocusOwner()

      • requestFocusInWindow

        public boolean requestFocusInWindow​(FocusEvent.Cause cause)
        请求cause请求此Component获取输入焦点，如果此Component的顶级祖先已经是焦点窗口。 此组件必须是可显示的，可聚焦的，可见的，并且其所有祖先（顶级窗口除外）必须对于要授予的请求是可见的。 将尽一切努力履行要求; 但是，在某些情况下，可能无法这样做。 在此Component收到FOCUS_GAINED事件之前，开发人员绝不能假定此Component是焦点所有者。

        此方法返回一个布尔值。 如果返回false ，则保证请求失败 。 如果返回true ，则除非被否决， 否则请求将成功，或者在本机窗口系统授予请求之前发生特殊事件（例如处置组件的对等方）。 同样，虽然返回值true表示请求可能成功，但开发人员必须永远不要假设此Component是焦点所有者，直到此Component收到FOCUS_GAINED事件。

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

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

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

        注意：并非所有焦点传输都是通过调用此方法产生的。 这样，组件可以接收焦点没有这种或任何其他requestFocus的方法Component被调用。

        参数
        cause - 请求关注的原因
        结果
        false如果焦点变更请求保证失败; true如果它可能成功
        从以下版本开始：
        9
        另请参见：
        requestFocus(FocusEvent.Cause) ， FocusEvent ， FocusEvent.Cause ， FocusEvent ， addFocusListener(java.awt.event.FocusListener) ， isFocusable() ， isDisplayable() ， KeyboardFocusManager.clearGlobalFocusOwner()

      • requestFocusInWindow

        protected boolean requestFocusInWindow​(boolean temporary)
        请求此Component获得输入焦点，如果这个Component的顶级祖先已经是焦点Window 。 此组件必须是可显示的，可聚焦的，可见的，并且其所有祖先（顶级窗口除外）必须对于要授予的请求是可见的。 将尽一切努力履行要求; 但是，在某些情况下，可能无法这样做。 在此组件收到FOCUS_GAINED事件之前，开发人员绝不能假定此组件是焦点所有者。

        此方法返回一个布尔值。 如果返回false ，则保证请求失败 。 如果返回true ，则除非被否决， 否则该请求将成功，或者在本机窗口系统授予请求之前发生特殊事件（例如处置组件的对等方）。 同样，虽然返回值true表明请求可能成功，但开发人员必须永远不要假设此组件是焦点所有者，直到此组件收到FOCUS_GAINED事件。

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

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

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

        注意：并非所有焦点传输都是通过调用此方法产生的。 这样，组件可以接收焦点没有这种或任何其他requestFocus的方法Component被调用。

        参数
        temporary - 如果焦点更改是临时的， temporary true，例如窗口失去焦点时; 有关临时焦点更改的更多信息，请参阅Focus Specification
        结果
        false如果焦点变更请求保证失败; true如果它可能成功
        从以下版本开始：
        1.4
        另请参见：
        requestFocus() ， FocusEvent ， addFocusListener(java.awt.event.FocusListener) ， isFocusable() ， isDisplayable() ， KeyboardFocusManager.clearGlobalFocusOwner()

      • getFocusCycleRootAncestor

        public Container getFocusCycleRootAncestor()
        返回Container，它是此Component焦点遍历循环的焦点循环根。 每个焦点遍历循环只有一个焦点循环根，而不是Container的每个Component只属于一个焦点遍历循环。 作为焦点循环根的容器属于两个循环：一个以Container本身为根，另一个以Container最近的焦点循环根祖先为根。 对于此类容器，此方法将返回Container最近的焦点循环根祖先。
        结果
        这个组件最近的焦点 - 循环 - 根祖先
        从以下版本开始：
        1.4
        另请参见：
        Container.isFocusCycleRoot()

      • isFocusCycleRoot

        public boolean isFocusCycleRoot​(Container container)
        返回指定的Container是否是此Component的焦点遍历循环的焦点循环根。 每个焦点遍历循环只有一个焦点循环根，而不是Container的每个Component只属于一个焦点遍历循环。
        参数
        container - 要测试的容器
        结果
        true如果指定的Container是此Component的焦点true根; 否则为false
        从以下版本开始：
        1.4
        另请参见：
        Container.isFocusCycleRoot()

      • transferFocus

        public void transferFocus()
        将焦点转移到下一个组件，就好像此组件是焦点所有者一样。
        从以下版本开始：
        1.1
        另请参见：
        requestFocus()

      • nextFocus

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

      • transferFocusBackward

        public void transferFocusBackward()
        将焦点转移到上一个组件，就好像此组件是焦点所有者一样。
        从以下版本开始：
        1.4
        另请参见：
        requestFocus()

      • transferFocusUpCycle

        public void transferFocusUpCycle()
        将焦点转移到一个焦点遍历循环。 通常，焦点所有者设置为此Component的焦点循环根，并且当前焦点循环根设置为新焦点所有者的焦点循环根。 但是，如果此Component的焦点循环根是Window，则焦点所有者将设置为焦点循环根的默认Component以进行焦点，并且当前焦点循环根不变。
        从以下版本开始：
        1.4
        另请参见：
        requestFocus() ， Container.isFocusCycleRoot() ， Container.setFocusCycleRoot(boolean)

      • 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(MenuComponent)

      • remove

        public void remove​(MenuComponent popup)
        从组件中删除指定的弹出菜单。
        Specified by:
        remove在界面 MenuContainer
        参数
        popup - 要删除的弹出菜单
        从以下版本开始：
        1.1
        另请参见：
        add(PopupMenu)

      • paramString

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

      • toString

        public String toString()
        返回此组件及其值的字符串表示形式。
        重写：
        toString在课程 Object
        结果
        此组件的字符串表示形式
        从以下版本开始：
        1.0

      • list

        public void list()
        将此组件的列表打印到标准系统输出流 System.out 。
        从以下版本开始：
        1.0
        另请参见：
        System.out

      • list

        public void list​(PrintStream out)
        将此组件的列表打印到指定的输出流。
        参数
        out - 打印流
        异常
        NullPointerException - 如果 out是 null
        从以下版本开始：
        1.0

      • list

        public void list​(PrintWriter out)
        将列表打印到指定的打印编写器。
        参数
        out - 要打印的打印作者
        异常
        NullPointerException - 如果 out是 null
        从以下版本开始：
        1.1

      • addPropertyChangeListener

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

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

        参数
        listener - 要添加的属性更改侦听器
        另请参见：
        removePropertyChangeListener(java.beans.PropertyChangeListener) ， getPropertyChangeListeners() ， addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)

      • addPropertyChangeListener

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

        如果propertyName或listener是null ，则不会引发异常并且不执行任何操作。

        参数
        propertyName - 上面列出的其中一个属性
        listener - 要添加的属性更改侦听器
        另请参见：
        removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener) ， getPropertyChangeListeners(java.lang.String) ， addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)

      • 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(java.lang.String, java.lang.Object, java.lang.Object)

      • firePropertyChange

        public void firePropertyChange​(String propertyName,
                               char oldValue,
                               char newValue)
        报告绑定的属性更改。
        参数
        propertyName - 已更改的属性的编程名称
        oldValue - 属性的旧值（作为char）
        newValue - 属性的新值（作为char）
        从以下版本开始：
        1.5
        另请参见：
        firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)

      • firePropertyChange

        public void firePropertyChange​(String propertyName,
                               short oldValue,
                               short newValue)
        报告绑定的属性更改。
        参数
        propertyName - 已更改的属性的编程名称
        oldValue - 该物业的旧价值（简称）
        newValue - 该物业的新值（简称）
        从以下版本开始：
        1.5
        另请参见：
        firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)

      • firePropertyChange

        public void firePropertyChange​(String propertyName,
                               long oldValue,
                               long newValue)
        报告绑定的属性更改。
        参数
        propertyName - 已更改的属性的编程名称
        oldValue - 属性的旧值（作为long）
        newValue - 属性的新值（作为long）
        从以下版本开始：
        1.5
        另请参见：
        firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)

      • firePropertyChange

        public void firePropertyChange​(String propertyName,
                               float oldValue,
                               float newValue)
        报告绑定的属性更改。
        参数
        propertyName - 已更改的属性的编程名称
        oldValue - 属性的旧值（作为浮点数）
        newValue - 属性的新值（作为float）
        从以下版本开始：
        1.5
        另请参见：
        firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)

      • firePropertyChange

        public void firePropertyChange​(String propertyName,
                               double oldValue,
                               double newValue)
        报告绑定的属性更改。
        参数
        propertyName - 已更改的属性的编程名称
        oldValue - 属性的旧值（作为double）
        newValue - 属性的新值（作为double）
        从以下版本开始：
        1.5
        另请参见：
        firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)

      • setComponentOrientation

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

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

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

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

        参数
        o - 要设置的方向
        另请参见：
        ComponentOrientation ， invalidate()

      • getComponentOrientation

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

      • getAccessibleContext

        public AccessibleContext getAccessibleContext()
        获取AccessibleContext与此相关Component 。 此基类实现的方法返回null。 扩展Component类应实现此方法以返回与子类关联的AccessibleContext 。
        结果
        AccessibleContext的 Component
        从以下版本开始：
        1.3

      • setMixingCutoutShape

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

        shape参数可能具有以下值：

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

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

        参数
        shape - 新的'混合切口'形状
        从以下版本开始：
        9