精华内容
下载资源
问答
  • 使用Swing组件2-JComponent
    千次阅读
    2019-03-04 18:04:41

    JComponent类

    官方API:https://docs.oracle.com/javase/tutorial/uiswing/components/jcomponent.html#complookapi

    除顶级容器外,名称以“J”开头的所有Swing组件都从 JComponent该类开始。例如JPanelJScrollPaneJButton,和JTable所有的继承JComponent。然而,JFrameJDialog千万不要因为它们实现顶层容器。

    JComponent类扩展了 Container类,它本身延伸 Component。该Component课程包括从提供布局提示到支持绘画和活动的所有内容。该Container班有添加组件的容器,铺出来的支持。这部分的API表总结了最经常使用的方法ComponentContainer,以及的JComponent

    JComponent功能

    JComponent类提供了以下功能,它的后代:

    工具提示

    通过使用setToolTipText方法指定字符串,您可以为组件的用户提供帮助。当光标暂停在组件上时,指定的字符串将显示在组件附近的小窗口中。

      /**
       * 组件工具提示
       */
      package JComponent类;
      ​
      import javax.swing.JButton;
      import javax.swing.JFrame;
      import javax.swing.JLabel;
      ​
      public class ToolTipTextDemo {
          
          private static void setToolTipText() {
              JFrame frame=new JFrame("工具提示");
              frame.setSize(300, 400);
              frame.setLocation(300, 300);
              frame.setLayout(null);
              
              
              //设置一个按钮
              JButton button=new JButton("按钮");
              button.setBounds(50, 50, 100, 40);
              //设置按钮组件提示
              button.setToolTipText("这是一个按钮");
              //将组件添加到主窗口
              frame.add(button);
              
              //设置一个标签
              JLabel label=new JLabel("标签");
              //设置标签的大小和位置
              label.setBounds(50, 100,100, 40);
              //设置标签组件提示
              label.setToolTipText("这是一个标签");
              //将组件添加到主窗口
              frame.add(label);
              
              frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
              frame.setVisible(true);
          }
          
          public static void main(String[] args) {
              setToolTipText();
          }
      }

    绘画和边框

    setBorder方法允许您指定组件在其边缘周围显示的边框。要绘制组件的内部,请覆盖该paintComponent方法。

    package JComponent类;
      ​
      import java.awt.Color;
      ​
      import javax.swing.BorderFactory;
      import javax.swing.JButton;
      import javax.swing.JFrame;
      import javax.swing.border.EtchedBorder;
      ​
      public class BorderDemo {
          private static void setBorder() {
              JFrame frame = new JFrame("设置边框");
              frame.setSize(300, 400);
              frame.setLocation(300, 300);
              frame.setLayout(null);
      ​
              // 设置一个按钮
              JButton button1 = new JButton("按钮1");
              // 为按钮设置红色实线边框
              button1.setBorder(BorderFactory.createLineBorder(Color.red));
              // 设置button的大小和位置
              button1.setBounds(50, 50, 100, 30);
              // 将button添加到主窗口
              frame.add(button1);
      ​
              // 设置一个按钮
              JButton button2 = new JButton("按钮2");
              // 为按钮设置边框
              button2.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.RAISED));
              // 设置button的大小和位置
              button2.setBounds(50, 100, 100, 30);
              // 将button添加到主窗口
              frame.add(button2);
      ​
              // 设置一个按钮
              JButton button3 = new JButton("按钮3");
              // 为按钮设置边框
              button3.setBorder(BorderFactory.createRaisedBevelBorder());
              // 设置button的大小和位置
              button3.setBounds(50, 150, 100, 30);
              // 将button添加到主窗口
              frame.add(button3);
      ​
              frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
              frame.setVisible(true);
          }
      ​
          public static void main(String[] args) {
              setBorder();
          }
      }

    应用程序范围的可插拔外观

    在幕后,每个JComponent对象都有一个相应的ComponentUI对象,可以执行所有绘图,事件处理,大小确定等操作JComponent。究竟使用哪个ComponentUI对象取决于您可以使用该UIManager.setLookAndFeel方法设置的当前外观。

    自定义属性

    您可以将一个或多个属性(名称/对象对)与任何属性相关联JComponent。例如,布局管理器可能使用属性将约束对象与其JComponent管理的每个约束对象相关联。您使用putClientPropertygetClientProperty方法放置和获取属性。

    支持布局

    尽管Component该类提供了诸如getPreferredSize和的布局提示方法getAlignmentX,但它没有提供任何设置这些布局提示的方法,缺少创建子类和覆盖方法。为了给你另一种方法来设置布局提示,则JComponent类增加setter方法。

    支持可访问性

    JComponent类提供API和基本功能,以帮助辅助技术,如屏幕阅读器获取Swing组件的信息,有关辅助功能的更多信息,请参阅 如何支持辅助技术

    支持拖放

    JComponent类提供的API来设置组件的传输处理程序,这是Swing的拖放支持的基础。有关详细信息,请参阅 DnD简介

    双缓冲

    双缓冲平滑在屏幕上绘画。有关详细信息,请参阅 执行自定义绘画

    键绑定

    当用户按下键盘上的键时,此功能会使组件做出反应。例如,在按钮具有焦点的许多外观中,键入Space键相当于鼠标单击按钮。外观自动设置按下和释放Space键之间的绑定以及对按钮产生的效果。有关键绑定的详细信息,请参阅 如何使用键绑定

    JComponent API

    JComponent类提供了许多新的方法和继承了许多方法ComponentContainer。下表总结了我们最常使用的方法。

    自定义组件外观

    方法目的
    void setBorder(Border) Border getBorder()设置或获取组件的边框。有关详细信息,请参见 如何使用边框
    void setForeground(Color) void setBackground(Color)设置组件的前景色或背景色。前景通常是用于在组件中绘制文本的颜色。假设组件是不透明的,背景是(毫不奇怪)组件背景区域的颜色。
    Color getForeground() Color getBackground()获取组件的前景色或背景色。
    void setOpaque(boolean) boolean isOpaque()设置或获取组件是否不透明。不透明组件用其背景颜色填充其背景。
    void setFont(Font) Font getFont()设置或获取组件的字体。如果尚未为组件设置字体,则返回其父级的字体。
    void setCursor(Cursor) Cursor getCursor()设置或获取光标显示在组件及其包含的所有组件上(除了具有自己的光标集的子组件)。例:aPanel.setCursor( Cursor.getPredefinedCursor( Cursor.WAIT_CURSOR));

    设置和获取组件状态

    方法目的
    void setComponentPopupMenu(JPopupMenu)设置JPopupMenu为此JComponent。UI负责注册绑定并添加必要的侦听器,以便JPopupMenu在适当的时间显示。当JPopupMenu显示取决于外观:有些人可能会显示它上的鼠标事件,有些人可能启用键绑定。 如果popup为null,则getInheritsPopupMenu返回true,然后getComponentPopupMenu将委托给父级。这提供了一种使所有子组件继承popupmenu父组件的方法。
    void setTransferHandler(TransferHandler) TransferHandler getTransferHandler()设置或删除transferHandler属性。所述TransferHandler支撑件通过剪切,复制交换数据,或粘贴到/从剪贴板以及拖放。有关详细信息,请参阅 DnD简介
    void setToolTipText(String)设置要在工具提示中显示的文本。有关更多信息,请参见如何使用工具提示
    void setName(String) String getName()设置或获取组件的名称。当您需要将文本与不显示文本的组件相关联时,这非常有用。
    boolean isShowing()确定组件是否在屏幕上显示。这意味着组件必须是可见的,并且必须位于可见和显示的容器中。
    void setEnabled(boolean) boolean isEnabled()设置或获取组件是否已启用。启用的组件可以响应用户输入并生成事件。
    void setVisible(boolean) boolean isVisible()设置或获取组件是否可见。组件最初是可见的,顶级组件除外。

    处理事件

    方法目的
    void addHierarchyListener(hierarchyListener l) void removeHierarchyListener(hierarchyListener l)添加或删除指定的层次结构侦听器,以便在此容器所属的层次结构发生更改时从此组件接收层次结构更改事件。如果listener l为null,则不会抛出异常并且不执行任何操作。
    void addMouseListener(MouseListener) void removeMouseListener(MouseListener)向组件添加或从组件中删除 鼠标侦听器。当用户使用鼠标与收听的组件进行交互时,将通知鼠标侦听器。
    void addMouseMotionListener(MouseMotionListener) void removeMouseMotionListener(MouseMotionListener)向组件添加或从组件中删除 鼠标移动侦听器。当用户在侦听组件的边界内移动鼠标时,将通知鼠标移动侦听器。
    void addKeyListener(KeyListener) void removeKeyListener(KeyListener)向组件添加或从组件中删除 键侦听器。当用户在键盘上键入并且收听的组件具有键盘焦点时,将通知键侦听器。
    void addComponentListener(ComponentListener) void removeComponentListener(ComponentListener)组件添加组件侦听器或从组件中删除 组件侦听器。监听组件被隐藏,显示,移动或调整大小时会通知组件侦听器。
    boolean contains(int,int) boolean contains(Point)确定指定的点是否在组件内。应根据组件的坐标系指定参数。这两个int参数分别指定xy坐标。
    Component getComponentAt(int, int) Component getComponentAt(Point) 
    Component setComponentZOrder(component comp, int index)将指定的组件移动到容器中指定的z-order索引。 如果组件是某个其他容器的子组件,则在将其添加到此容器之前将其从该容器中删除。此方法之间的重要区别在于java.awt.Container.add(Component, int)removeNotify除非必要且底层本机窗口系统允许,否则此方法在从前一个容器中删除组件时不会调用该组件。这样,如果组件具有键盘焦点,则在移动到新位置时它会保持焦点。 注意: z顺序确定组件的绘制顺序。具有最高z次序涂料的组件首先涂漆,具有最低z次序涂料的组件最后涂漆。在组件重叠的情况下,具有较低z次序的组件在具有较高z次序的组件上绘制。
    Component getComponentZOrder(component comp)返回容器内组件的z顺序索引。组件在z顺序层次结构中越高,其索引越低。具有最低z顺序索引的组件最后绘制,高于所有其他子组件。

    绘画组件

    方法目的
    void repaint() void repaint(int,int,int,int)请求重新绘制全部或部分组件。这四个int参数指定要绘制的矩形的边界(xy,宽度,高度,按此顺序)。
    void repaint(Rectangle)请求重新绘制组件中的指定区域。
    void revalidate()请求再次布置组件及其受影响的容器。除非在可见之后显式更改组件的大小/对齐提示,否则通常不需要调用此方法,或者在可见后更改包含层次结构。总是repaint在之后调用revalidate
    void paintComponent(Graphics)绘制组件。重写此方法以实现自定义组件的绘制。

    处理包含层次结构

    方法目的
    Component add(Component) Component add(Component, int) void add(Component, Object)将指定的组件添加到此容器中。此方法的单参数版本将组件添加到容器的末尾。如果存在,int参数表示新组件在容器中的位置。如果存在,则Object参数为当前布局管理器提供布局约束。
    void remove(int) void remove(Component) void removeAll()从此容器中删除一个或所有组件。如果存在,则int参数指示要移除的组件的容器内的位置。
    JRootPane getRootPane()获取包含该组件的根窗格。
    Container getTopLevelAncestor()获取组件的最顶层容器 - a WindowApplet如果组件尚未添加到任何容器,则返回null。
    Container getParent()获取组件的直接容器。
    int getComponentCount()获取此容器中的组件数。
    Component getComponent(int) Component[] getComponents()获取此容器中的一个或所有组件。该int参数指示组件的位置来获得。
    Component getComponentZOrder(int) Component[] getComponentZOrder()返回容器内组件的z顺序索引。组件在z顺序层次结构中越高,其索引越低。具有最低z顺序索引的组件最后绘制,高于所有其他子组件。

    布局组件

    方法目的
    void setPreferredSize(Dimension) void setMaximumSize(Dimension) void setMinimumSize(Dimension)设置组件的首选,最大或最小尺寸,以像素为单位。首选大小表示组件的最佳尺寸。组件不应大于其最大大小,且不小于其最小大小。请注意,这些仅是提示,某些布局管理器可能会忽略这些提示。
    Dimension getPreferredSize() Dimension getMaximumSize() Dimension getMinimumSize()获取组件的首选大小,最大大小或最小大小(以像素为单位)。许多JComponent类都有setter和getter方法。对于那些JComponent没有相应setter方法的非子类,可以通过创建子类并覆盖这些方法来设置组件的首选,最大或最小大小。
    void setAlignmentX(float) void setAlignmentY(float)沿x轴y轴设置对齐。这些值表示组件如何相对于其他组件对齐。该值应为0到1之间的数字,其中0表示沿原点对齐,1表示距离原点最远,0.5表示居中,依此类推。请注意,这些仅是提示,某些布局管理器可能会忽略这些提示。
    float getAlignmentX() float getAlignmentY()获取组件沿x轴y轴的对齐方式。对于JComponent没有相应setter方法的非子类,可以通过创建子类并覆盖这些方法来设置组件的对齐方式。
    void setLayout(LayoutManager) LayoutManager getLayout()设置或获取组件的布局管理器。布局管理器负责在容器内调整和定位组件。
    void applyComponentOrientation(ComponentOrientation)void setComponentOrientation(ComponentOrientation)设置ComponentOrientation此容器的属性及其中包含的所有组件。有关更多信息,请参阅设置容器的方向

    获取大小和位置信息

    方法目的
    int getWidth() int getHeight()获取以像素为单位测量的组件的当前宽度或高度。
    Dimension getSize() Dimension getSize(Dimension)以像素为单位获取组件的当前大小。使用此方法的单参数版本时,调用方负责创建Dimension返回结果的实例。
    int getX() int getY()获取组件原点相对于父级左上角的当前x或y坐标(以像素为单位)。
    Rectangle getBounds() Rectangle getBounds(Rectangle)获取以像素为单位测量的组件边界。边界指定组件相对于其父级的宽度,高度和原点。使用此方法的单参数版本时,调用方负责创建Rectangle返回结果的实例。
    Point getLocation() Point getLocation(Point)获取组件相对于父级左上角的当前位置(以像素为单位)。使用单参数版本的getLocation方法时,调用者负责创建Point返回结果的实例。
    Point getLocationOnScreen()返回相对于屏幕左上角的位置。
    Insets getInsets()获取组件边框的大小。

    指定绝对大小和位置

    方法目的
    void setLocation(int,int) void setLocation(Point)设置组件相对于父级左上角的位置(以像素为单位)。这两个int参数按顺序指定xy。不使用布局管理器时,使用这些方法定位组件。
    void setSize(int,int) void setSize(Dimension)设置以像素为单位测量的组件大小。这两个int参数按顺序指定宽度和高度。不使用布局管理器时,使用这些方法调整组件的大小。
    void setBounds(int,int,int,int) void setBounds(Rectangle)设置相对于父组件左上角的大小和位置(以像素为单位)。这四个int参数按顺序指定xy,width和height。在不使用布局管理器时,使用这些方法来定位和调整组件的大小。

    实例

    实例1-自定义组件外观

     /**
       * 自定义组件外观
       */
      package JComponent类;
      ​
      import java.awt.Color;
      import java.awt.Cursor;
      import java.awt.Font;
      ​
      import javax.swing.BorderFactory;
      import javax.swing.JButton;
      import javax.swing.JFrame;
      import javax.swing.border.Border;
      ​
      public class SetLookDemo {
          private static void setLook() {
              JFrame frame = new JFrame("设置边框");
              frame.setSize(300, 400);
              frame.setLocation(300, 300);
              frame.setLayout(null);
      ​
              // 设置一个按钮
              JButton button1 = new JButton("按钮1");
              
              //设置按钮的字体
              button1.setFont(new Font("宋体",Font.BOLD,20));
              //获取组件设置的字体
              Font f=button1.getFont();
              System.out.println("按钮设置的字体是:"+f);
              
              // 设置按钮的边框
              Border border=BorderFactory.createLineBorder(Color.red);
              button1.setBorder(border);
              //获取按钮的边框
              Border bor=button1.getBorder();
              System.out.println("按钮的边框是:"+bor);
              
              //设置组件是否不透明
              button1.setOpaque(true);//不透明
              button1.setOpaque(false);//按钮透明
              //获取组件是否被设置为不透明
              System.out.println("按钮组件是否被设置为不透明:"+button1.isOpaque());
              
              //设置按钮的前景色
              button1.setForeground(Color.green);
              //获取按钮的前景色
              Color col=button1.getForeground();
              System.out.println("按钮的前景色是:"+col);
              
              //设置按钮的背景色
              button1.setBackground(Color.orange);
              //获取按钮的背景色
              Color col2=button1.getBackground();
              System.out.println("按钮的背景色是:"+col2);
              
              //设置光标显示在组件上
              button1.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
              //获取显示在组件上的光标
              Cursor cur=button1.getCursor();
              System.out.println("显示在组件上的光标是:"+cur);
              
              // 设置button的大小和位置
              button1.setBounds(50, 50, 100, 30);
              // 将button添加到主窗口
              frame.add(button1);
      ​
              
      ​
              frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
              frame.setVisible(true);
          }
          
          public static void main(String[] args) {
              setLook();
          }
      }

    实例2-设置和获取组件状态

    /**
       * 设置和获取组件状态
       */
      package JComponent类;
      ​
      import java.awt.Color;
      import java.awt.Cursor;
      import java.awt.Font;
      ​
      import javax.swing.BorderFactory;
      import javax.swing.JButton;
      import javax.swing.JFrame;
      import javax.swing.border.Border;
      ​
      public class SetComponentStatement {
          private static void setStatement() {
              JFrame frame = new JFrame("设置边框");
              frame.setSize(300, 400);
              frame.setLocation(300, 300);
              frame.setLayout(null);
      ​
              // 设置一个按钮
              JButton button1 = new JButton("按钮");
              // 设置button的大小和位置
              button1.setBounds(50, 50, 100, 30);
              
              //设置工具提示
              button1.setToolTipText("这是一个按钮");
              
              //设置组件名称
              button1.setName("我是按钮");
              //获取组件名称
              String name=button1.getName();
              System.out.println("按钮组件的名称是:"+name);
              
              //确定组件是否在屏幕上显示
              button1.isShowing();
              
              // 将button添加到主窗口
              frame.add(button1);
              
              //设置组件是否已经启用
              button1.setEnabled(false);
              System.out.println("组件是否已经启用:"+button1.isEnabled());
      ​
              //设置组件是否可见
              button1.setVisible(true);
              System.out.println("组件是否可见:"+button1.isVisible());
              
              frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
              frame.setVisible(true);
          }
      ​
          public static void main(String[] args) {
              setStatement();
          }
      }

    实例3-处理包含层次结构

     /**
       * 处理包含层次结构
       */
      package JComponent类;
      ​
      import java.awt.Component;
      import java.awt.ComponentOrientation;
      import java.awt.Container;
      import java.awt.Dimension;
      import java.awt.FlowLayout;
      import java.awt.LayoutManager;
      ​
      import javax.swing.JButton;
      import javax.swing.JFrame;
      import javax.swing.JRootPane;
      ​
      public class SetComponent {
          private static void setComponent() {
              JFrame frame = new JFrame();
              frame.setSize(300, 400);
              frame.setLocation(300, 300);
              frame.setLayout(null);
      ​
              // 设置一个按钮
              JButton button1 = new JButton("按钮");
              // 设置button的大小和位置
              button1.setBounds(50, 50, 100, 30);
      ​
              // 删除组件
      //      frame.remove(button1);
              // 删除所有组件
      //      frame.removeAll();
      ​
              // 添加组件到主窗口
              frame.add(button1);
      ​
              // 获取包含组件的根窗格
              JRootPane jrp = button1.getRootPane();
              System.out.println("该组件的根窗格是:" + jrp);
              
              //获取组件的最顶层容器
              Container  con=button1.getTopLevelAncestor();
              System.out.println("该组件的最顶层容器是:"+con);
              
              
              //获取组件的直接容器
              Container con2=button1.getParent();
              System.out.println("该组件的直接容器:"+con2);
              
              //获取此容器中的组件数
              int count=frame.getComponentCount();
              System.out.println("此容器中的组件数:"+count);
              
              //获取此容器中的一个组件
              Component con3=frame.getComponent(0);//从0开始的
              System.out.println("此容器中的一个组件:"+con3);
      ​
              frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
              frame.setVisible(true);
          }
      ​
          public static void main(String[] args) {
              setComponent();
          }
      }

    实例4-布局组件

     /**
       * 布局组件
       */
      package JComponent类;
      ​
      import java.awt.ComponentOrientation;
      import java.awt.Dimension;
      import java.awt.FlowLayout;
      import java.awt.LayoutManager;
      ​
      import javax.swing.JButton;
      import javax.swing.JFrame;
      ​
      public class SetLayoutConponent {
          private static void layoutConponent() {
              JFrame frame = new JFrame();
              frame.setSize(300, 400);
              frame.setLocation(300, 300);
              frame.setLayout(null);
      ​
              // 设置一个按钮
              JButton button1 = new JButton("按钮");
              // 设置button的大小和位置
              button1.setBounds(50, 50, 100, 30);
              //添加组件到主窗口
              frame.add(button1);
              
              //设置组件的首选值
              Dimension setpreferredSize=new Dimension(100,50);
              button1.setPreferredSize(setpreferredSize);
              //获取组件的首选大小
              Dimension getPreferredSize=button1.getPreferredSize();
              System.out.println("组件的首选大小为:"+getPreferredSize);
              
              //设置组件的最大值
              Dimension setMaxSize=new Dimension(100,100);
              button1.setMaximumSize(setMaxSize);
              //获取组件的最大值
              Dimension getMaxSize=button1.getMaximumSize();
              System.out.println("组件的最大大小为:"+getMaxSize);
              
              //设置组件的最小值
              Dimension setMinSize=new Dimension(20,20);
              button1.setMinimumSize(setMinSize);
              //获取组件的最小值
              Dimension getMinSize=button1.getMinimumSize();
              System.out.println("组件的最小大小为:"+getMinSize);
              
              //设置组件沿x轴对齐
              button1.setAlignmentX(0.5f);
              //获取组件沿x轴的对齐方式
              System.out.println("组件沿x轴对齐方式为:"+button1.getAlignmentX());
              
              //设置组件沿y轴对齐
              button1.setAlignmentY(0.5f);
              //获取组件沿y轴的对齐方式
              System.out.println("组件沿y轴对齐方式为:"+button1.getAlignmentY());
              
              //设置布局管理器
              frame.setLayout(new FlowLayout());
              //获取布局管理器
              LayoutManager lm=frame.getLayout();
              System.out.println("容器的布局管理器为:"+lm);
              
              //设置ComponentOrientation
              ComponentOrientation co=ComponentOrientation.LEFT_TO_RIGHT;
              button1.applyComponentOrientation(co);
              button1.setComponentOrientation(co);
              
              frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
              frame.setVisible(true);
          }
      ​
          public static void main(String[] args) {
              layoutConponent();
          }
      }
      ​

    实例5-获取大小和位置信息

     /**
       * 获取组件大小和位置信息
       */
      package JComponent类;
      ​
      import java.awt.Dimension;
      import java.awt.Insets;
      import java.awt.Point;
      import java.awt.Rectangle;
      ​
      import javax.swing.JButton;
      import javax.swing.JFrame;
      ​
      public class GetSizeAndLocationInfo {
      ​
          private static void getSizeInfo() {
              JFrame frame = new JFrame();
              frame.setSize(300, 400);
              frame.setLocation(300, 300);
              frame.setLayout(null);
      ​
              // 设置一个按钮
              JButton button1 = new JButton("按钮");
              button1.setBounds(50, 50, 100, 50);
              // 将button添加到主窗口
              frame.add(button1);
      ​
              // 获取组件的当前宽度
              int width = button1.getWidth();
              System.out.println("组件的当前宽度为:" + width);
      ​
              // 获取组件的当前高度
              int height = button1.getHeight();
              System.out.println("组件的当前高度为:" + height);
      ​
              // 获取组件的X位置
              int x = button1.getX();
              System.out.println("组件的当前X位置为:" + x);
      ​
              // 获取组件的Y位置
              int y = button1.getY();
              System.out.println("组件的当前Y位置为:" + y);
      ​
              // 获取组件的大小
              Dimension di = button1.getSize();
              System.out.println("组件的当前大小为:" + di);
      ​
              // 获取组件的位置
              Rectangle rect = button1.getBounds();
              System.out.println("组件的当前位置为:" + rect);
      ​
              // 获取组件相对于父级组件左上角的当前位置
              Point point = button1.getLocation();
              System.out.println("组件相对于父级组件左上角位置为:" + point);
      ​
              // 获取组件边框的大小
              Insets in = button1.getInsets();
              System.out.println("组件边框的大小为:" + in);
      ​
              frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
              frame.setVisible(true);
          }
      ​
          public static void main(String[] args) {
              getSizeInfo();
          }
      }
      ​

    实例6-指定绝对大小和位置

    package JComponent类;
      ​
      import java.awt.Dimension;
      import java.awt.Point;
      import java.awt.Rectangle;
      ​
      import javax.swing.JButton;
      import javax.swing.JFrame;
      ​
      public class SetAbsoluteSizeAndLocationDemo {
          private static void setSizeAndLocation() {
              JFrame frame = new JFrame();
              frame.setSize(300, 400);
              frame.setLocation(300, 300);
              frame.setLayout(null);
      ​
              // 设置一个按钮
              JButton button1 = new JButton("按钮");
      ​
              // 设置组件的位置
              button1.setLocation(300, 200);
              // 获取组件的位置
              System.out.println("组件位置为:" + button1.getLocation());
      ​
              // 通过Point来设置组件新位置
              Point p = new Point(0, 0);
              button1.setLocation(p);
      ​
              //设置组件大小
              button1.setSize(100,50);
              //获取组件的大小
              System.out.println("组件大小为:"+button1.getSize());
              
              //通过Dimension来设置组件大小
              Dimension d=new Dimension(80,60);
              button1.setSize(d);
              
              //同时设置组件大小和位置
              button1.setBounds(50, 50, 100, 50);
              //获取组件大小和位置
              System.out.println("获取组件大小和位置:"+button1.getBounds());
              
              //通过Rectangle设置组件大小和位置
              Rectangle rect=new Rectangle(10,10,200,80);
              button1.setBounds(rect);
              
              // 将button添加到主窗口
              frame.add(button1);
      ​
              frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
              frame.setVisible(true);
          }
      ​
          public static void main(String[] args) {
              setSizeAndLocation();
          }
      }
      ​
    

     

    更多相关内容
  • 1、JComponent类概览 JComponent扩展java. awt.Container,而 java. awt . Container又扩展java.awt . Component,因此,所有的Swing组件都是AWT容器。Component 和Container类本身提供了大量的功能,因此,...

    1、JComponent类概览

    JComponent扩展java. awt.Container,而 java. awt . Container又扩展java.awt . Component,因此,所有的Swing组件都是AWT容器。Component 和Container类本身提供了大量的功能,因此,JComponent继承了大量的功能。
    因为JComponent为几乎所有的Swing组件提供下层构件,因此,它是一个很大的类,包括100多个public方法。JComponent类为它的扩展提供了下面的功能:

    • **边框:**任何JComponent 的扩展都可以带边框。Swing 提供了许多不同风格的边框,如雕刻边框、带标题边框和蚀刻边框。虽然一个组件只能有一个边框,但是边框是可以组合的。因此,从效果上来看,单个组件可有多个边框。
    • 自动滚动: 当把光标拖出了组件的边界时,Swing轻量组件可以滚动其内容,这个特性称作自动滚动。所有的JComponent扩展都继承了自动滚动的功能。可以在每个组件的基础上设置允许或禁止自动滚动。缺省时,JList和JI able是允许自动滚动的。
    • **可访问性:**可访问性是使人人都能使用软件。例如,为视力不好的用户放大字体或为听力不好的用户显示带声音的标题。
      Swing 的插入式界面样式体系结构通过允许把可选择的界面样式分配给一组组件来支持可访问性。
    • **工具提示:**工具提示是当光标停在带工具提示的JCmpnext扩展上时,在一个小窗口中显示的字符串。工具提示大多用在工具条按钮上,用于描述指定按钮的功能。
      工具提示相当灵活,例如,可根据停留在组件上的光标位置来改变工具提示的文本内容。图像映像是需要这种特性的主要情况,图像映像弹出对当前光标下的内容的简单说明。
      可通过ToolTipManager类来设置从光标开始停留在组件上到显示工具提示之间的时间间隔。
    • **双缓存:**在更新组件(擦除然后重绘组件)时,会产生可察觉的闪烁。双缓存通过在屏外缓存区中更新组件,然后把屏外缓存区的相应部分拷贝到组件的屏上代表中来消除闪烁。
      所有的Swing轻量组件都继承了双缓存它们显示内容的能力。一个屏外缓存(由Swing 的RepaintManger维护)常用于双缓存JComponent的扩展。
    • 调试图形: 调用JComponent.setDebugGraphicsOptions (int)可以把一个组件转换成一个慢速绘制器,该绘制器在每个图形调用前闪烁一下,而且还可以维护-个图形调用的日志文件。
      调试图形允许开发人员快速、准确地了解组件是如何绘制的,在实现一个需要大量绘制的定制组件时,调试图形是很方便的。
    • **键击处理:**JComponent类提供对嵌套键击处理的支持。不需要开发人员过滤所有的键击事件并对感兴趣的键击事件作出反应,当在某些条件下按下或释放一个键击时,可以指示JComponent 把动作事件发送给一个特定的目标。
    • 客户属性: 每个JComponent对象都维护一个称作客户属性的词典。词典维护一组“关键字/值”对,“关键字/值"对可以是任何类型的对象。客户属性可以把任何JComponent与一个不扩展JComponent类的对象联系起来。

    2、JComponent类结构

    在这里插入图片描述

    2.1 Swing组件是AWT容器

    因为JComponent扩展java. awt . Container,所以每个JComponent 扩展都可以包含AWT和Swing组件。

    2.2 最小尺寸、最大尺寸和首选尺寸

    我们要对上面这句话进行解释,一个组件的最小尺寸、最大尺寸和首选尺寸并不决定其实际尺寸。通常,布局管理器设置组件的大小,且布局管理器有权决定是否使用最小尺寸、最大尺寸和首选尺寸。事实上,最小尺寸、最大尺寸和首选尺寸是一个尺寸请求,在确定组件尺寸时,该请求可能被考虑也可能不被考虑。
    与AWT组件必须扩展才能修改最小尺寸、最大尺寸和首选尺寸不同,Swing 组件带有设置组件尺寸的方法。

    void setMaxmumSize(Dimension) //设置组件最大尺寸
    void setMinimumSize(Dimension) //设置组件最小尺寸
    void setPreferredSize(Dimension) //设置组件首选尺寸
    Dimension getMaxmumSize() //返回组件的最大尺寸
    Dimension getMinimumSize() //返回组件的最大尺寸
    Dimension getPreferredSize() //返回组件的最大尺寸
    

    3、绘制JComponent组件

    3.1. paint、repaint和update方法
    • 调用repaint ()后,就会调用AWT组件和Swing 组件的update方法。
    • 对AWT组件,update()擦除该组件的背景,接着调用paint ()。有时,擦除背景是人们所不希望的。例如,在一个图形条中,不断用获得的新数据来更新其显示。反复擦除和重新绘制该图像会导致可察觉的闪烁。在这种情况下,一般是用AWT组件的扩展来重载update()以便直接调用paint()方法,因此,避免了擦除组件背景和与之有关的闪烁。
    • 对Swing 组件而言,为了消除闪烁,不需要重载update ()来直接调用paint ()。因为,JComponent类重载了update (),直接调用paint ()。然而,这不是说Swing组件在重新绘制组件时不擦除组件背景。当重新绘制Swing组件时,擦除这个组件背景的任务就交给这个组件的UI代表来完成(如果这个组件有一个UI代表的话)。
    • 幸运的是,不需要子类化一个组件的UI代表来消除闪烁,因为,缺省时,Swing组件是双缓存的,这意味着擦除组件然后重新绘制组件的工作都是在屏外缓存中进行的。当组件在其屏外缓存中更新后,再把更新后的组件拷贝到屏幕上。双缓存消除了闪烁,因此,不需要为Swing 组件重载update()方法。如果Swing 组件闪烁,则解决方法是确保该组件是双缓存而不是重载update ( )。
    3.2 validate、invalidate和revalidate

    Swing 和AWT的containers都提供了一个validate方法,该方法可为容器中的所有组件布局。例如,有一个容器,它含有一个按钮,且这个按钮的文本已经改变(因此是无效的),如果为该容器调用validate (),则该容器将布局这个按钮及该容器中的所有其他组件。

    对invalidate ()和validate ()的调用在容器层次结构中分别向上和向下传播,因此,使一个组件无效会使这个组件的容器层次结构中的所有容器无效。

    JComponent类提供了–个revalidate方法,这个方法使组件无效并为组件层次结构中的第一个容器在事件派发线程上安排一个validate ()的调用,如果组件的isValidateRoot 属性被设置为true的话。因为包含在JApplet或JFrame实例中的所有Swing组件都在根面板中,所以,为Swing小应用程序或应用程序中的一-个Swing组件调用revalidate ()将使该组件被布局。在组件布局后,已改变的组件区域将重新绘制。

    注意:

    第一,同调用repaint ()一样,对revalidate ()的调用是合并的。因此,如果为某个容器中的多个组件连续调用revalidate (),则这些revalidate ()调用将合并,即只调用一次revalidate ( )。
    第二,任何为改变位置和大小而改变的Swing 组件应该通过组件本身来重新生效,布局和重新绘制组件。不幸的是,对Swing 1.1 FCS/1.2 JDK,重新生效操作并不总是执行。如果在组件的位置和大小改变后,组件没有被布局和重新绘制,则这是Swing 的错误造成的。
    第三,虽然对JComponent . revalidate()的调用应该使已经变化了的组件域重新绘制,但是重新绘制不总是发生。因此,有时需要在调用revalidate ()后,再调用repaint ( )
    3.3 不透明组件与透明组件的比较

    Swing组件可以是不透明的或部分透明的。

    3.4 立即绘制Swing组件

    为一个组件调用repaint ()会产生一个将要放到AWT事件序列上的绘制事件。因此,如果repaint ()是从一个事件处理方法中调用的,则直到该事件处理方法返回才会进行重新绘制。
    JComponent类提供了立即绘制组件的方法,即 paintImmediately ()方法,该方法适合在需要立即更新组件外观的事件处理方法中使用。

    4、双缓存

    Swing包括一个RepaintManager类,该类维护一个屏外缓存。该缓存很大,足以容纳下屏幕的大小,用它来双缓存所有的Swing 轻量组件。如果一个组件处在一个双缓存的容器中,则该组件就自动是双缓存的,因此,对Swing的轻量容器来说,缺省时,只需规定JRootPane和JPanel是双缓存的即可。

    5、调试图形

    Swing提供了java. awt.Graphics类的一个扩展——swing. DebugGraphics,它减慢图形操作的速率并且在每次操作前闪烁。另外,DebugGraphics类可以输出它所执行的图形调用的日志。操作执行的速率、每次操作的闪烁次数、闪烁的颜色和要输出的日志流都是可设置的,可通过DebugGraphics类中的static public方法来设置。

    在利用调试图形方面,现在我们所知道的要比我们实际所需要的多。与大多数Swing特性一样,调试图形已不再复杂,例如,我们不需要知道还有一个扩展java .awt.Graphics 的 DebugGraphics类。要使用调试图形,只需调用JComponent的方法 setDebugGraphicsOptions ( int),其中的整数参数代表下面的调试选项:

    DebugGraphics. LOG _ OPTION
    DebugGraphics.FLASH _ OPTION
    DebugGraphics. BUFFERED _ OPTION
    DebugGraphics . NONE_ OPTION
    

    把Swing组件的调试图形选项设置为DebugGraphics.NONE_ OPTION 以外的任意选项,都会引起该组件在绘制时使用一个DebugGraphics实例。
    选项 BUFFERED_ OPTION用于双缓存组件,它引起弹出一个外部的窗口并显示该组件的屏外缓存。

    6、自动滚动

    JComponent具有自动滚动的功能。当鼠标被拖出组件的边界后,自动滚动功能使组件能继续滚动。
    调用JComponent的 setAutoScrolls ( boolean)方法可启用或禁用自动滚动。JComponent还提供返回一个boolean值的 getAutoscrolls方法,该boolean值指示该组件的自动滚动是否是允许的.缺省时,只有列表和表格的自动滚动是允许的。

    7、工具提示

    工具提示是当鼠标停留在一个组件上的时间超出指定的时间后在一个窗口中显示的一行文字。

    把工具提示与一个Swing 组件相关联是通过调用JComponent.setToolTiplext()来实现的。JComponent.setToolTiplext()所带的参数是将在工具提示窗口中显示的字符串。把null字符串传送给setToolTiplext()将使该组件以前的工具提示无效。

    7.1基于鼠标位置的工具提示

    在工具提示的实现上,有三个类:

    • 第一是JComponent类,如前所述,JComponent类提供了一个setTooTipText方法,该方法为组件激活工具提示并设置与工具提示有关的文本。
    • 第二是JToolTip类,由于Swing插入式界面样式的实现,这个类仅维护工具提示文本和一个对与工具提示有关的组件的引用。实际显示工具提示文本的代码封装在工具提示的界面样式中,而界面样式又存在于swing . plaf . ToolTipUI类的扩展中。
    • 第三,Swing的ToolTipManager类负责提供一个将在其中显示工具提示的窗口,并负责把JTooTips 实例插入到显示它们的窗口中。ToolTipManager还控制定时问题,如鼠标停留在组件上的时间与显示工具提示的时间之间的时间差。
    7.2 工具提示的首选位置

    重载JComponent . getToolTipLocation方法可以用来设置工具提示的首选位置。getToolTipLocation方法带入一个MouseEvent并返回一个 Point,工具提示将显示在 Point 的位置上。

    缺省时,JComponent . getrToolTipLocation ()返回null,指示工具提示应该直接显示在鼠标光标的下面。

    JComponent 的扩展可以重载getToolTipText ()来指定要显示的工具提示的确切位置。

    7.3 定制工具提示的行为

    当光标在组件上停留一定时间后就会显示工具提示,这里的一定时间指的是初始延迟。缺省时,初始延迟被设置为750毫秒。
    下述三个事件之一的事件可清除工具提示:

    • 光标离开了这个组件。
    • 按下了鼠标。
    • 清除延迟:指的是提示从出现到消失的时间

    如果光标离开显示工具提示的组件,接着进入另一个带工具提示的组件,则第二个组件的工具提示可能立即显示出来。如果退出第一个组件进入第二个组件之间的时间少于重新显示延迟( reshow delay),则第二个组件的工具提示将会立即显示。缺省的重新显示延迟时间是500毫秒。表4-3总结了工具提示的延迟。

    7.4 定制工具提示的界面样式

    与大多数Swing组件一样,工具提示也有一个UI代表,该UI代表决定该工具提示的界面样式。

    8、键击处理

    当向一个特定的组件登记了键击时,这个组件就称作已登记的组件。处理一个键击指的是与这个键击相关联的ActionListener调用其actionPerformed方法。

    当已登记的组件有焦点时,处理满足WHEN_ FOCUSED条件的键击。

    当已登记的组件有焦点或已登记的组件包含有焦点的组件时,则处理满足WHEN_ ANCES-TOR_ OF _ FOCUSED _ COMPONENT条件的键击。对键击处理而言,术语父组件指容器包含层次结构,而不是继承关系。从这个意义上讲,父组件与容器是同义的。

    当任何与已登记组件处在同一个窗口中的组件有焦点时,处理WHEN_ IN_ FOCUSED _ WINDOW键击。

    9、客户属性

    每个JComponent实例都维护-个称作客户属性的属性字典。一个字典由一-组键/值对组成,这里,键和值可能是任何类型的对象。Swing类本身使用客户属性。例如,组件把它们的工具提示文本作:为一个客户属性来维护,JL ayeredPane类把它的组件层作为–个客户属性来维护。

    客户属性是被约束的属性,即不论何时一个客户属性修改了,那么属性变化事件就会发送给组件的属性变化监听器。

    处理客户属性的方法:set/getClientProperty()

    10、焦点管理

    缺省时,在 Swing容器中按下Tab键将把焦点移到下一个可获得焦点的组件上,按下Shift+Tab可把焦点移到上一次获得焦点的组件.上。可以用JComponent的焦点属性或缺省焦点管理器的替代属性来修改缺省的行为。

    10.1 JComponent的焦点属性
    • focusCycleRoot——确定一个容器是否包含形成它们自己的焦点循环的那些组件。如果该属性设置为true,则按下Tab键将把焦点移到该容器中并且焦点会在容器的组件中移动,但不会移出容器本身。
    • focusTraversable—-—确定焦点管理器是否将把焦点传给一个组件。其focusTraversable属性指定为false 的组件在requestFocus ()被调用时仍将接受焦点,例如,如果一个按钮的focusTraversable属性被设置为false(通过在JButton 的一个扩展中重载isFocusTraversable ( )),则单击该按钮会产生对requestFocus ()的一个调用,并且该按钮仍将接受焦点。但是,如果按下Tab或Shift + Tab,则该按钮将不接受焦点。
    • managingFocus——确定当按下键把焦点切换到–个组件或从一个组件把焦点移开时,是否要把所按下的键传送给这个组件本身。缺省时是不传送的。
    • requestFocusEnabled——与focusTraversable属性相反,如果该属性设置为false,则在request-Focus ()调用时组件将不接受焦点,但是,作为键按下的结果,焦点管理器将把焦点传给该组件。
    • nextFocusableComponent——在按下Tab键时,指定接受焦点的下一个组件。注意,不能把焦点传送给以前的可获得焦点的组件。
    10.2 焦点管理器
    • Swing的焦点管理器负责把焦点从一个组件传送给另一个组件。Swing 提供了一个抽象的FocusManager类和一个DefaultFocusManager 扩展。DefaultFocusManager类把焦点从左传送到右,从上传送到下。
    • 缺省的焦点管理器负责确定用哪个键来移动焦点。缺省时,Tab和Ctrl +'Tab向前移动焦点,Shift +Tab和 Ctrl + Shift +Tab向后移动焦点。可以扩展DefaultFocusManager,而且可以重载其processKeyEvent方法以便修改缺省的行为。
    • 假如当前有焦点的组件没有重载getNextFocusedComponent()来返回一个非空组件,则缺省焦点管理器在comparelabOrder方法的帮助下将决定哪个组件下一次将接受焦点。DefaultFocusMan-ager. compareTabOnder 以两个组件为参数并返回一个boolean值,该值指出在tab顺序中它的第一个组件参数是否在第二个组件参数前。
    展开全文
  • Java JComponent

    2021-03-07 18:04:09
    Java JComponent1 Java JComponent的介绍JComponent类是除顶层容器之外的所有Swing组件的基类。名称以“ J”开头的Swing组件是JComponent类的后代。例如,JButton,JScrollPane,JPanel,JTable等。但是,JFrame和...

    Java JComponent

    1 Java JComponent的介绍

    JComponent类是除顶层容器之外的所有Swing组件的基类。名称以“ J”开头的Swing组件是JComponent类的后代。例如,JButton,JScrollPane,JPanel,JTable等。但是,JFrame和JDialog不继承JComponent类,因为它们是顶级容器的子级。

    JComponent类扩展了Container类,而Container类本身又扩展了Component。Container类支持将组件添加到容器中。

    2 Java JComponent的字段

    字段

    描述

    accessibleContext

    与此JComponent关联的AccessibleContext。

    listenerList

    此组件的事件侦听器的列表。

    TOOL_TIP_TEXT_KEY

    当光标位于组件上方时显示的注释,也称为“值提示”,“悬浮式帮助”或“悬浮式标签”

    ui

    此组件的外观委托。

    UNDEFINED_CONDITION

    它是某些API使用的常量,表示未定义任何条件。

    WHEN_ANCESTOR_OF_FOCUSED_COMPONENT

    它是用于registerKeyboardAction的常数,这意味着当接收组件是关注组件的祖先或本身就是关注组件时,应调用命令。

    WHEN_FOCUSED

    它是用于registerKeyboardAction的常数,这意味着当组件具有焦点时应调用命令。

    WHEN_IN_FOCUSED_WINDOW

    用于registerKeyboardAction的常量,这意味着当接收组件位于具有焦点的窗口或本身就是焦点组件的窗口中时,应调用命令。

    3 Java JComponent的构造方法

    构造方法

    描述

    JComponent()

    默认的JComponent构造函数。

    4 Java JComponent的方法

    方法

    描述

    void setActionMap(ActionMap am)

    将ActionMap设置为am。

    void setBackground(Color bg)

    设置此组件的背景色。

    void setFont(Font font)

    为此组件设置字体。

    void setMaximumSize(Dimension maximumSize)

    将此组件的最大大小设置为恒定值。

    void setMinimumSize(Dimension minimumSize)

    将此组件的最小大小设置为恒定值。

    protected void setUI(ComponentUI newUI)

    为此组件设置外观委托。

    void setVisible(boolean aFlag)

    使组件可见或不可见。

    void setForeground(Color fg)

    设置此组件的前景色。

    String getToolTipText(MouseEvent event)

    返回用作事件工具提示的字符串。

    Container getTopLevelAncestor()

    返回此组件的顶级祖先(包含Window或Applet),如果未将此组件添加到任何容器,则返回null。

    TransferHandler getTransferHandler()

    获取transferHandler属性。

    5 Java JComponent的案例

    package com.yiidian;

    /**

    * 一点教程网: http://www.yiidian.com

    */

    import java.awt.Color;

    import java.awt.Graphics;

    import javax.swing.JComponent;

    import javax.swing.JFrame;

    class MyJComponent extends JComponent {

    public void paint(Graphics g) {

    g.setColor(Color.green);

    g.fillRect(30, 30, 100, 100);

    }

    }

    public class JComponentExample {

    public static void main(String[] arguments) {

    MyJComponent com = new MyJComponent();

    // create a basic JFrame

    JFrame.setDefaultLookAndFeelDecorated(true);

    JFrame frame = new JFrame("JComponent案例-一点教程网");

    frame.setSize(300,200);

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    // add the JComponent to main frame

    frame.add(com);

    frame.setVisible(true);

    }

    }

    输出结果为:

    ff203dbd6d0e6949e9da0c5fc0008021.png

    展开全文
  • JComponent是一个和JPanel很相似的组件的容器,但又有区别。 JPanel不透明,所以在需要透明等应用场景的条件比较麻烦,使用JComponent比较方便。package swing;import javax.swing.*;import java.awt.*;/*** @author...

    JComponent是一个和JPanel很相似的组件的容器,但又有区别。 JPanel不透明,所以在需要透明等应用场景的条件比较麻烦,使用JComponent比较方便。

    package swing;

    import javax.swing.*;

    import java.awt.*;

    /**

    * @author: 我的袜子都是洞

    * @description:

    * @path: tourJava-swing-NotHelloWorld

    * @date: 2019-01-18 22:48

    */

    public class NotHelloWorld {

    public static void main(String[] args) {

    EventQueue.invokeLater(() -> {

    JFrame frame = new NotHelloWorldFrame();

    frame.setTitle("Not Hello World");

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    frame.setVisible(true);

    });

    }

    }

    class NotHelloWorldFrame extends JFrame {

    public NotHelloWorldFrame () {

    add(new NotHelloWorldComponent());

    // 调整窗口大小,要考虑到其组件的首选大小

    pack();

    }

    }

    /**

    * JComponent不同于JPanel,JPanel不透明,JComponent透明

    */

    class NotHelloWorldComponent extends JComponent {

    public static final int MESSAGE_X = 75;

    public static final int MESSAGE_Y = 100;

    public static final int DEFAULT_WIDTH = 300;

    public static final int DEFAULT_HEIGHT = 200;

    public void paintComponent (Graphics g) {

    g.drawString("Not a hello world program", MESSAGE_X, MESSAGE_Y);

    }

    public Dimension getPreferredSize () {

    return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT);

    }

    }

    复制代码

    运行效果:

    bd0f92bfc13cf8bd03c7df2a1e7c0b36.png

    展开全文
  • java类——JComponent

    2021-03-13 07:16:45
    public abstract class JComponent该类是除顶层容器外所有 Swing 组件的基类。要使用继承自 JComponent 的组件,必须将该组件置于一个根为顶层 Swing 容器的包含层次结构(containment hierarchy)中。顶层 Swing 容器...
  • 除了顶层容器类,其他J开头的类都是继承自JComponent类,其中包括JPanel, JScrollPane, JButton, 和JTable。 JComponent继承自Container类,Container类继承自Component类。 Component类提供了界面绘制和事件处理...
  • 我想开始为工作中的项目构建自己的自定义JComponent.我在下面有一个简单的例子,它应该只是在屏幕上创建一个球. (我在互联网上发现了大部分内容),但确实提供了一个不错的起点.我的问题是为什么这段代码不能以我的形式...
  • JPanel 是 JComponent的一种。 jpanel就是一个平板,叫做面板,但是可以有很多种布局可选择。 JComponent叫容器 , 并不一定是什么东西,没有具体定义容器应该是什么外观,只是说明他能够容纳其他的swing组件。 ...
  • java swing:JComponent

    2019-09-17 01:57:37
    JComponent类学习 层次结构: +java.lang.Object +java.awt.Component +java.awt.Container +javax.swing.JComponent API中文解释:  该类是除顶层容器外所有 Swi...
  • 这些类是Java UI设计的通用扩展点。 首先,要认识到它们之间...JComponent-用于与Swing交互的对象的基类。 JFrame-用于表示窗口应具有的内容。 这包括边框(可调整大小的y / n?),标题栏(应用程序名称或其他消息)
  • 详细讲解了JComponent与ComponentUI的内在关系
  • } }因为JComponent的visible属性默认就是true,所以不会调用到Component的setVisible方法,所以也不会fire出ComponentEvent,当然,如果你调用下JComponent的setVisible(false)+setVisible(true)是会fire出...
  • Swing JComponent

    千次阅读 2017-10-11 11:17:10
    +java.lang.Object  +java.awt.Component  +java.awt.Container  +javax.swing.JComponent ...要使用继承自 JComponent 的组件,必须将该组件置于一个根为顶层 Swing 容器的包含层次结构(contain
  • java界面编程一 JComponent类学习

    千次阅读 多人点赞 2018-03-07 20:22:25
    转载注明出处:...要使用继承自 JComponent 的组件,必须将该组件置于一个根为顶层 Swing 容器的包含层次结构(containment hierarchy)中。顶层 Swing 容器(如 JFrame、JDialo...
  • } @Override protected void exportDone(JComponent source, Transferable data, int action) { super.exportDone(source, data, action); // Decide what to do after the drop has been accepted } } public ...
  • java.lang.Object java.awt.Component java.awt.Container javax.swing.JComponent JComponent类是除顶层容器外所有 Swing 组件的基类。要使用继承自 JComponent 的组件,必须将该组件置于一个根为顶层 Swing 容器...
  • 空项目:PWA 说明: 从NPM安装最新版本的Total.js框架4 $ npm install total4 下载范例 运行$ node index.js 打开浏览器http://127.0.0.1:8000 将文件/builds/app.build到
  • import javax.swing.JComponent; //导入方法依赖的package包/类/*** Method description** @see*/final public void setLanguageJLabels(boolean bolPhideControlJFrame) {final Rectangle ...
  • 第4章 JComponent类  JComponent类是所有Swing轻量组件的基类,因此,我们单独用一章对它进行讨论。JComponent对Swing的意义就如同java.awt.Component对AWT的意义一样,它们都是它们各自框架组件的基类。 作为所有...
  • Java Swing之JPanel和JComponent

    千次阅读 2018-04-03 11:18:59
    如果需要创建一个能够进行绘制的组件,一般需要定义一个扩展JComponent的类,并覆盖其中的paintComponent方法。如下所示:class MyComponent extends JComponent { public void paintComponent(Graphics g) { ...
  • Jcomponent

    2012-12-27 20:42:00
    并不是所有的Swing组件都继承于JComponent类,JComponent类继承于Container类,所以凡是此类的组件都可作为容器使用。 组件从功能上分可分为: 1) 顶层容器:JFrame,JApplet,JDialog,JWindow共4个 2) 中间容器...
  • Can anyone give insight as to why a JPanel that is drawing simple shapes such as rectangles, in small quantity, could lag noticeably when resizing the frame?I think that by adding an event for window ...
  • 下列程序段的输出结果是String MyStr = "Hello,";MyStr = MyStr + "World!";System.out.println(确定固定资产处置损益时,应考虑的因素有()。A.累计折旧B.营业税C.固定资产使用年限D.固定资产原价结构化分析...
  •  JComponent{    public   static   final   int  MSG_X= 75 ;    public   static   final   int  MSG_Y= 50 ;    public   static   final   int  DEFAULT_W= 300 ;    public ...
  • 如题,自己编写一个继承自JComponent的类并重写了paint()方法,但是直接初始化这个类无法显示图形,只有初始化一个面板(JFrame,Frame)再在面板上add这个组件才能显示 但JFrame,Frame自己就是继承自组件类...
  • 目前它看起来如此怎么做它看起来如此?以下是我的代码:JFrame f = new JFrame();JTextPane textPane = new JTextPane();JTextField component = new JTextField(" ");component.setMaximumSize(component....
  • public class MyComponent extends JComponent { // Instance variables. private int width; private int height; public MyComponent() { width = getWidth(); height = getHeight(); System.out.println(width+...
  • 博为峰小博老师:JComponent类的一些特性。其实它的特性非常多,其中有9大特性尤其显著。Tool tipsTool tips就是工具提示功能,通过在setToolTipText方法中指定字符串,可以为一个组件提供一些帮助。当以标停留在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,242
精华内容 3,296
关键字:

jcomponent