swing 订阅
Swing是一个用于开发Java应用程序用户界面的开发工具包。以抽象窗口工具包(AWT)为基础使跨平台应用程序可以使用任何可插拔的外观风格。Swing开发人员只用很少的代码就可以利用Swing丰富、灵活的功能和模块化组件来创建优雅的用户界面。 工具包中所有的包都是以swing作为名称,例如javax.swing,javax.swing.event。 展开全文
Swing是一个用于开发Java应用程序用户界面的开发工具包。以抽象窗口工具包(AWT)为基础使跨平台应用程序可以使用任何可插拔的外观风格。Swing开发人员只用很少的代码就可以利用Swing丰富、灵活的功能和模块化组件来创建优雅的用户界面。 工具包中所有的包都是以swing作为名称,例如javax.swing,javax.swing.event。
信息
基    础
抽象窗口工具包(AWT)
示    例
avax.swing,javax.swing.event
特    点
丰富、灵活的功能和模块化组件
中文名
Swing
功    能
开发Java应用程序用户界面
性    质
开发工具包
Swing步骤
(1)导入Swing包 Swing 可定制图形界面(6张) (2)选择界面风格(3)设置顶层容器(4)设置按钮和标签(5)将组件放到容器上(6)为组件增加边框(7)处理事件(8)辅助技术支持下面语句导入Swing包import javax.swing.*;大部分Swing程序用到了AWT的基础底层结构和事件模型,因此需要导入两个包:import java.awt.*;import java.awt.event.*;如果图形界面中包括了事件处理,那么还需要导入事件处理包:import javax.swing.event.*;Swing允许选择程序的图形界面风格常用的有java风格,windows风格等下面的代码用于选择图形界面风格,这里选择的是跨平台的Java界面风格。try { UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName( )); }catch (Exception e) { }图形界面至少要有一个顶级Swing容器顶级Swing容器为其它Swing组件在屏幕上的绘制和处理事件提供支持常用的顶级容器:JFrame(框架):表示主程序窗口JDialog(对话框):每个JDialog对象表示一个对话框,对话框属于二级窗口JApplet(小程序):在浏览器内显示一个小程序界面一个框架包括边界、菜单栏、工具栏、状态栏,以及中间占主要部分的窗格窗格也可以看作是一种面板,但它是框架的一个组成部分组件不会直接放到框架上,而是放在若干个面板上,这些面板再放到窗格上用框架对象的getContentPane()函数来获得窗格,再调用窗格的add()函数放置面板public static void main(String[ ]args){JFrame frame=new JFrame("SwingApplication");JPanel panel1=new JPanel();frame.getContentPane().add(panel1,BorderLayout.CENTER);......//frame.pack();frame.setVisible(true);}
收起全文
精华内容
下载资源
问答
  • Java Swing 图形界面开发简介

    万次阅读 多人点赞 2017-05-30 23:52:47
    Java Swing GUI 图形界面窗口开发基础教程,本教程将系统性地详细介绍 Swing 开发中常用的一些组件、布局管理器等相关知识技术,并且每章节都将通过代码实例展示实际应用。Swing 是 Java 为图形界面应用开发提供的...

    本文链接: http://blog.csdn.net/xietansheng/article/details/72814531

    Java Swing GUI 图形界面窗口开发基础教程,本教程将系统性地详细介绍 Java Swing 开发中常用的一些组件、布局管理器等相关知识技术,并且每章节都将通过代码实例展示实际应用。

    教程总目录: Java Swing 图形界面开发(目录)

    1. Swing简介

    Swing 是 Java 为图形界面应用开发提供的一组工具包,是 Java 基础类的一部分。

    Swing 包含了构建图形界面(GUI)的各种组件,如: 窗口、标签、按钮、文本框等。

    Swing 提供了许多比 AWT 更好的屏幕显示元素,使用纯 Java 实现,能够更好的兼容跨平台运行。

    为了和 AWT 组件区分,Swing 组件在javax.swing.*包下,类名均以 J 开头,例如: JFrame、JLabel、JButton等。

    2. Swing组件

    一个 Java 的图形界面,由各种不同类型的“元素”组成,例如: 窗口、菜单栏、对话框、标签、按钮、文本框等等,这些“元素”统一被称为 组件Component)。

    组件按照不同的功能,可分为 顶层容器中间容器基本组件。一个简单窗口的组成,如下层级结构所示:

    • 顶层容器
      • 菜单栏
      • 中间容器
        • 基本组件
        • 基本组件

    组件类型的继承关系:

    • 顶层容器 属于窗口类组件,继承自java.awt.Window
    • 中间容器 和 基本组件 继承自javax.swing.JComponent

    2.1 顶层容器

    顶层容器属于窗口类组件,可以独立显示,一个图形界面至少需要一个窗口,例如:

    # 组件 描述
    1 JFrame 一个普通的窗口(绝大多数 Swing 图形界面程序使用 JFrame 作为顶层容器)
    2 JDialog 对话框

    2.2 中间容器

    中间容器充当基本组件的载体,不可独立显示。中间容器可以添加若干基本组件(也可以嵌套添加中间容器),对容器内的组件进行管理,类似于给各种复杂的组件进行分组管理。最顶层的一个中间容器必须依托在顶层容器(窗口)内。

    常用的中间容器(面板):

    # 组件 描述
    1 JPanel 一般轻量级面板容器组件
    2 JScrollPane 带滚动条的,可以水平和垂直滚动的面板组件
    3 JSplitPane 分隔面板
    4 JTabbedPane 选项卡面板
    5 JLayeredPane 层级面板

    特殊的中间容器:

    # 组件 描述
    1 JMenuBar 菜单栏
    2 JToolBar 工具栏
    3 JPopupMenu 弹出菜单
    4 JInternalFrame 内部窗口

    2.3 基本组件

    基本组件是直接实现人机交互的组件。

    常用的简单的基本组件:

    # 组件 描述
    1 JLabel 标签
    2 JButton 按钮
    3 JRadioButton 单选按钮
    4 JCheckBox 复选框
    5 JToggleButton 开关按钮
    6 JTextField 文本框
    7 JPasswordField 密码框
    8 JTextArea 文本区域
    9 JComboBox 下拉列表框
    10 JList 列表
    11 JProgressBar 进度条
    12 JSlider 滑块

    选取器组件:

    # 组件 描述
    1 JFileChooser 文件选取器
    2 JColorChooser 颜色选取器

    其他较为复杂的基本组件:

    # 组件 描述
    1 JTable 表格
    2 JTree

    3. 布局管理器

    Swing 的各种组件(JComponent)添加到面板容器中(JPanel),需要给面板容器指定布局管理器(LayoutManager),明确容器(Container)内的各个组件之间的排列布局方式。

    常用的布局管理器:

    # 布局管理器 描述
    1 FlowLayout 流式布局,按组件加入的顺序,按水平方向排列,排满一行换下一行继续排列。
    2 GridLayout 网格布局,把Container按指定行列数分隔出若干网格,每一个网格按顺序放置一个控件。
    3 GridBagLayout 网格袋布局,按网格划分Container,每个组件可占用一个或多个网格,可将组件垂直、水平或沿它们的基线对齐。
    4 BoxLayout 箱式布局,将Container中的多个组件按 水平 或 垂直 的方式排列。
    5 GroupLayout 分组布局,将组件按层次分组(串行 或 并行),分别确定 组件组 在 水平 和 垂直 方向上的位置。
    6 CardLayout 卡片布局,将Container中的每个组件看作一张卡片,一次只能显示一张卡片,默认显示第一张卡片。
    7 BorderLayout 边界布局,把Container按方位分为 5 个区域(东、西、南、北、中),每个区域放置一个组件。
    8 SpringLayout 弹性布局,通过定义组件四条边的坐标位置来实现布局。
    9 null 绝对布局,通过设置组件在Container中的坐标位置来放置组件。

    4. 代码实例: 一个简单的窗口程序

    package com.xiets.swing;
    
    import javax.swing.*;
    
    public class Main {
    
        public static void main(String[] args) {
            // 1. 创建一个顶层容器(窗口)
            JFrame jf = new JFrame("测试窗口");          // 创建窗口
            jf.setSize(250, 250);                       // 设置窗口大小
            jf.setLocationRelativeTo(null);             // 把窗口位置设置到屏幕中心
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); // 当点击窗口的关闭按钮时退出程序(没有这一句,程序不会退出)
    
            // 2. 创建中间容器(面板容器)
            JPanel panel = new JPanel();                // 创建面板容器,使用默认的布局管理器
    
            // 3. 创建一个基本组件(按钮),并添加到 面板容器 中
            JButton btn = new JButton("测试按钮");
            panel.add(btn);
    
            // 4. 把 面板容器 作为窗口的内容面板 设置到 窗口
            jf.setContentPane(panel);
    
            // 5. 显示窗口,前面创建的信息都在内存中,通过 jf.setVisible(true) 把内存中的窗口显示在屏幕上。
            jf.setVisible(true);
        }
    
    }
    

    结果展示:

    result.png


    展开全文
  • Java Swing 图形界面开发(目录)

    万次阅读 多人点赞 2017-05-30 23:50:42
    Java Swing 图形界面(GUI)开发基础教程(目录)

    本文链接: https://blog.csdn.net/xietansheng/article/details/72814492

    0. JavaSwing 简介

    1. JavaSwing 布局管理器

    2. JavaSwing 基本组件

    3. JavaSwing 面板组件

    4. JavaSwing 其他组件

    5. JavaSwing 相关特性

    扩展:Java AWT/Swing 其他相关


    展开全文
  • Swing

    千次阅读 2019-11-25 14:37:54
    为什么需要Swing? 使用AWT已经能够实现图形界面,为什么还需要Swing? AWT依赖本地系统支持,在不同的系统上,外观不同. AWT只能实现所有平台上都有的组件,大大限制了AWT所支持的组件的数量. Swing完全使用100%Java...

    为什么需要Swing?
    使用AWT已经能够实现图形界面,为什么还需要Swing?

    • AWT依赖本地系统支持,在不同的系统上,外观不同.
    • AWT只能实现所有平台上都有的组件,大大限制了AWT所支持的组件的数量.
    • Swing完全使用100%Java实现,组件全都使用Java绘制.
    • 在不同的平台上用户体验完全相同.
    • 可以控制所有组件的底层代码,甚至可以重写所有组件.
    • 组件数量非常多,可以实现更多功能.
    • 使用MVC设计模式,组件实现更加合理和易于维护.
    • 组件本身功能也更加强大.
    • 实际Java的GUI应用中,大多使用Swing,很少使用AWT.
      虽然AWT在实际使用中很少使用,Swing和AWT还是存在着很大的关联.
    • 大部分Swing组件(Jcomponent及其子类)都是AWT中Container类的子类
    • Swing为AWT中几乎所有的组件都提供了相对应的组件.(通常在你熟悉的AWT组件前面加上J就是对应的Swing组件)
    • Swing中可以使用AWT中的布局管理对界面进行布局管理
    • Swing中使用的时间处理方式和AWT中的事件处理方式相似
      BoxLayout
      出了AWT提供了Layout之外,Swing也提供了另外一种Layout.BoxLayout将组件放在单一的行或列中,和FlowLayout不同的是,它可以考虑到组件的对齐方式,最大,最小和最佳尺寸.
      除此之外,开发者还可以下载第三方的Layout或者干脆自己继承Layout类设计和编写自己的Layout.
      在这里插入图片描述
      Swing基本组件
      Swing为几乎所有的AWT组件提供了自己的实现,并且功能更加强大.
    • 可以使用setToolTipText()方法为组件设置鼠标悬停提示.
    • 大部分的Swing组件(按钮、标签、菜单项等),除了可以设置文字之外,还可以设置图标(ImageIcon类).
    • Swing组件可以设置一个或多个边框.其中空白边框可以用户增大组件之间的间隔,结合布局期使用往往会得到很好的效果.
    • Swing组件可以设置不同的外观。每一个JComponent类都有一个对应的ComponentUI类,它为这个Jcomponent类完成诸如绘制、事件处理、计算组件大小的任务.
      Swing常见组件的分类
      顶层容器:
      JFrame、JApplet、JDialog和Jwindow
      组件容器:
      Jpanel、JScrollPane、JSplitPane、JToolBar…
      特殊容器(一般不会手动创建和使用):
      JInternalFrame、JRootPane、JLayeredPane和JDesktopPane…
      基本组件(实现主要的人机交互):
      JButton、JComboBox、JList、JMenu、JSlider…
      不可编辑组件:
      JLabel、JProgressBar和JToolTip。
      可编辑组件:
      JTextField、JTextArea、JTable等。
      对话框组件:
      JFileChooser、JcolorChooser等。
      Swing组件的关系图
      在这里插入图片描述
      Swing菜单与工具栏
      Swing菜单
      菜单是基本的GUI组件。
      Swing菜单主要涉及的类有:
      JMenuBar:主菜单栏
      JPopupMenu:邮件弹出式菜单
      JMenu:菜单,其下可以添加菜单项
      JMenuItem:菜单项,单击将触发某功能
      JCheckBoxMenuItem:带有复选框的菜单项
      JRadioButtonMenuItem:带有单选框的菜单项
      Jseparator:菜单的项的分割符
      Swing工具栏
      工具栏是除了菜单之外另外一种非常常用的GUI组件。
      Swing工具栏主要涉及的类有:
      JToolBar:主工具栏容器,里面可放置各种按钮和组件
      JToolTip:按钮提示
      JButton:工具栏上的具体按钮,通过菜单栏的add(Action)方法创建
      Swing对话框
      JFileChooser
      让用户选择一个已有的文件或者新建一个文件
      可以使用JFileChooser的showDialog、showOpenDialog或showSaveDialog()方法来打开文件对话框,但是它仅仅会返回用户选择的按钮(确认还是取消)和文件名(如果确认的话),接下来的要实现的例如存盘或者打开的功能还需要程序员自己编写
      这个类提供了专门的方法用于设置可选择的文件类型,还可以指定每类文件使用的类型图标
      在这里插入图片描述
      JColorChooser
      可以让用户选择所需要的颜色
      通常使用这个类的静态方法showDialog()来输出标准的颜色选择对话框,其返回值就是选择的颜色
      也可以通过静态方法createDialog()方式输出个性化的颜色选择对话框,例如为其添加菜单、定义其事件处理程序,这个方法的返回值就是一个对话框
      在这里插入图片描述
      JOptionPane
      如果要提示一些简单的信息,在AWT中,我们需要自己继承Dialog类,并添加相应的组件。
      在javax.swing包内提供了JOptionPane来显示一些简单的提示信息,或是做一些简单的选择
      通过使用这个类提供的一些静态方法show×××Dialog,就可以产生四种简单的对话框
      这四种对话框(除了输入对话框可以不指定父窗口)都需要提供一个父窗口组件ParentComponent
      指定了父窗口后,这些对话框自动成为模式对话框
      Swing中的特殊容器
      JSplitPane
      可以把两个组件显示在两个显示区域内,且随着区域间分隔线的拖动,区域内组件的大小也随之发生变动
      它允许设置水平分割或者垂直分割;也允许设置动态拖曳功能(拖动分界线时两边组件是否会随着拖曳动态改变大小还是在拖曳结束后才改动)
      我们通常先把组件放到Scroll Pane中,再把Scroll Pane放到Split Pane中。这样在每部分窗口中,都可以拖动滚动条看到组件的全部内容
      具体的API请查看API文档和教材。
      JTabbedPane
      Tab是一种常用的界面元素,可以节省界面空间,在同一个窗口上组织多项功能,也是微软新界面体系Ribbon的核心元素之一
      在基于Tab的界面中,我们可以给每项设置一个标签,每个标签下面包含为完成此功能专用的若干组件
      用户要使用哪项功能,只用点击相应的标签,就可以进入相应的页面
      在AWT中,可以通过CardLayout和按钮结合的方式来实现。
      由于基于Tab的界面现在非常流行,在Swing中,Java提供了一种专门的容器来实现Tab界面
      JLayeredPane
      有关层次的组件。
      JDesktopPane与JInternalFrame
      如果要实现在一个主窗口中打开很多个文档,每个文档各自占用一个新的窗口,就需要使用JInternalFrame容器类
      JInternalFrame的使用跟JFrame几乎一样,可以最大化、最小化、关闭窗口、加入菜单
      唯一不同的是JInternalFrame不是顶级容器,只能作为中间容器,必须依附于顶层容器上
      通常我们会将JInernalFrame加入JDesktopPane类的对象来方便管理,JDesktopPane继承自JLayeredPane,用来建立虚拟桌面。它可以显示并管理众多JInternalFrame之间的层次关系
      Swing中的数值调整组件
      JProgressBar
      在一些软件运行时,会出现一个进度条告知目前进度如何.通过使用该组件我们可以轻松地微软件嘉善一个进度条.
      JSlider
      一个可以让用户通过拖动控制杆选择一个介于最大和最小值之间的数值的组件.
      适合用于控制不是很精确的场景.
      在界面空间比较大的时候使用比较方便,若界面空间太小,则选择不精确.
      在这里插入图片描述
      JSpinner
      用于精确选择数值的组件
      类似于可编辑的JComboBox,是种复合组件,由三个部分组成:向上按钮、向下按钮和一个文本编辑区
      可以通过按钮来选择待选项,也可以直接在文本编辑区内输入
      适用于界面空间较小或者对选择的数值控制比较精确的场景
      在这里插入图片描述
      Swing中的列表组件
      MVC
      Model-View-Controller Pattern(模型-视图-控制器模式),是一种常用的图形界面设计模式。
      模型:图形界面系统中组件的内部数据表示。
      视图:用于将组件的内部数据显示出来给用户看的类。
      控制器:将模型和视图连接起来
      控制用户界面上的事件
      从视图上获取消息
      将视图上的消息传递给模型
      MVC的两种模式
      在这里插入图片描述
      JList
      Swing的几乎所有组件都是根据MVC模式设计的
      而JList才是使用MVC模式的经典例子。
      在这里插入图片描述
      构造函数:
      public JList()
      public JList(ListModel model)
      public JList(Object[] data)
      public JList(Vector data)
      监听器:
      public void addListSelectionListener( ListSelectionListener lsl)
      DefaultListModel是ListModel的默认实现。
      在这里插入图片描述
      JList选择相关方法
      public void clearSelection()

    public int getSelectedIndex()
    public int[] getSelectedIndices()
    public Object getSelectedValue()
    public Object[] getSelectedValues()

    public void setSelectedIndex(int index)
    public void setSelectedIndices(int[] indices)
    public int getSelectionMode()
    public void setSelectionMode(int mode)
    ListSelectionModel.SINGLE_SELECTION
    JComboBox
    JComboxBox是下拉列表框。
    和JList类似,JComboBox使用ComboBoxModel。
    构造函数:
    public JComboBox()
    public JComboBox(Vector items)
    public JComboBox(ComboBoxModel model)
    监听器:
    public void addActionListener(ActionListener al)
    在这里插入图片描述
    选择:
    public int getSelectedIndex()
    public Object getSelectedItem()
    public void setSelectedItem(Object item)
    public void setSelectedIndex(int index)
    其他:
    public void setEnabled(boolean enabled)
    public void setEditable(boolean editable)
    ListCellReader
    ListCellRenderer用于将ListModel中的每一个数据项,渲染称为某种显示格式。
    JList和JComboBox都可以使用ListCellRenderer来显示每一个列表项目。
    默认的ListCellRenderer只是将ListModel中的数据显示成为一个简单的字符串。
    如果需要显示格式更为复杂的列表项目,则可以自己继承并重写ListCellRenderer。
    Swing中的树组件
    树形结构
    树形结构是一种常用的层次化显示组件。
    Swing中使用JTree来表示树形结构。
    JTree也完全遵循MVC模式。
    低层使用TreeModel,并通过TreeCellRenderer来显示树形结构。
    术语:
    Root(根)
    Parent(父)
    Node(节点)
    Branch(枝)
    在这里插入图片描述
    JTree和DefaultTreeModel
    JTree用于将TreeModel中的数据以树形结构的形式显示在图形界面上。
    DefaultTreeModel是一种简单的树形数据结构的实现。
    DefaultTreeModel中包含有TreeNode,一般称为Root(根)
    TreeNode又可以包含其他的TreeNode。
    TreeModel的常用方法:
    getChild(Object parent, int index)
    getChildCount (Object parent)
    getIndexOfChild(Object parent, Object child)
    getRoot()
    isLeaf(Object node)
    创建JTree

    DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root");
    treeModel = new DefaultTreeModel(root);
    tree = new JTree(treeModel);
    
    DefaultMutableTreeNode subroot = new DefaultMutableTreeNode("Subroot");
    treeModel.insertNodeInto(subroot, root, 0);	
    
    DefaultMutableTreeNode leaf1 = new DefaultMutableTreeNode("Leaf 1");	
    treeModel.insertNodeInto(leaf1, subroot, 0);
    
    DefaultMutableTreeNode leaf2 = new DefaultMutableTreeNode("Leaf 2"); 
    treeModel.insertNodeInto(leaf2, root, 1); 
    
    

    JTree的选择模式
    JTree的选择模式,不能在JTree上直接设置,而需要在其TreeModel上设置:

    tree.getSelectionModel().setSelectionMode (
    	TreeSelectionModel.SINGLE_TREE_SELECTION);
    

    JTree的选择模式:
    SINGLE_TREE_SELECTION
    DISCONTIGUOUS_TREE_SELECTION
    CONTIGUOUS_TREE_SELECTION
    监听节点事件
    和其他组件一样,JTree使用监听器来监听事件
    JTree的事件主要是节点被选中,使用以下方法来添加监听器:
    tree.addTreeSelectionListener(TreeSelectionListener)
    处理事件需要重写TreeSelectionListener中的valueChanged()方法

    public void valueChanged(TreeSelectionEvent e) { 
    	DefaultMutableTreeNode node = 					(DefaultMutableTreeNode)tree.getLastSelectedPathComponent(); 
    }
    

    扩展DefaultTreeCellRender
    和JList一样,JTree可以通过扩展默认的TreeCellRenderer来改变树上每个节点的显示方法。
    Swing中的文本组件
    JTextField和JPasswordField
    JTextField使用方法和AWT中TextField类似。
    JPasswordField的使用和JTextField类似,但是用户的输入都以特殊符号替代,无法看出输入的字符。
    可以使用以下方法来控制特殊字符:
    setEchoChar(*);
    JFormattedTextField
    JFormattedTextField可以验证用户的输入是否合法。
    主要构造函数:
    JFormattedTextField(Format)
    JFormattedTextField(Formatter)
    Format:
    DateFormat
    MessageFormat
    NumberFormat
    当JFormattedTextField失去焦点的时候,Format将查看用户的输入,如果可以通过Format将用户的输入转换为特定的类型,则用户输入是合法的。
    可以使用isEditValid()方法来获取用户刚刚输入是否合法。

    展开全文
  • JavaSwing_4.8: JTable(表格)

    万次阅读 多人点赞 2017-09-24 21:13:38
    Java Swing 图形界面开发(目录) 1. 概述 官方JavaDocsApi: javax.swing.JTable JTable,表格。JTable 是用来显示和编辑常规二维单元表。 2. 创建简单的表格 package com.xiets...

    本文链接: https://blog.csdn.net/xietansheng/article/details/78079806

    Java Swing 图形界面开发(目录)

    1. 概述

    官方JavaDocsApi: javax.swing.JTable

    JTable,表格。JTable 是用来显示和编辑常规二维单元表。

    2. 创建简单的表格

    package com.xiets.swing;
    
    import javax.swing.*;
    import java.awt.*;
    
    public class Main {
    
        public static void main(String[] args) {
            JFrame jf = new JFrame("测试窗口");
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    
            // 创建内容面板,使用边界布局
            JPanel panel = new JPanel(new BorderLayout());
    
            // 表头(列名)
            Object[] columnNames = {"姓名", "语文", "数学", "英语", "总分"};
    
            // 表格所有行数据
            Object[][] rowData = {
                    {"张三", 80, 80, 80, 240},
                    {"John", 70, 80, 90, 240},
                    {"Sue", 70, 70, 70, 210},
                    {"Jane", 80, 70, 60, 210},
                    {"Joe", 80, 70, 60, 210}
            };
    
            // 创建一个表格,指定 所有行数据 和 表头
            JTable table = new JTable(rowData, columnNames);
    
            // 把 表头 添加到容器顶部(使用普通的中间容器添加表格时,表头 和 内容 需要分开添加)
            panel.add(table.getTableHeader(), BorderLayout.NORTH);
            // 把 表格内容 添加到容器中心
            panel.add(table, BorderLayout.CENTER);
    
            jf.setContentPane(panel);
            jf.pack();
            jf.setLocationRelativeTo(null);
            jf.setVisible(true);
        }
    
    }
    

    结果展示:

    result_01.png

    表格组件和其他普通组件一样,需要添加到中间容器中才能显示,添加表格到容器中有两种方式:

    1. 添加到普通的中间容器中(如上面代码实例所示的添加到JPanel),此时添加的jTable只是表格的行内容,表头(jTable.getTableHeader())需要额外单独添加。此添加方式适合表格行数确定,数据量较小,能一次性显示完的表格;
    2. 添加到JScrollPane滚动容器中,此添加方式不需要额外添加表头,jTable添加到jScrollPane中后,表头自动添加到滚动容器的顶部,并支持行内容的滚动(滚动行内容时,表头会始终在顶部显示)。

    3. JTable 常用的操作方法

    JTable常用构造方法:

    // 创建空表格,后续再添加相应数据
    JTable() 
    
    // 创建指定行列数的空表格,表头名称默认使用大写字母(A, B, C ...)依次表示
    JTable(int numRows, int numColumns) 
    
    // 创建表格,指定 表格行数据 和 表头名称
    JTable(Object[][] rowData, Object[] columnNames)
    
    // 使用表格模型创建表格
    JTable(TableModel dm)
    

    JTable 字体网格 颜色设置:

    // 设置内容字体
    void setFont(Font font)
    
    // 设置字体颜色
    void setForeground(Color fg)
    
    // 设置被选中的行前景(被选中时字体的颜色)
    void setSelectionForeground(Color selectionForeground)
    
    // 设置被选中的行背景
    void setSelectionBackground(Color selectionBackground)
    
    // 设置网格颜色
    void setGridColor(Color gridColor)
    
    // 设置是否显示网格
    void setShowGrid(boolean showGrid)
    
    // 水平方向网格线是否显示
    void setShowHorizontalLines(boolean showHorizontalLines)
    
    // 竖直方向网格线是否显示
    void setShowVerticalLines(boolean showVerticalLines)
    

    JTable 表头 设置:

    // 获取表头
    JTableHeader jTableHeader = jTable.getTableHeader();
    
    // 设置表头名称字体样式
    jTableHeader.setFont(Font font);
    
    // 设置表头名称字体颜色
    jTableHeader.setForeground(Color fg);
    
    // 设置用户是否可以通过在头间拖动来调整各列的大小。
    jTableHeader.setResizingAllowed(boolean resizingAllowed);
    
    // 设置用户是否可以拖动列头,以重新排序各列。
    jTableHeader.setReorderingAllowed(boolean reorderingAllowed);
    

    JTable 行列 相关设置:

    // 设置所有行的行高
    void setRowHeight(int rowHeight)
    
    // 设置指定行的行高
    void setRowHeight(int row, int rowHeight)
    
    /**
     * 设置当手动改变某列列宽时,其他列的列宽自动调整模式,可选值:
     *     JTable.AUTO_RESIZE_ALL_COLUMNS 在所有的调整大小操作中,按比例调整所有的列。
     *     JTable.AUTO_RESIZE_LAST_COLUMN 在所有的调整大小操作中,只对最后一列进行调整。
     *     JTable.AUTO_RESIZE_NEXT_COLUMN 在 UI 中调整了一个列时,对其下一列进行相反方向的调整。
     *     JTable.AUTO_RESIZE_OFF 不自动调整列的宽度;使用滚动条。
     *     JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS 在 UI 调整中,更改后续列以保持总宽度不变;此为默认行为。
     */
    void setAutoResizeMode(int mode)
    
    /*
     * 调整列宽
     */
    // 先获取到某列
    TableColumn tableColumn = jTable.getColumnModel().getColumn(int columnIndex);
    
    // 设置列的宽度、首选宽度、最小宽度、最大宽度
    tableColumn.setWidth(int width);
    tableColumn.setPreferredWidth(int preferredWidth);
    tableColumn.setMinWidth(int minWidth);
    tableColumn.setMaxWidth(int maxWidth);
    
    // 调整该列的列宽,以适合其标题单元格的宽度。
    tableColumn.sizeWidthToFit();
    
    // 是否允许手动改变该列的列宽
    tableColumn.setResizable(boolean isResizable);
    
    // 设置该列的表头名称
    tableColumn.setHeaderValue(Object headerValue);
    

    JTable 数据 相关操作:

    /*
     * 表格数据的简单设置和获取
     */
    // 设置表格中指定单元格的数据
    jTable.getModel().setValueAt(Object aValue, int rowIndex, int columnIndex);
    
    // 获取表格中指定单元格的数据
    Object value = jTable.getModel().getValueAt(int rowIndex, int columnIndex);
    

    4. 创建带滚动条的表格

    创建带滚动条的表格基本步骤:

    // 创建表格
    JTable table = new JTable(...);
    
    /* 设置表格相关数据 */
    
    // 设置滚动面板视口大小(超过该大小的行数据,需要拖动滚动条才能看到)
    table.setPreferredScrollableViewportSize(new Dimension(int width, int height));
    
    // 创建滚动面板,把 表格 放到 滚动面板 中(表头将自动添加到滚动面板顶部)
    JScrollPane scrollPane = new JScrollPane(table);
    
    /* 再把滚动面板 scrollPane 添加到其他容器中显示 */
    

    完整实例代码:

    package com.xiets.swing;
    
    import javax.swing.*;
    import java.awt.*;
    
    public class Main {
    
        public static void main(String[] args) {
            JFrame jf = new JFrame("测试窗口");
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    
            // 创建内容面板
            JPanel panel = new JPanel();
    
            // 表头(列名)
            String[] columnNames = {"序号", "姓名", "语文", "数学", "英语", "总分"};
    
            // 表格所有行数据
            Object[][] rowData = {
                    {1, "张三", 80, 80, 80, 240},
                    {2, "John", 70, 80, 90, 240},
                    {3, "Sue", 70, 70, 70, 210},
                    {4, "Jane", 80, 70, 60, 210},
                    {5, "Joe_05", 80, 70, 60, 210},
                    {6, "Joe_06", 80, 70, 60, 210},
                    {7, "Joe_07", 80, 70, 60, 210},
                    {8, "Joe_08", 80, 70, 60, 210},
                    {9, "Joe_09", 80, 70, 60, 210},
                    {10, "Joe_10", 80, 70, 60, 210},
                    {11, "Joe_11", 80, 70, 60, 210},
                    {12, "Joe_12", 80, 70, 60, 210},
                    {13, "Joe_13", 80, 70, 60, 210},
                    {14, "Joe_14", 80, 70, 60, 210},
                    {15, "Joe_15", 80, 70, 60, 210},
                    {16, "Joe_16", 80, 70, 60, 210},
                    {17, "Joe_17", 80, 70, 60, 210},
                    {18, "Joe_18", 80, 70, 60, 210},
                    {19, "Joe_19", 80, 70, 60, 210},
                    {20, "Joe_20", 80, 70, 60, 210}
            };
    
            // 创建一个表格,指定 表头 和 所有行数据
            JTable table = new JTable(rowData, columnNames);
    
            // 设置表格内容颜色
            table.setForeground(Color.BLACK);                   // 字体颜色
            table.setFont(new Font(null, Font.PLAIN, 14));      // 字体样式
            table.setSelectionForeground(Color.DARK_GRAY);      // 选中后字体颜色
            table.setSelectionBackground(Color.LIGHT_GRAY);     // 选中后字体背景
            table.setGridColor(Color.GRAY);                     // 网格颜色
    
            // 设置表头
            table.getTableHeader().setFont(new Font(null, Font.BOLD, 14));  // 设置表头名称字体样式
            table.getTableHeader().setForeground(Color.RED);                // 设置表头名称字体颜色
            table.getTableHeader().setResizingAllowed(false);               // 设置不允许手动改变列宽
            table.getTableHeader().setReorderingAllowed(false);             // 设置不允许拖动重新排序各列
    
            // 设置行高
            table.setRowHeight(30);
    
            // 第一列列宽设置为40
            table.getColumnModel().getColumn(0).setPreferredWidth(40);
    
            // 设置滚动面板视口大小(超过该大小的行数据,需要拖动滚动条才能看到)
            table.setPreferredScrollableViewportSize(new Dimension(400, 300));
    
            // 把 表格 放到 滚动面板 中(表头将自动添加到滚动面板顶部)
            JScrollPane scrollPane = new JScrollPane(table);
    
            // 添加 滚动面板 到 内容面板
            panel.add(scrollPane);
    
            // 设置 内容面板 到 窗口
            jf.setContentPane(panel);
    
            jf.pack();
            jf.setLocationRelativeTo(null);
            jf.setVisible(true);
        }
    
    }
    

    结果展示:

    result_02.png

    5. 表格模型(TableModel)

    TableModel 接口指定了 JTable 用于询问表格式数据模型的方法。TableModel 封装了表格中的各种数据,为表格显示提供数据。上面案例中直接使用行数据和表头创建表格,实际上JTable 内部自动将传入的行数据和表头封装成了 TableModel。

    只要数据模型实现了 TableModel 接口,就可以通过以下两行代码设置 JTable 显示该模型:

    TableModel myData = new MyTableModel(); 
    JTable table = new JTable(myData);
    

    TableModel 接口中的方法:

    package javax.swing.table;
    
    import javax.swing.*;
    import javax.swing.event.*;
    
    public interface TableModel {
        /** 返回总行数 */
        public int getRowCount();
    
        /** 返回总列数 */
        public int getColumnCount();
    
        /** 返回指定列的名称(表头名称) */
        public String getColumnName(int columnIndex);
    
        /** 针对列中所有的单元格值,返回最具体的超类。JTable 使用此方法来设置列的默认渲染器和编辑器。 */
        public Class<?> getColumnClass(int columnIndex);
    
        /** 判断指定单元格是否可编辑 */
        public boolean isCellEditable(int rowIndex, int columnIndex);
    
        /** 获取指定单元格的值 */
        public Object getValueAt(int rowIndex, int columnIndex);
    
        /** 设置指定单元格的值 */
        public void setValueAt(Object aValue, int rowIndex, int columnIndex);
    
        /** 添加表格模型监听器 */
        public void addTableModelListener(TableModelListener l);
    
        /** 移除表格模型监听器 */
        public void removeTableModelListener(TableModelListener l);
    }
    

    JRE 中常用的已实现 TableModel 接口的类有两个:

    (1)javax.swing.table.AbstractTableModel

    此抽象类为 TableModel 接口中的大多数方法提供默认实现。它负责管理侦听器,并为生成 TableModelEvents 以及将其调度到侦听器提供方便。要创建一个具体的 TableModel 作为 AbstractTableModel 的子类,只需提供对以下三个方法的实现:

    public int getRowCount();
    public int getColumnCount();
    public Object getValueAt(int row, int column);
    

    (2)javax.swing.table.DefaultTableModel

    这是 TableModel 的一个实现,它使用一个 Vector 来存储单元格的值对象,该 Vector 由多个 Vector 组成。DefaultTableModel 还增加了许多方便操作表格数据的方法,例如 支持 添加 和 删除 行列 等操作

    下面使用 AbstractTableModel 创建一个表格:

    package com.xiets.swing;
    
    import javax.swing.*;
    import javax.swing.table.AbstractTableModel;
    import java.awt.*;
    
    public class Main {
    
        public static void main(String[] args) {
            JFrame jf = new JFrame("测试窗口");
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    
            // 创建内容面板,使用边界布局
            JPanel panel = new JPanel(new BorderLayout());
    
            // 使用表格模型创建一个表格
            JTable table = new JTable(new MyTableModel());
    
            // 把 表头 添加到容器顶部(使用普通的中间容器添加表格时,表头 和 内容 需要分开添加)
            panel.add(table.getTableHeader(), BorderLayout.NORTH);
            // 把 表格内容 添加到容器中心
            panel.add(table, BorderLayout.CENTER);
    
            jf.setContentPane(panel);
            jf.pack();
            jf.setLocationRelativeTo(null);
            jf.setVisible(true);
        }
    
        /**
         * 表格模型实现,表格显示数据时将调用模型中的相应方法获取数据进行表格内容的显示
         */
        public static class MyTableModel extends AbstractTableModel {
            /**
             * 表头(列名)
             */
            private Object[] columnNames = {"姓名", "语文", "数学", "英语", "总分"};
    
            /**
             * 表格所有行数据
             */
            private Object[][] rowData = {
                    {"张三", 80, 80, 80, 240},
                    {"John", 70, 80, 90, 240},
                    {"Sue", 70, 70, 70, 210},
                    {"Jane", 80, 70, 60, 210},
                    {"Joe", 80, 70, 60, 210}
            };
    
            /**
             * 返回总行数
             */
            @Override
            public int getRowCount() {
                return rowData.length;
            }
    
            /**
             * 返回总列数
             */
            @Override
            public int getColumnCount() {
                return columnNames.length;
            }
    
            /**
             * 返回列名称(表头名称),AbstractTableModel 中对该方法的实现默认是以
             * 大写字母 A 开始作为列名显示,所以这里需要重写该方法返回我们需要的列名。
             */
            @Override
            public String getColumnName(int column) {
                return columnNames[column].toString();
            }
    
            /**
             * 返回指定单元格的显示的值
             */
            @Override
            public Object getValueAt(int rowIndex, int columnIndex) {
                return rowData[rowIndex][columnIndex];
            }
        }
    
    }
    

    结果展示:

    result_01.png

    用鼠标点击相应的单元格,会发现单元格不可编辑,因为 AbstractTableModel 中对 isCellEditable(…) 方法的实现是返回 false,即单元格不可编辑。如果某些单元格需要支持编辑,可以重写 isCellEditable(…) 方法针对相应的单元格返回 true 即可。

    6. 表格数据改变的监听(TableModelListener)

    表格的数据维护,对数据的监听,都是由 表格模型(TableModel)来维护,通过设置表格模型监听器(TableModelListener),可以监听表格单元格数据的更改,表格行列的增加和移除。

    设置表格模型监听器主要代码:

    // 先获取 表格模型 对象
    TableModel tableModel = table.getModel();
    
    // 在 表格模型上 添加 数据改变监听器
    tableModel.addTableModelListener(new TableModelListener() {
        @Override
        public void tableChanged(TableModelEvent e) {
            // 第一个 和 最后一个 被改变的行(只改变了一行,则两者相同)
            int firstRow = e.getFirstRow();
            int lastRow = e.getLastRow();
    
            // 被改变的列
            int column = e.getColumn();
    
            // 事件的类型,可能的值有:
            //     TableModelEvent.INSERT   新行或新列的添加
            //     TableModelEvent.UPDATE   现有数据的更改
            //     TableModelEvent.DELETE   有行或列被移除
            int type = e.getType();
        }
    });
    

    代码实例:

    package com.xiets.swing;
    
    import javax.swing.*;
    import javax.swing.event.TableModelEvent;
    import javax.swing.event.TableModelListener;
    import javax.swing.table.AbstractTableModel;
    import javax.swing.table.TableModel;
    import java.awt.*;
    
    public class Main {
    
        public static void main(String[] args) {
            JFrame jf = new JFrame("测试窗口");
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    
            // 创建内容面板,使用边界布局
            JPanel panel = new JPanel(new BorderLayout());
    
            // 表头(列名)
            final Object[] columnNames = {"姓名", "语文", "数学", "英语", "总分"};
    
            // 表格所有行数据
            final Object[][] rowData = {
                    {"张三", 80, 80, 80, 240},
                    {"John", 70, 80, 90, 240},
                    {"Sue", 70, 70, 70, 210},
                    {"Jane", 80, 70, 60, 210},
                    {"Joe", 80, 70, 60, 210}
            };
    
            // 自定义表格模型,创建一个表格
            JTable table = new JTable(new AbstractTableModel() {
                @Override
                public int getRowCount() {
                    return rowData.length;
                }
    
                @Override
                public int getColumnCount() {
                    return rowData[0].length;
                }
    
                @Override
                public String getColumnName(int column) {
                    return columnNames[column].toString();
                }
    
                @Override
                public boolean isCellEditable(int rowIndex, int columnIndex) {
                    // 总分列的索引为 4,总分列不允许编辑,其他列允许编辑,
                    // 总分列的数值由 语文、数学、英语 这三列的值相加得出,并同步更新
                    return columnIndex != 4;
                }
    
                @Override
                public Object getValueAt(int rowIndex, int columnIndex) {
                    return rowData[rowIndex][columnIndex];
                }
    
                @Override
                public void setValueAt(Object newValue, int rowIndex, int columnIndex) {
                    // 设置新的单元格数据时,必须把新值设置到原数据数值中,
                    // 待更新UI重新调用 getValueAt(...) 获取单元格值时才能获取到最新值
                    rowData[rowIndex][columnIndex] = newValue;
                    // 设置完数据后,必须通知表格去更新UI(重绘单元格),否则显示的数据不会改变
                    fireTableCellUpdated(rowIndex, columnIndex);
                }
            });
    
            /*
             * 上面的继承 AbstractTableModel 实现自定义表格模型,功能并不完整,还有很多需要自己
             * 去实现(例如更新数据,通知UI更新,列名称获取等),建议使用 DefaultTableModel 类,
             * 该类对 TableModel 做了较为完善的实现,支持自动更新数据处理,支持UI自动更新,列名称
             * 处理,添加/移除行列等。无特殊要求不需要重写方法,直接使用即可,如下两行代码即可:
             */
            // DefaultTableModel tableModel = new DefaultTableModel(rowData, columnNames);
            // JTable table = new JTable(tableModel);
    
            // 获取 表格模型
            final TableModel tableModel = table.getModel();
            // 在 表格模型上 添加 数据改变监听器
            tableModel.addTableModelListener(new TableModelListener() {
                @Override
                public void tableChanged(TableModelEvent e) {
                    // 获取 第一个 和 最后一个 被改变的行(只改变了一行,则两者相同)
                    int firstRow = e.getFirstRow();
                    int lastRow = e.getLastRow();
    
                    // 获取被改变的列
                    int column = e.getColumn();
    
                    // 事件的类型,可能的值有:
                    //     TableModelEvent.INSERT   新行或新列的添加
                    //     TableModelEvent.UPDATE   现有数据的更改
                    //     TableModelEvent.DELETE   有行或列被移除
                    int type = e.getType();
    
                    // 针对 现有数据的更改 更新其他单元格数据
                    if (type == TableModelEvent.UPDATE) {
                        // 只处理 语文、数学、英语 这三列(索引分别为1、2、3)的分数的更改
                        if (column < 1 || column > 3) {
                            return;
                        }
                        // 遍历每一个修改的行,单个学科分数更改后同时更新总分数
                        for (int row = firstRow; row <= lastRow; row++) {
                            // 获取当前行的 语文、数学、英语 的值
                            Object chineseObj = tableModel.getValueAt(row, 1);
                            Object mathObj = tableModel.getValueAt(row, 2);
                            Object englishObj = tableModel.getValueAt(row, 3);
    
                            // 把对象值转换为数值
                            int chinese = 0;
                            try {
                                chinese = Integer.parseInt("" + chineseObj);
                            } catch (Exception ex) {
                                ex.printStackTrace();
                            }
                            int math = 0;
                            try {
                                math = Integer.parseInt("" + mathObj);
                            } catch (Exception ex) {
                                ex.printStackTrace();
                            }
                            int english = 0;
                            try {
                                english = Integer.parseInt("" + englishObj);
                            } catch (Exception ex) {
                                ex.printStackTrace();
                            }
    
                            // 重新计算新的总分数
                            int totalScore = chinese + math + english;
                            // 将新的分数值设置到总分单元格(总分数的列索引为4)
                            tableModel.setValueAt(totalScore, row, 4);
                        }
                    }
                }
            });
    
            // 把 表头 添加到容器顶部(使用普通的中间容器添加表格时,表头 和 内容 需要分开添加)
            panel.add(table.getTableHeader(), BorderLayout.NORTH);
            // 把 表格内容 添加到容器中心
            panel.add(table, BorderLayout.CENTER);
    
            jf.setContentPane(panel);
            jf.pack();
            jf.setLocationRelativeTo(null);
            jf.setVisible(true);
        }
    
    }
    

    结果展示,修改单科分数,按回车,看总分变化:

    result_03.gif

    7. 表格选择器(ListSelectionModel)

    表格数据的选择使用 ListSelectionModel 选择器模型维护,允许用户以不同的模式选中表格中的数据。

    ListSelectionModel 的使用:

    // 创建表格
    final JTable table = new JTable(...);
    
    // 设置是否允许单元格单个选中,默认为 false
    table.setCellSelectionEnabled(boolean cellSelectionEnabled);
    
    // 首先通过表格对象 table 获取选择器模型
    ListSelectionModel selectionModel = table.getSelectionModel();
    
    // 设置选择器模式,参数可能的值为:
    //     ListSelectionModel.MULTIPLE_INTERVAL_SELECTION   一次选择一个或多个连续的索引范围(默认)
    //     ListSelectionModel.SINGLE_INTERVAL_SELECTION     一次选择一个连续的索引范围
    //     ListSelectionModel.SINGLE_SELECTION              一次只能选择一个列表索引
    selectionModel.setSelectionMode(int selectionMode);
    
    // 添加选择模型监听器(选中状态改变时回调)
    selectionModel.addListSelectionListener(new ListSelectionListener() {
        @Override
        public void valueChanged(ListSelectionEvent e) {
            // 获取选中的第一行
            int selectedRow = table.getSelectedRow();
            
            // 获取选中的第一列
            int selectedRow = table.getSelectedColumn();        
            
            // 获取选中的所有行
            int[] selectedRows = table.getSelectedRows();
            
            // 获取选中的所有列
            int[] selectedColumns = table.getSelectedColumns();
        }
    });
    

    8. 单元格的渲染器(TableCellRenderer)

    单元格渲染器用于指定每一个单元格的显示样式。

    下面代码实例实现表格的 偶数行背景设置为白色,奇数行背景设置为灰色,第一列的内容水平居中对齐,最后一列的内容水平右对齐,其他列的内容水平左对齐。

    package com.xiets.swing;
    
    import javax.swing.*;
    import javax.swing.table.DefaultTableCellRenderer;
    import javax.swing.table.TableColumn;
    import java.awt.*;
    
    public class Main {
    
        public static void main(String[] args) {
            JFrame jf = new JFrame("测试窗口");
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    
            // 创建内容面板,使用边界布局
            JPanel panel = new JPanel(new BorderLayout());
    
            // 表头(列名)
            Object[] columnNames = {"姓名", "语文", "数学", "英语", "总分"};
    
            // 表格所有行数据
            Object[][] rowData = {
                    {"张三", 80, 80, 80, 240},
                    {"John", 70, 80, 90, 240},
                    {"Sue", 70, 70, 70, 210},
                    {"Jane", 80, 70, 60, 210},
                    {"Joe_01", 80, 70, 60, 210},
                    {"Joe_02", 80, 70, 60, 210},
                    {"Joe_03", 80, 70, 60, 210},
                    {"Joe_04", 80, 70, 60, 210},
                    {"Joe_05", 80, 70, 60, 210}
            };
    
            // 创建一个表格,指定 所有行数据 和 表头
            JTable table = new JTable(rowData, columnNames);
    
            // 创建单元格渲染器
            MyTableCellRenderer renderer = new MyTableCellRenderer();
    
            // 遍历表格的每一列,分别给每一列设置单元格渲染器
            for (int i = 0; i < columnNames.length; i++) {
                // 根据 列名 获取 表格列
                TableColumn tableColumn = table.getColumn(columnNames[i]);
                // 设置 表格列 的 单元格渲染器
                tableColumn.setCellRenderer(renderer);
            }
    
            // 如果需要自定义表头样式,也可以给表头设置一个自定义渲染器
            // table.getTableHeader().setDefaultRenderer(headerRenderer);
    
            // 把 表头 添加到容器顶部(使用普通的中间容器添加表格时,表头 和 内容 需要分开添加)
            panel.add(table.getTableHeader(), BorderLayout.NORTH);
            // 把 表格内容 添加到容器中心
            panel.add(table, BorderLayout.CENTER);
    
            jf.setContentPane(panel);
            jf.pack();
            jf.setLocationRelativeTo(null);
            jf.setVisible(true);
        }
    
        /**
         * 单元格渲染器,继承已实现渲染器接口的默认渲染器 DefaultTableCellRenderer
         */
        public static class MyTableCellRenderer extends DefaultTableCellRenderer {
            /**
             * 返回默认的表单元格渲染器,此方法在父类中已实现,直接调用父类方法返回,在返回前做相关参数的设置即可
             */
            @Override
            public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                // 偶数行背景设置为白色,奇数行背景设置为灰色
                if (row % 2 == 0) {
                    setBackground(Color.WHITE);
                } else {
                    setBackground(Color.LIGHT_GRAY);
                }
    
                // 第一列的内容水平居中对齐,最后一列的内容水平右对齐,其他列的内容水平左对齐
                if (column == 0) {
                    setHorizontalAlignment(SwingConstants.CENTER);
                } else if (column == (table.getColumnCount() - 1)) {
                    setHorizontalAlignment(SwingConstants.RIGHT);
                } else {
                    setHorizontalAlignment(SwingConstants.LEFT);
                }
                
                // 设置提示文本,当鼠标移动到当前(row, column)所在单元格时显示的提示文本
                setToolTipText("提示的内容: " + row + ", " + column);
    
                // PS: 多个单元格使用同一渲染器时,需要自定义的属性,必须每次都设置,否则将自动沿用上一次的设置。
    
                /*
                 * 单元格渲染器为表格单元格提供具体的显示,实现了单元格渲染器的 DefaultTableCellRenderer 继承自
                 * 一个标准的组件类 JLabel,因此 JLabel 中相应的 API 在该渲染器实现类中都可以使用。
                 *
                 * super.getTableCellRendererComponent(...) 返回的实际上是当前对象(this),即 JLabel 实例,
                 * 也就是以 JLabel 的形式显示单元格。
                 *
                 * 如果需要自定义单元格的显示形式(比如显示成按钮、复选框、内嵌表格等),可以在此自己创建一个标准组件
                 * 实例返回。
                 */
    
                // 调用父类的该方法完成渲染器的其他设置
                return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
            }
        }
    
    }
    

    结果展示:

    result_04.png

    9. 单元格数据的编辑器(TableCellEditor)

    渲染器是用于正常显示单元格数据时提供显示组件,编辑器则是用于编辑单元格数据时显示(使用)的组件。

    使用编辑器,可控制单元格内输入的内容格式,监听输入的内容变化等。

    常用的编辑组件为 JTextField(文本框),也可使用 JCheckBox(复选框)、JComboBox(文本框) 等组件作为编辑组件。

    编辑器接口为TableCellEditor,只有一个方法,即为指定的单元格提供一个编辑组件。实际使用时通常使用已实现了该接口的默认编辑器DefaultCellEditor

    下面代码使用 DefaultCellEditor 作为基类自定义一个只能输入数字的编辑器:

    package com.xiets.swing;
    
    import javax.swing.*;
    import javax.swing.table.TableColumn;
    import java.awt.*;
    
    public class Main {
    
        public static void main(String[] args) {
            JFrame jf = new JFrame("测试窗口");
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    
            // 创建内容面板,使用边界布局
            JPanel panel = new JPanel(new BorderLayout());
    
            // 表头(列名)
            Object[] columnNames = {"姓名", "语文", "数学", "英语", "总分"};
    
            // 表格所有行数据
            Object[][] rowData = {
                    {"张三", 80, 80, 80, 240},
                    {"John", 70, 80, 90, 240},
                    {"Sue", 70, 70, 70, 210},
                    {"Jane", 80, 70, 60, 210},
                    {"Joe", 80, 70, 60, 210}
            };
    
            // 创建一个表格,指定 所有行数据 和 表头
            JTable table = new JTable(rowData, columnNames);
    
            // 创建单元格编辑器,使用文本框作为编辑组件
            MyCellEditor cellEditor = new MyCellEditor(new JTextField());
    
            // 遍历表格中所有数字列,并设置列单元格的编辑器
            for (int i = 1; i < columnNames.length; i++) {
                // 根据 列名 获取 表格列
                TableColumn tableColumn = table.getColumn(columnNames[i]);
                // 设置 表格列 的 单元格编辑器
                tableColumn.setCellEditor(cellEditor);
            }
    
            // 把 表头 添加到容器顶部(使用普通的中间容器添加表格时,表头 和 内容 需要分开添加)
            panel.add(table.getTableHeader(), BorderLayout.NORTH);
            // 把 表格内容 添加到容器中心
            panel.add(table, BorderLayout.CENTER);
    
            jf.setContentPane(panel);
            jf.pack();
            jf.setLocationRelativeTo(null);
            jf.setVisible(true);
        }
    
        /**
         * 只允许输入数字的单元格编辑器
         */
        public static class MyCellEditor extends DefaultCellEditor {
    
            public MyCellEditor(JTextField textField) {
                super(textField);
            }
    
            public MyCellEditor(JCheckBox checkBox) {
                super(checkBox);
            }
    
            public MyCellEditor(JComboBox comboBox) {
                super(comboBox);
            }
    
            @Override
            public boolean stopCellEditing() {
                // 获取当前单元格的编辑器组件
                Component comp = getComponent();
    
                // 获取当前单元格编辑器输入的值
                Object obj = getCellEditorValue();
    
                // 如果当前单元格编辑器输入的值不是数字,则返回 false(表示数据非法,不允许设置,无法保存)
                if (obj == null || !obj.toString().matches("[0-9]*")) {
                    // 数据非法时,设置编辑器组件内的内容颜色为红色
                    comp.setForeground(Color.RED);
                    return false;
                }
    
                // 数据合法时,设置编辑器组件内的内容颜色为黑色
                comp.setForeground(Color.BLACK);
    
                // 合法数据交给父类处理
                return super.stopCellEditing();
            }
        }
    
    }
    

    结果展示:

    result_05.gif

    10. 表格数据的排序(RowSorter)

    JTable 还支持单击表头按该列进行升序或降序的排序,只需要给表格设置一个表格行排序器TableRowSorter(按字典顺序排序)。

    代码实例:

    package com.xiets.swing;
    
    import javax.swing.*;
    import javax.swing.table.DefaultTableModel;
    import javax.swing.table.TableModel;
    import javax.swing.table.TableRowSorter;
    import java.awt.*;
    
    public class Main {
    
        public static void main(String[] args) {
            JFrame jf = new JFrame("测试窗口");
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    
            // 创建内容面板,使用边界布局
            JPanel panel = new JPanel(new BorderLayout());
    
            // 表头(列名)
            Object[] columnNames = {"姓名", "语文", "数学", "英语", "总分"};
    
            // 表格所有行数据
            Object[][] rowData = {
                    {"张三", 80, 80, 80, 240},
                    {"John", 70, 80, 90, 240},
                    {"Sue", 70, 70, 70, 210},
                    {"Jane", 80, 70, 60, 210},
                    {"Joe", 80, 70, 60, 210}
            };
    
            // 创建 表格模型,指定 所有行数据 和 表头
            TableModel tableModel = new DefaultTableModel(rowData, columnNames);
    
            // 使用 表格模型 创建 表格
            JTable table = new JTable(tableModel);
    
            // 使用 表格模型 创建 行排序器(TableRowSorter 实现了 RowSorter)
            RowSorter<TableModel> rowSorter = new TableRowSorter<TableModel>(tableModel);
    
            // 给 表格 设置 行排序器
            table.setRowSorter(rowSorter);
    
            // 把 表头 添加到容器顶部(使用普通的中间容器添加表格时,表头 和 内容 需要分开添加)
            panel.add(table.getTableHeader(), BorderLayout.NORTH);
            // 把 表格内容 添加到容器中心
            panel.add(table, BorderLayout.CENTER);
    
            jf.setContentPane(panel);
            jf.pack();
            jf.setLocationRelativeTo(null);
            jf.setVisible(true);
        }
    
    }
    

    结果展示:

    result_06.gif

    展开全文
  • JavaSwing_4.2: JDialog、JOptionPane(对话框)

    万次阅读 多人点赞 2017-07-23 22:42:56
    JDialog,对话框。使用 JDialog 类可以创建自定义有的对话框,或者调用 ...JOptionPane是 JavaSwing 内部已实现好的,以静态方法的形式提供调用,能够快速方便的弹出要求用户提供值或向其发出通知的标准对话框。
  • Java_Swing(一)——Swing介绍

    万次阅读 2019-06-03 23:49:27
    Swing组件的出现是为了解决AWT组件的移植性问题,同时提供更多的企业级应用程序所需要的界面功能,Swing组件中的类主要包含在javax.swing包中,JDK1.2以后的版本都包含Swing类库。 与AWT组件不同,javax.swing包中...
  • 目录Swing简介Swing类库结构SwingSwing容器 Swing简介 Swing是新一代的图形管理工具。使用Swing来开发图形界面比AWT更优秀,因为Swing是一种轻量级组件,它采用纯Java实现,不再依赖本地平台的图形界面,所以可以...
  • Swing实战

    千次阅读 2019-07-24 21:34:05
    一第1个Swing应用 1代码 import javax.swing.JFrame; public class TestSwing { public static void main( String[] args ) { JFrame frame = new JFrame("Hello Swing"); frame.setSize(300, 20...
  • Java Swing(一)Swing初识

    千次阅读 2018-12-31 16:17:04
    Swing初识 参考资料: [1]王鹏,何昀峰.JavaSwing图形界面开发与案例详解[M].北京:清华大学出版社,2008:407. 文章目录Swing初识1. 什么是Java Swing2. Java Swing的结构3. Java Swing HelloWorld4. 使用IDE开发...
  • Swing算法

    千次阅读 2019-08-09 16:26:35
    Swing算法 概念:不同于传统基于“点”的节点亲密度(proximity)计算方式,如:Common Neighbors, Adamic/Adar, Cosine Similarity, Jaccard Similarity, Wb-cosine, Rooted PageRank等,Swing会考虑网络结构信息,...
  • Swing Datepicker

    千次下载 热门讨论 2009-02-19 13:09:07
    此日历控件在www.eltima.com上给的Swing library4.0的jar包里提出出来 并重新封装在DatePicker类中 将必要的函数由私有状态提升为公开状态.具体使用方法可见doc.doc文件
  • javafx 和swing 我刚刚完成了对使用Swing的应用程序组件的重写,现在正在使用JavaFX,最后得到了与更大的swing应用程序集成的JavaFX组件。 这是一个很大的应用程序,重写花了我一段时间,最后一切都很好,我很高兴...
  • Swing学习22:Java Swing JTable

    千次阅读 2020-03-13 15:37:19
    表格是 Swing 新增加的组件,主要功能是把数据以二维表格的形式显示出来,并且允许用户对表格中的数据进行编辑。表格组件是最复杂的组件之一,它的表格模型功能非常强大、灵活而易于执行。由于篇幅有限,本节只介绍...
  • Swing学习15:Java Swing JSlider

    千次阅读 2020-03-13 15:12:58
    在前面的章节中,我们介绍了 Swing 设计简单界面所需的窗口、布局组件以及如何响应事件。Swing 还提供了很多高级组件,如菜单栏、工具栏、文件选择器、表格以及树等。使用这些高级组件可以实现更为复杂的布局,也...
  • Swing的学习教程链接:Java Swing教程:30分钟玩转Swing界面设计。 图片处理的参考文章:https://blog.csdn.net/qq_36511401/category_9467762.html 一、介绍 1、SwingSwing是一个用于开发Java应用程序用户...
  • Swing学习06:Java Swing JTextField

    千次阅读 2020-03-12 16:47:10
    Swing 中使用 JTextField 类实现一个单行文本框,它允许用户输入单行的文本信息。该类的常用构造方法如下: JTextField():创建一个默认的文本框。 JTextField(String text):创建一个指定初始化文本信息的文本框。...
  • Swing学习09:Java Swing JRadioButton

    千次阅读 2020-03-13 14:53:32
    Swing 中 JRadioButton 类实现单选按钮,它与 JCheckBox 一样都是从 JToggleButton 类派生出来的。JRadioButton 通常位于一个 ButtonGroup 按钮组中,不在按钮组中的 JRadioButton 也就失去了单选按钮的意义。 在同...
  • Swing学习07:Java Swing JTextArea

    千次阅读 2020-03-12 16:51:21
    Swing 中使用 JTextArea 类实现一个文本域,其常用构造方法如下。 JTextArea():创建一个默认的文本域。 JTextArea(int rows,int columns):创建一个具有指定行数和列数的文本域。 JTextArea(String text):创建...
  • Swing学习08:Java Swing JCheckBox

    千次阅读 2020-03-13 14:51:57
    Swing 中使用 JCheckBox 类实现复选框,该类的常用构造方法如下。 JCheckBox():创建一个默认的复选框,在默认情况下既未指定文本,也未指定图像,并且未被选择。 JCheckBox(String text):创建一个指定文本的复选框...
  • Swing学习11:Java Swing JList

    千次阅读 2020-03-13 14:58:32
    列表框与下拉列表的区别不仅仅表现在外观上,当激活下拉列表时,会出现下拉列表框中的内容。但列表框只是在窗体系上占据固定的大小,如果需要列表框具有...Swing 中使用 JList 类来表示列表框,该类的常用构造方法如...
  • Java swing组件介绍

    万次阅读 多人点赞 2018-07-29 14:58:47
    本文链接: ... Java Swing 图形界面开发(目录) 1. Swing简介 Swing 是 Java 为图形界面应用开发提供的一组工具包,是 Java 基础类的一部分。 Swing 包含了构建图...
  • Swing ——Swing基本结构

    千次阅读 2013-12-12 22:51:02
    Swing原先是利用MVC(Model -View -Controller)的概念衍生而出。 Swing组件的Model可分成3类。   Swing原先是利用MVC(Model -View -Controller)的概念衍生而出 ...
  • Java学习指南 Swing项目实战篇

    千人学习 2019-08-18 21:06:05
    一、课程简介 本课程是基于Java Swing 技术的项目实战教程,每章为一个项目实例。前置课程为 Swing入门篇 和 Swing高级篇。 以下项目中,界面部分使用 Swing 实现,为了实现项目需求,一般还会结合使用 Swing 之外的...
  • Java学习指南(Swing入门篇)

    千人学习 2019-03-19 22:49:50
    ☆ Java程序员居家旅行必备课程 ☆ Java学习指南系列的第3篇,承接高级语法篇,介绍基于Java Swing的GUI界面程序开发的技术。 Swing系列教程分为两篇:(1) Swing入门篇 (2) Swing高级篇。 通过本篇的训练,学员可以...
  • Swing程序设计

    千次阅读 2019-09-25 20:30:29
    Swing 概述、常用窗体
  • 本节详细介绍 Swing 中文件选择器和颜色选择器的使用。 文章目录文件选择器颜色选择器 文件选择器 文件选择器为用户能够操作系统文件提供了桥梁。swing 中使用 JFileChooser 类实现文件选择器,该类常用的构造方法...
  • Java Swing

    万次阅读 2017-03-22 21:38:09
    容器是放置界面组件的地方,在Swing中提供了两个容器,一个是Jframe,它是一个最基本的窗口容器,一个是Jpanel,也称为面板,面板可以放置在Jframe容器或者Applet上。 常用的布局方式是首先设计几个Jpanel面板,再将...
  • Eclipse中swing插件

    热门讨论 2011-09-22 14:21:56
    Eclipse中swing插件Eclipse中swing插件Eclipse中swing插件
  • Swing笔记

    2012-07-28 11:25:49
    swing中控制按钮大小 Button bt = new Button(); bt.setPreferredSize(new Dimension(100,30)); swing选项卡 JTablePanle jtp; JPanle jp1,jp2,jp3; jtp = new JTablePanle(); jp1 = new JPan

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,439
精华内容 28,175
关键字:

swing