Module  java.desktop
软件包  java.awt

Class Component

  • All Implemented Interfaces:
    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()
        {
            // 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() ， Constant Field Values

      • BOTTOM_ALIGNMENT

        public static final float BOTTOM_ALIGNMENT
        易于使用的常数为getAlignmentY 。 指定与组件底部的对齐方式。
        另请参见：
        getAlignmentY() ， Constant Field Values

      • LEFT_ALIGNMENT

        public static final float LEFT_ALIGNMENT
        易于使用的常数为getAlignmentX 。 指定组件左侧的对齐方式。
        另请参见：
        getAlignmentX() ， Constant Field Values

      • RIGHT_ALIGNMENT

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

      • 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对象。
        结果
        true如果组件可见，否则为 false
        从以下版本开始：
        1.0
        另请参见：
        setVisible(boolean)

      • getMousePosition

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

        为Container的IT如果鼠标上述返回一个非空值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​()
        已过时。 从JDK 1.1版开始，由setEnabled(boolean)代替。

      • enable

        @Deprecated
public void enable​(boolean b)
        已过时。 从JDK 1.1版开始，由setEnabled(boolean)替代。
        启用或禁用此组件。
        参数
        b - true以启用此组件; 否则false

      • disable

        @Deprecated
public void disable​()
        已过时。 从JDK 1.1版开始，由setEnabled(boolean)替代。

      • isDoubleBuffered

        public boolean isDoubleBuffered​()
        如果此组件被绘制到稍后复制到屏幕的屏幕外图像（“缓冲区”），则返回true。 支持双缓冲的组件子类应该覆盖此方法，以便在启用双缓冲时返回true。
        结果
        默认为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​()
        已过时。 从JDK 1.1版开始，由setVisible(boolean)代替。

      • show

        @Deprecated
public void show​(boolean b)
        已过时。 从JDK 1.1版开始，由setVisible(boolean)替代。
        使此组件可见或不可见。
        参数
        b - true以使该组件可见; 否则false

      • hide

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

      • getForeground

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

      • setForeground

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

      • isForegroundSet

        public boolean isForegroundSet​()
        返回是否为此组件显式设置了前景色。 如果此方法返回false ，则此Component将从祖先继承其前景颜色。
        结果
        true如果前面的颜色已被明确设置为此组件; 否则为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​()
        返回是否为此组件显式设置了背景颜色。 如果此方法返回false ，则此组件将从祖先继承其背景颜色。
        结果
        true如果已经为此组件显式设置了背景颜色; 否则为false 。
        从以下版本开始：
        1.4

      • getFont

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

      • setFont

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

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

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

      • isFontSet

        public boolean isFontSet​()
        返回是否已经为此组件显式设置了字体。 如果此方法返回false ，则此Component将从祖先继承其字体。
        结果
        true如果字体已被明确设置为此组件; 否则为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()

      • location

        @Deprecated
public Point location​()
        已过时。 从JDK 1.1版开始，由getLocation()替代。
        返回此组件左上角的位置。
        结果
        该组件的左上角的位置

      • setLocation

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

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

        参数
        x - 新位置的左上角 x坐标坐标空间
        y - 父位置坐标空间中新位置左上角的 y坐标
        从以下版本开始：
        1.1
        另请参见：
        getLocation() ， setBounds(int, int, int, int) ， invalidate()

      • move

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

      • setLocation

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

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

        参数
        p - 定义新位置左上角的点，在该组件的父项的坐标空间中给出
        从以下版本开始：
        1.1
        另请参见：
        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​()
        已过时。 截至JDK 1.1版，由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)
        已过时。 从JDK 1.1版开始，由setSize(int, int)替代。
        调整此组件的大小。
        参数
        width - 组件的新宽度
        height - 组件的新高度

      • resize

        @Deprecated
public void resize​(Dimension d)
        已过时。 从JDK 1.1版开始，由setSize(Dimension)替代。
        调整此组件的大小，使其宽度为 d.width ，高度为 d.height 。
        参数
        d - 这个组件的新尺寸

      • bounds

        @Deprecated
public Rectangle bounds​()
        已过时。 从JDK 1.1版开始，由getBounds()替代。
        返回此组件的边界矩形。
        结果
        该组件的边界矩形

      • setBounds

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

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

        参数
        x - 这个组件的新 x坐标
        y - 这个组件的新 y-坐标
        width - 这个组件的新 width
        height - 这个组件的新 height
        从以下版本开始：
        1.1
        另请参见：
        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)
        已过时。 从JDK 1.1版开始，由setBounds(int, int, int, int)替代。
        重新整形这个组件的边界矩形。
        参数
        x - 矩形左上角的 x坐标
        y - 矩形左上角的 y坐标
        width - 矩形的宽度
        height - 矩形的高度

      • getX

        public int getX​()
        返回组件原点的当前x坐标。 这种方法比component.getBounds().x或component.getLocation().x更component.getBounds().x ，因为它不会导致堆分配。
        结果
        组件原点的当前x坐标
        从以下版本开始：
        1.2

      • getY

        public int getY​()
        返回组件原点的当前y坐标。 这种方法比component.getBounds().y或component.getLocation().y更component.getBounds().y ，因为它不会导致任何堆分配。
        结果
        组件原点的当前y坐标
        从以下版本开始：
        1.2

      • getWidth

        public int getWidth​()
        返回此组件的当前宽度。 这种方法比component.getBounds().width或component.getSize().width更component.getBounds().width ，因为它不会导致任何堆分配。
        结果
        该组件的当前宽度
        从以下版本开始：
        1.2

      • getHeight

        public int getHeight​()
        返回此组件的当前高度。 这种方法比component.getBounds().height或component.getSize().height更component.getBounds().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 Container ，除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。
        结果
        如果已经使用非空值调用了 setPreferredSize则 setPreferredSize true。
        从以下版本开始：
        1.5

      • getPreferredSize

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

      • preferredSize

        @Deprecated
public Dimension preferredSize​()
        已过时。 从JDK 1.1版开始，替换为getPreferredSize() 。
        返回组件的首选大小。
        结果
        该组件的首选尺寸

      • setMinimumSize

        public void setMinimumSize​(Dimension minimumSize)
        将此组件的最小大小设置为常量值。 后续调用getMinimumSize将始终返回此值。 将最小大小设置为null可恢复默认行为。
        参数
        minimumSize - 这个组件的最小尺寸
        从以下版本开始：
        1.5
        另请参见：
        getMinimumSize() ， isMinimumSizeSet()

      • isMinimumSizeSet

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

      • minimumSize

        @Deprecated
public Dimension minimumSize​()
        已过时。 从JDK 1.1版开始，由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 s，以使组件沿其基线对齐。 返回值小于0表示此组件没有合理的基线，并且LayoutManager s不应该将该组件对准其基线。

        默认实现返回-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，则使用此方法。 该方法可以返回BaselineResizeBehavior.OTHER以外的值，即使getBaseline返回小于0的值。

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

      • doLayout

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

      • layout

        @Deprecated
public void layout​()
        已过时。 从JDK 1.1版开始，替换为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的影响，并且此方法不提供此方法，它只能返回默认渲染上下文的度量标准，如果正在使用270467271938838功能，则可能与组件上呈现时使用的不一致 。 相反，可以通过在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​()
        返回是否已经为此组件显式设置了游标。 如果此方法返回false ，则此Component将从祖先继承其游标。
        结果
        true如果游标已为此组件显式设置; 否则为false 。
        从以下版本开始：
        1.4

      • paint

        public void paint​(Graphics g)
        涂抹这个组件。

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

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

        注意 ：有关由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的调用做额外工作的子类覆盖。 要覆盖此方法的组件子类应直接从其update方法调用super.update(g)或调用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界面进行管理。
        参数
        width - 指定的宽度
        height - 指定的高度
        caps - 图像功能
        结果
        一个VolatileImage对象，可用于管理表面内容的丢失和能力。 null值如果组件不可显示，或GraphicsEnvironment.isHeadless()返回true 。
        异常
        AWTException - 如果无法创建具有指定功能的图像
        从以下版本开始：
        1.4
        另请参见：
        VolatileImage

      • prepareImage

        public boolean prepareImage​(Image image,
                            ImageObserver observer)
        准备用于在此组件上呈现的图像。 图像数据在另一个线程中被异步地下载，并且生成图像的适当的屏幕表示。
        参数
        image - 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)
        已过时。 从JDK 1.1版开始，由contains（int，int）替换。
        检查点是否在该组件内。
        参数
        x - 点的 x坐标
        y - 点的 y坐标
        结果
        true如果点在组件内; 否则false

      • contains

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

      • getComponentAt

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

        该locate的方法Component简单地返回组件本身，如果（X，Y）坐标位置是其边界框的内部， null否则。

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

      • locate

        @Deprecated
public Component locate​(int x,
                        int y)
        已过时。 从JDK 1.1版开始，由getComponentAt（int，int）替换。
        返回占据指定位置的组件（此组件或直接子组件，如果前两个都不占用该位置，则返回null）。
        参数
        x - 搜索组件的 x坐标
        y - 用于搜索组件的 y坐标
        结果
        指定位置的组件或 null

      • getComponentAt

        public Component getComponentAt​(Point p)
        返回包含指定点的组件或子组件。
        参数
        p - 关键
        结果
        指定位置的组件或 null
        从以下版本开始：
        1.1
        另请参见：
        contains(int, int)

      • deliverEvent

        @Deprecated
public void deliverEvent​(Event e)
        已过时。 从JDK 1.1版开始，由dispatchEvent(AWTEvent e)替代。
        参数
        e - 交付的事件

      • dispatchEvent

        public final void dispatchEvent​(AWTEvent e)
        将事件分派到此组件或其一个子组件。 致电processEvent然后返回为Component启用的1.1样式的事件。
        参数
        e - 事件

      • postEvent

        @Deprecated
public boolean postEvent​(Event e)
        已过时。 从JDK 1.1版开始，由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)
        潜在地合并现有事件发布的事件。 此方法由称为EventQueue.postEvent ，如果具有相同的ID为要发布的事件的事件队列中被发现（这两个事件必须具有此组件作为它们的源）。 该方法或者返回一个替换现有事件的合并事件（并且新事件被丢弃），或者null以表示不应该组合（将第二个事件添加到队列的末尾）。 任何一个事件参数都可以被修改和返回，因为另外一个被丢弃，除非返回null 。

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

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

      • processComponentEvent

        protected void processComponentEvent​(ComponentEvent e)
        通过将组件事件发送到任何注册的ComponentListener对象来处理此组件上发生的组件事件。

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

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

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

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

      • processFocusEvent

        protected void processFocusEvent​(FocusEvent e)
        通过将这些事件发送到任何已注册的FocusListener对象来处理发生在该组件上的焦点事件。

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

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

        如果焦点事件，启用Component ，目前KeyboardFocusManager确定焦点事件是否应该被分派到注册FocusListener对象。 如果要发送事件， KeyboardFocusManager调用Component的dispatchEvent方法，这将调用Component的processFocusEvent方法。

        如果Component启用了焦点事件， 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对象来处理此组件上发生的关键事件。

        除非为此组件启用了关键事件，否则不会调用此方法。 如果出现以下情况之一，则启用主要事件：

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

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

        从J2SE 1.4起， KeyEvent被重定向到焦点所有者。 详情请参阅Focus Specification 。

        使用KeyEvent作为参数调用Component的dispatchEvent方法将导致调用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对象来处理此组件上发生的鼠标事件。

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

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

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

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

      • processMouseMotionEvent

        protected void processMouseMotionEvent​(MouseEvent e)
        通过将这些组件发送到任何已注册的MouseMotionListener对象来处理发生在该组件上的鼠标运动事件。

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

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

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

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

      • processMouseWheelEvent

        protected void processMouseWheelEvent​(MouseWheelEvent e)
        通过将鼠标滚轮事件发送到任何注册的MouseWheelListener对象来处理鼠标滚轮事件。

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

        • A 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对象来处理此组件上发生的层次结构事件。

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

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

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

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

      • processHierarchyBoundsEvent

        protected void processHierarchyBoundsEvent​(HierarchyEvent e)
        进程层次结构通过HierarchyBoundsListener到任何已注册的HierarchyBoundsListener对象来限制发生在该组件上的事件。

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

        • 一个HierarchyBoundsListener对象通过addHierarchyBoundsListener注册。
        • 层次enableEvents事件通过enableEvents启用。

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

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

      • handleEvent

        @Deprecated
public boolean handleEvent​(Event evt)
        已过时。 从JDK版本1.1替换为processEvent（AWTEvent）。
        参数
        evt - 要处理的事件
        结果
        true如果事件处理，否则为 false

      • mouseDown

        @Deprecated
public boolean mouseDown​(Event evt,
                         int x,
                         int y)
        已过时。 从JDK 1.1版开始，由processMouseEvent（MouseEvent）替换。
        参数
        evt - 要处理的事件
        x - x坐标
        y - y坐标
        结果
        false

      • mouseDrag

        @Deprecated
public boolean mouseDrag​(Event evt,
                         int x,
                         int y)
        已过时。 从JDK 1.1版开始，由processMouseMotionEvent（MouseEvent）替换。
        参数
        evt - 事件处理
        x - x坐标
        y - y坐标
        结果
        false

      • mouseUp

        @Deprecated
public boolean mouseUp​(Event evt,
                       int x,
                       int y)
        已过时。 从JDK 1.1版开始，由processMouseEvent（MouseEvent）替换。
        参数
        evt - 处理事件
        x - x坐标
        y - y坐标
        结果
        false

      • mouseMove

        @Deprecated
public boolean mouseMove​(Event evt,
                         int x,
                         int y)
        已过时。 从JDK 1.1版开始，由processMouseMotionEvent（MouseEvent）替换。
        参数
        evt - 事件处理
        x - x坐标
        y - y坐标
        结果
        false

      • mouseEnter

        @Deprecated
public boolean mouseEnter​(Event evt,
                          int x,
                          int y)
        已过时。 从JDK 1.1版开始，由processMouseEvent（MouseEvent）替换。
        参数
        evt - 事件处理
        x - x坐标
        y - y坐标
        结果
        false

      • mouseExit

        @Deprecated
public boolean mouseExit​(Event evt,
                         int x,
                         int y)
        已过时。 从JDK 1.1版开始，由processMouseEvent（MouseEvent）替换。
        参数
        evt - 要处理的事件
        x - x坐标
        y - y坐标
        结果
        false

      • keyDown

        @Deprecated
public boolean keyDown​(Event evt,
                       int key)
        已过时。 从JDK 1.1版开始，由processKeyEvent（KeyEvent）替换。
        参数
        evt - 处理事件
        key - 按键
        结果
        false

      • keyUp

        @Deprecated
public boolean keyUp​(Event evt,
                     int key)
        已过时。 从JDK 1.1版开始，由processKeyEvent（KeyEvent）替换。
        参数
        evt - 事件处理
        key - 按键
        结果
        false

      • action

        @Deprecated
public boolean action​(Event evt,
                      Object what)
        已过时。 从JDK 1.1版开始，应该在组件上注册此组件作为ActionListener，该组件将触发动作事件。
        参数
        evt - 事件处理
        what - 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)
        已过时。 从JDK 1.1版开始，由processFocusEvent（FocusEvent）替代。
        参数
        evt - 处理事件
        what - 对象集中
        结果
        false

      • lostFocus

        @Deprecated
public boolean lostFocus​(Event evt,
                         Object what)
        已过时。 从JDK 1.1版开始，由processFocusEvent（FocusEvent）替代。
        参数
        evt - 处理事件
        what - 对象集中
        结果
        false

      • isFocusTraversable

        @Deprecated
public boolean isFocusTraversable​()
        已过时。 截至1.4，由isFocusable()取代。
        返回这个 Component是否可以成为焦点所有者。
        结果
        true如果这个Component是可Component的; 否则为false
        从以下版本开始：
        1.1
        另请参见：
        setFocusable(boolean)

      • isFocusable

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

      • setFocusable

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

      • setFocusTraversalKeys

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

        组件焦点遍历键的默认值与实现相关。 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
        要禁用遍历键，请使用空的Set; 推荐使用Collections.EMPTY_SET。

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

        如果为Set指定了null值，则此Component将从其父项继承Set。 如果此组件的所有祖先对于Set指定了空值，则使用当前的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事件，或者如果任何键击已经映射到此组件的另一个焦点遍历操作
        从以下版本开始：
        1.4
        另请参见：
        getFocusTraversalKeys(int) ， KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS ， KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS ， KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS

      • areFocusTraversalKeysSet

        public boolean areFocusTraversalKeysSet​(int id)
        返回是否为此组件显式定义了给定焦点遍历操作的聚焦遍历键集。 如果此方法返回false ，则此Component将从祖先继承Set，或从当前的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

      • requestFocus

        public void requestFocus​()
        请求此组件获取输入焦点，并且该组件的顶级祖先成为关注的窗口。 该组件必须是可显示的，可聚焦的，可见的，并且所有的祖先（除了顶级窗口除外）必须对于被授予的请求可见。 将竭尽全力尊重这一要求; 然而，在某些情况下，这可能是不可能的。 开发人员绝不能假定此组件是焦点拥有者，直到本组件收到FOCUS_GAINED事件为止。 如果此请求被拒绝，因为该组件的顶级窗口不能成为关注的窗口，则请求将被记住，并且将在窗口稍后被用户关注时被授予。

        该方法无法用于将焦点所有者设置为无任何组件。 改用KeyboardFocusManager.clearGlobalFocusOwner() 。

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

        注意：并非所有的焦点传输都是通过调用此方法。 因此，组件可以接收焦点，而不调用Component的其他requestFocus方法。

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

      • requestFocus

        public void requestFocus​(FocusEvent.Cause cause)
        由于cause ，该组件获得输入焦点，并且该组件的顶级祖先成为关注的窗口。 该组件必须是可显示的，可聚焦的，可见的，并且所有的祖先（除了顶级窗口除外）必须对于被授予的请求可见。 将竭尽全力尊重这一要求; 然而，在某些情况下，这可能是不可能的。 开发人员绝不能假定此组件是焦点拥有者，直到本组件收到FOCUS_GAINED事件为止。

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

        该方法无法用于将焦点所有者设置为无任何组件。 改用KeyboardFocusManager.clearGlobalFocusOwner() 。

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

        注意：并非所有的焦点传输都是通过调用此方法。 因此，组件可以接收焦点，而不会调用Component的其他requestFocus方法。

        参数
        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 s将具有指定的临时值。 但是，由于指定任意临时状态在所有本机窗口系统上可能无法实现，所以只有轻型Component才能保证此方法的正确行为。 此方法不适用于一般用途，而是作为轻量级组件库（如Swing）的钩子而存在。

        注意：并非所有的焦点传输都是通过调用此方法。 因此，组件可以接收焦点，而不会调用Component的其他requestFocus方法。

        参数
        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 s将具有指定的临时值。 但是，由于指定任意临时状态在所有本机窗口系统上可能无法实现，所以只有轻量级的Component可以保证此方法的正确行为。 此方法不适用于一般用途，而是作为轻量级组件库（如Swing）的钩子而存在。

        注意：并非所有的焦点传输都是通过调用此方法。 因此，组件可以接收焦点，而不调用Component的其他requestFocus方法。

        参数
        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​()
        要求此组件获取输入焦点，如果此组件的顶级祖先已经是关注的窗口。 该组件必须是可显示的，可聚焦的，可见的，并且所有的祖先（除了顶级窗口除外）必须对于被授予的请求可见。 将竭尽全力尊重这一要求; 然而，在某些情况下，这可能是不可能的。 开发人员绝不能假定此组件是焦点拥有者，直到本组件收到FOCUS_GAINED事件为止。

        此方法返回一个布尔值。 如果返回false ，则请求将保证失败 。 如果返回true ， 除非被否决， 否则请求将成功， 否则 ，在本地窗口系统授予请求之前，会发生特殊事件（如组件对等体的处理）。 同样，当返回值为true表示请求可能成功时，开发人员不能假定此组件是焦点所有者，直到此组件收到FOCUS_GAINED事件为止。

        该方法无法用于将焦点所有者设置为无任何组件。 改用KeyboardFocusManager.clearGlobalFocusOwner() 。

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

        注意：并非所有的焦点传输都是通过调用此方法。 因此，组件可以接收焦点，而不会调用Component的其他requestFocus方法。

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

      • requestFocusInWindow

        public boolean requestFocusInWindow​(FocusEvent.Cause cause)
        由于cause的原因，该组件获得输入焦点，如果此组件的顶级祖先已经是关注的窗口。 该组件必须是可显示的，可聚焦的，可见的，并且所有的祖先（除了顶级窗口除外）必须对于被授予的请求可见。 将竭尽全力尊重这一要求; 然而，在某些情况下，这可能是不可能的。 开发人员绝不能假定此组件是焦点拥有者，直到本组件收到FOCUS_GAINED事件为止。

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

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

        该方法无法用于将焦点所有者设置为无任何组件。 改用KeyboardFocusManager.clearGlobalFocusOwner() 。

        这种方法的重点行为可以跨平台实现，因此，强烈建议开发人员尽可能地使用这种方法超过requestFocus(FocusEvent.Cause) 。 依赖于requestFocus(FocusEvent.Cause)代码可能会在不同平台上展示不同的焦点行为。

        注意：并非所有的焦点传输都是通过调用此方法。 因此，组件可以接收焦点，而不会调用Component的其他requestFocus方法。

        参数
        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 s将具有指定的临时值。 但是，由于指定任意临时状态在所有本机窗口系统上可能无法实现，因此只能为轻量级组件确保此方法的正确行为。 此方法不适用于一般用途，而是作为轻量级组件库（如Swing）的钩子而存在。

        注意：并非所有的焦点传输都是通过调用此方法。 因此，组件可以接收焦点，而不会调用Component的其他requestFocus方法。

        参数
        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最近的focus-cycle-roots祖先。
        结果
        该组件最近的焦点循环根祖先
        从以下版本开始：
        1.4
        另请参见：
        Container.isFocusCycleRoot()

      • isFocusCycleRoot

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

      • transferFocus

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

      • nextFocus

        @Deprecated
public void nextFocus​()
        已过时。 从JDK 1.1版开始，由transferFocus（）替换。

      • transferFocusBackward

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

      • transferFocusUpCycle

        public void transferFocusUpCycle​()
        将焦点转移到一个焦点遍历周期。 通常，焦点所有者设置为此组件的焦点循环根，并将当前焦点循环根设置为新焦点所有者的焦点循环根。 但是，如果此组件的焦点循环根为Window，则焦点所有者将设置为焦点循环根的默认组件以进行对焦，并且当前焦点循环根未更改。
        从以下版本开始：
        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添加到侦听器列表。 监听器已注册到此类的所有绑定属性，包括以下内容：
        • 这个组件的字体（“font”）
        • 此组件的背景颜色（“背景”）
        • 此组件的前景色（“前景”）
        • 该组件的可重点性（“可聚焦”）
        • 此组件的焦点遍历键启用状态（“focusTraversalKeysEnabled”）
        • 此组件的FORWARD_TRAVERSAL_KEYS（“forwardFocusTraversalKeys”）
        • 此组件的BACKWARD_TRAVERSAL_KEYS（“backwardFocusTraversalKeys”）
        • 此组件的UP_CYCLE_TRAVERSAL_KEYS（“upCycleFocusTraversalKeys”）
        • 此组件的首选大小（“preferredSize”）
        • 此组件的最小尺寸（“minimumSize”）
        • 此组件的最大大小（“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添加到特定属性的侦听器列表中。 指定的属性可能是用户定义的，也可能是以下之一：
        • 这个组件的字体（“font”）
        • 此组件的背景颜色（“背景”）
        • 此组件的前景色（“前景”）
        • 该组件的可重点性（“可聚焦”）
        • 此组件的焦点遍历键启用状态（“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发送适当的PropertyChangeEvent。
        参数
        propertyName - 其值已更改的属性
        oldValue - 该物业的以前的价值
        newValue - 该物业的新价值

      • firePropertyChange

        protected void firePropertyChange​(String propertyName,
                                  boolean oldValue,
                                  boolean newValue)
        支持报告布尔属性的绑定属性更改。 当绑定属性已更改时，可以调用此方法，并且将向适当的PropertyChangeEvent发送适当的PropertyChangeEvent。
        参数
        propertyName - 其值已更改的属性
        oldValue - 该物业的以前的价值
        newValue - 物业的新价值
        从以下版本开始：
        1.4

      • firePropertyChange

        protected void firePropertyChange​(String propertyName,
                                  int oldValue,
                                  int newValue)
        支持报告整数属性的绑定属性更改。 当绑定属性已更改时，可以调用此方法，并且将向适当的PropertyChangeEvent发送适当的PropertyChangeEvent。
        参数
        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 - 物业的旧价值（长期）
        newValue - 物业的新价值（长期）
        从以下版本开始：
        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 - 属性的新值（作为浮点数）
        从以下版本开始：
        1.5
        另请参见：
        firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)

      • firePropertyChange

        public void firePropertyChange​(String propertyName,
                               double oldValue,
                               double newValue)
        报告绑定属性更改。
        参数
        propertyName - 已更改的属性的编程名称
        oldValue - 该属性的旧值（双重）
        newValue - 该属性的新值（双重）
        从以下版本开始：
        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