Swing概述

  1. 前一章己经介绍过AWT和Swing 的关系 ， 因此不难知道 : 实际使用 Java 开发图形界面程序时 ，很少使用 AWT 组件，绝大部分时候都是用 Swing 组件开发的 。 Swing是由100%纯 Java实现的，不再依赖于本地平台的 GUI， 因此可以在所有平台上都保持相同的界面外观。独立于本地平台的Swing组件被称为**轻量级组件**;而依赖于本地平台的 AWT 组件被称为**重量级组件**。    <br />由于 Swing 的所有组件完全采用 Java 实现，不再调用本地平台的 GUI，所以导致 Swing 图形界面的显示速度要比 AWT 图形界面的显示速度慢一些，但相对于快速发展的硬件设施而言，这种微小的速度差别无妨大碍。<br />**使用Swing的优势:**    <br />1. Swing 组件不再依赖于本地平台的 GUI，无须采用各种平台的 GUI 交集 ，因此 Swing 提供了大量图形界面组件 ， 远远超出了 AWT 所提供的图形界面组件集。<br />2. Swing 组件不再依赖于本地平台 GUI ，因此不会产生与平台 相关的 bug 。    <br />3. Swing 组件在各种平台上运行时可以保证具有相同的图形界面外观。<br />Swing 提供的这些优势，让 Java 图形界面程序真正实现了 " Write Once, Run Anywhere" 的 目标。<br />**Swing的特征：**<br />1. Swing 组件采用 MVC(Model-View-Controller， 即模型一视图一控制器)设计模式：
  1. 模型(Model): 用于维护组件的各种状态；
  3.     视图(View): 是组件的可视化表现；
  5.     控制器(Controller):用于控制对于各种事件、组件做出响应 。
  7.     当模型发生改变时，它会通知所有依赖它的视图，视图会根据模型数据来更新自己。Swing使用UI代理来包装视图和控制器， 还有一个模型对象来维护该组件的状态。例如，按钮JButton有一个维护其状态信息的模型ButtonModel对象 。 Swing组件的模型是自动设置的，因此一般都使用JButton，而无须关心ButtonModel对象。
  9. 2. Swing在不同的平台上表现一致，并且有能力提供本地平台不支持的显示外观 。由于 Swing采用 MVC 模式来维护各组件，所以 当组件的外观被改变时，对组件的状态信息(由模型维护)没有任何影响 。因 此，Swing可以使用插拔式外观感觉 (Pluggable Look And Feel, PLAF)来控制组件外观，使得 Swing图形界面在同一个平台上运行时能拥有不同的外观，用户可以选择自己喜欢的外观 。相比之下，在 AWT 图形界面中，由于控制组件外观的对等类与具体平台相关 ，因此 AWT 组件总是具有与本地平台相同的外观 。

Swing基本组件的用法

Swing组件层次

Swing组件继承体系图：

Swing组件继承体系.png
大部分Swing 组件都是 JComponent抽象类的直接或间接子类(并不是全部的 Swing 组件)，JComponent 类定义了所有子类组件的通用方法 ，JComponent 类是 AWT 里 java.awt. Container 类的子类 ，这也是 AWT 和 Swing 的联系之一。 绝大部分 Swing 组件类继承了 Container类，所以Swing 组件都可作为 容器使用 ( JFrame继承了Frame 类)。
Swing组件和AWT组件的对应关系：
大部分情况下，只需要在AWT组件的名称前面加个J，就可以得到其对应的Swing组件名称，但有几个例外：
1. JComboBox: 对应于 AWT 里的 Choice 组件，但比 Choice 组件功能更丰富 。
2. JFileChooser: 对应于 AWT 里的 FileDialog 组件 。
3. JScrollBar: 对应于 AWT 里的 Scrollbar 组件，注意两个组件类名中 b 字母的大小写差别。
4. JCheckBox : 对应于 AWT 里的 Checkbox 组件， 注意两个组件类名中 b 字母的大小 写差别 。
5. JCheckBoxMenultem: 对应于 AWT 里的 CheckboxMenuItem 组件，注意两个组件类名中 b字母的大小写差别。
Swing组件按照功能来分类：
1.顶层容器: JFrame、JApplet、JDialog 和 JWindow 。
2. 中间容器: JPanel 、 JScrollPane 、 JSplitPane 、 JToolBar 等 。
3. 特殊容器:在用户界面上具有特殊作用的中间容器，如 JIntemalFrame 、 JRootPane 、 JLayeredPane和 JDestopPane 等 。
4. 基本组件 : 实现人机交互的组件，如 JButton、 JComboBox 、 JList、 JMenu、 JSlider 等 。
5. 不可编辑信息的显示组件:向用户显示不可编辑信息的组件，如JLabel 、 JProgressBar 和 JToolTip等。
6. 可编辑信息的显示组件:向用户显示能被编辑的格式化信息的组件，如 JTable 、 JTextArea 和JTextField 等 。
7. 特殊对话框组件:可以直接产生特殊对话框的组件 ， 如 JColorChooser 和 JFileChooser 等。

AWT组件的Swing实现

  1. Swing 为除 Canvas 之外的所有 AWT 组件提供了相应的实现，Swing 组件比 AWT 组件的功能更加强大。相对于 AWT 组件， Swing 组件具有如下 4 个额外的功能 :
  1. 可以为 Swing 组件设置提示信息。使用 setToolTipText()方法，为组件设置对用户有帮助的提示信息 。
  2. 很多 Swing 组件如按钮、标签、菜单项等，除使用文字外，还可以使用图标修饰自己。为了允许在 Swing 组件中使用图标， Swing为Icon 接口提供了 一个实现类: Imagelcon ，该实现类代表一个图像图标。
  3. 支持插拔式的外观风格。每个 JComponent 对象都有一个相应的 ComponentUI 对象，为它完成所有的绘画、事件处理、决定尺寸大小等工作。 ComponentUI 对象依赖当前使用的 PLAF ， 使用 UIManager.setLookAndFeel()方法可以改变图形界面的外观风格 。

  4. 支持设置边框。Swing 组件可以设置一个或多个边框。 Swing 中提供了各式各样的边框供用户边 用，也能建立组合边框或自己设计边框。 一种空白边框可以用于增大组件，同时协助布局管理器对容器中的组件进行合理的布局。

    每个 Swing 组件都有一个对应的UI 类，例如 JButton组件就有一个对应的 ButtonUI 类来作为UI代理 。每个 Swing组件的UI代理的类名总是将该 Swing 组件类名的 J 去掉，然后在后面添加 UI 后缀 。 UI代理类通常是一个抽象基类 ， 不同的 PLAF 会有不同的UI代理实现类 。 Swing 类库中包含了几套UI代理,分别放在不同的包下， 每套UI代理都几乎包含了所有 Swing组件的 ComponentUI实现，每套这样的实现都被称为一种PLAF 实现 。以 JButton 为例，其 UI 代理的继承层次下图：
    ComponentUI.png
    如果需要改变程序的外观风格， 则可以使用如下代码： ```java //容器： JFrame jf = new JFrame();

try {

  1. //设置外观风格
  2. UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
  4. //刷新jf容器及其内部组件的外观
  5. SwingUtilities.updateComponentTreeUI(jf);

} catch (Exception e) { e.printStackTrace(); }

  1. **案例：**<br />使用Swing组件，实现下图中的界面效果：<br />![swing_c_1.jpg](https://cdn.nlark.com/yuque/0/2021/jpeg/22782459/1634573287309-e631bdaa-8ef2-401c-9830-cb04b1120480.jpeg#clientId=uaaa5a029-81e7-4&from=drop&id=u3ab4430c&originHeight=399&originWidth=751&originalType=binary&ratio=1&rotation=0&showTitle=false&size=43335&status=done&style=none&taskId=u57842ddc-55fc-4f3c-b2dd-199a898c7b8&title=)<br />![swing_c_2.jpg](https://cdn.nlark.com/yuque/0/2021/jpeg/22782459/1634573296758-e5866434-bc4e-4c71-94ce-fbd8e569f9ee.jpeg#clientId=uaaa5a029-81e7-4&from=drop&id=ufddc7c8b&originHeight=399&originWidth=751&originalType=binary&ratio=1&rotation=0&showTitle=false&size=62581&status=done&style=none&taskId=uaacbd75c-a5a7-47c3-8585-cecbc1f2e92&title=)<br />**演示代码：**
  2. ```java
  3. import cn.itcast.swing.util.ImagePathUtil;
  5. import javax.swing.*;
  6. import java.awt.*;
  7. import java.awt.event.ActionEvent;
  8. import java.awt.event.ActionListener;
  9. import java.awt.event.InputEvent;
  11. public class SwingComponentDemo {
  14.     JFrame f = new JFrame("测试swing基本组件");
  16.     //定义一个按钮，并为其指定图标
  17.     Icon okIcon = new ImageIcon(ImagePathUtil.getRealPath("2\\ok.png"));
  18.     JButton ok = new JButton("确定",okIcon);
  20.     //定义一个单选按钮，初始处于选中的状态
  21.     JRadioButton male = new JRadioButton("男",true);
  22.     //定义一个单选按钮，初始处于选中状态
  23.     JRadioButton female = new JRadioButton("女",false);
  25.     //定义一个ButtonGroup，把male和female组合起来，实现单选
  26.     ButtonGroup bg  = new ButtonGroup();
  28.     //定义一个复选框，初始处于没有选中状态
  29.     JCheckBox married = new JCheckBox("是否已婚？",false);
  31.     //定义一个数组存储颜色
  32.     String[] colors = { "红色", "绿色 " , "蓝色 " };
  34.     //定义一个下拉选择框，展示颜色
  35.     JComboBox<String> colorChooser = new JComboBox<String>(colors);
  37.     //定一个列表框，展示颜色
  38.     JList<String> colorList = new JList<String>(colors);
  40.     //定义一个8行20列的多行文本域
  41.     JTextArea ta = new JTextArea(8,20);
  43.     //定义一个40列的单行文本域
  44.     JTextField name = new JTextField(40);
  46.     //定义菜单条
  47.     JMenuBar mb = new JMenuBar();
  49.     //定义菜单
  50.     JMenu file = new JMenu("文件");
  51.     JMenu edit = new JMenu("编辑");
  53.     //创建菜单项，并指定图标
  54.     JMenuItem newItem = new JMenuItem("新建",new ImageIcon(ImagePathUtil.getRealPath("2\\new.png")));
  55.     JMenuItem saveItem = new JMenuItem("保存",new ImageIcon(ImagePathUtil.getRealPath("2\\save.png")));
  56.     JMenuItem exitItem = new JMenuItem("退出",new ImageIcon(ImagePathUtil.getRealPath("2\\exit.png")));
  58.     JCheckBoxMenuItem autoWrap = new JCheckBoxMenuItem("自动换行");
  59.     JMenuItem copyItem = new JMenuItem("复制",new ImageIcon(ImagePathUtil.getRealPath("2\\copy.png")));
  60.     JMenuItem pasteItem = new JMenuItem("粘贴",new ImageIcon(ImagePathUtil.getRealPath("2\\paste.png")));
  62.     //定义二级菜单，将来会添加到编辑中
  63.     JMenu format = new JMenu("格式");
  64.     JMenuItem commentItem = new JMenuItem("注释");
  65.     JMenuItem cancelItem = new JMenuItem("取消注释");
  67.     //定义一个右键菜单，用于设置程序的外观风格
  68.     JPopupMenu pop = new JPopupMenu();
  70.     //定义一个ButtongGroup对象，用于组合风格按钮，形成单选
  71.     ButtonGroup flavorGroup = new ButtonGroup();
  73.     //定义五个单选按钮菜单项，用于设置程序风格
  74.     JRadioButtonMenuItem metalItem = new JRadioButtonMenuItem("Metal 风格",true);
  75.     JRadioButtonMenuItem nimbusItem = new JRadioButtonMenuItem("Nimbus 风格",true);
  76.     JRadioButtonMenuItem windowsItem = new JRadioButtonMenuItem("Windows 风格",true);
  77.     JRadioButtonMenuItem classicItem = new JRadioButtonMenuItem("Windows 经典风格",true);
  78.     JRadioButtonMenuItem motifItem = new JRadioButtonMenuItem("Motif 风格",true);
  82.     //初始化界面
  83.     public void init(){
  85.         //------------------------组合主区域------------------------
  86.         //创建一个装载文本框和按钮的JPanel
  87.         JPanel bottom = new JPanel();
  88.         bottom.add(name);
  89.         bottom.add(ok);
  91.         f.add(bottom, BorderLayout.SOUTH);
  93.         //创建一个装载下拉选择框、三个JChekBox的JPanel
  94.         JPanel checkPanel = new JPanel();
  95.         checkPanel.add(colorChooser);
  96.         bg.add(male);
  97.         bg.add(female);
  99.         checkPanel.add(male);
  100.         checkPanel.add(female);
  101.         checkPanel.add(married);
  103.         //创建一个垂直排列的Box，装载checkPanel和多行文本域
  104.         Box topLeft = Box.createVerticalBox();
  106.         //使用JScrollPane作为普通组件的JViewPort
  107.         JScrollPane taJsp = new JScrollPane(ta);
  108.         topLeft.add(taJsp);
  109.         topLeft.add(checkPanel);
  111.         //创建一个水平排列的Box，装载topLeft和colorList
  112.         Box top = Box.createHorizontalBox();
  113.         top.add(topLeft);
  114.         top.add(colorList);
  116.         //将top Box 添加到窗口的中间
  117.         f.add(top);
  119.         //---------------------------组合菜单条----------------------------------------------
  120.         //为newItem添加快捷键 ctrl+N
  121.         newItem.setAccelerator(KeyStroke.getKeyStroke('N', InputEvent.CTRL_MASK));
  122.         newItem.addActionListener(new ActionListener() {
  123.             @Override
  124.             public void actionPerformed(ActionEvent e) {
  125.                 ta.append("用户点击了“新建”菜单\n");
  126.             }
  127.         });
  130.         //为file添加菜单项
  131.         file.add(newItem);
  132.         file.add(saveItem);
  133.         file.add(exitItem);
  135.         //为edit添加菜单项
  136.         edit.add(autoWrap);
  137.         edit.addSeparator();
  138.         edit.add(copyItem);
  139.         edit.add(pasteItem);
  140.         //为commentItem添加提示信息
  141.         commentItem.setToolTipText("将程序代码注释起来");
  143.         //为format菜单添加菜单项
  144.         format.add(commentItem);
  145.         format.add(cancelItem);
  147.         //给edit添加一个分隔符
  148.         edit.addSeparator();
  150.         //把format添加到edit中形成二级菜单
  151.         edit.add(format);
  153.         //把edit file 添加到菜单条中
  154.         mb.add(file);
  155.         mb.add(edit);
  157.         //把菜单条设置给窗口
  158.         f.setJMenuBar(mb);
  160.         //------------------------组合右键菜单-----------------------------
  162.         flavorGroup.add(metalItem);
  163.         flavorGroup.add(nimbusItem);
  164.         flavorGroup.add(windowsItem);
  165.         flavorGroup.add(classicItem);
  166.         flavorGroup.add(motifItem);
  168.         //给5个风格菜单创建事件监听器
  169.         ActionListener flavorLister = new ActionListener() {
  170.             @Override
  171.             public void actionPerformed(ActionEvent e) {
  172.                 String command = e.getActionCommand();
  173.                 try {
  174.                     changeFlavor(command);
  175.                 } catch (Exception e1) {
  176.                     e1.printStackTrace();
  177.                 }
  178.             }
  179.         };
  181.         //为5个风格菜单项注册监听器
  182.         metalItem.addActionListener(flavorLister);
  183.         nimbusItem.addActionListener(flavorLister);
  184.         windowsItem.addActionListener(flavorLister);
  185.         classicItem.addActionListener(flavorLister);
  186.         motifItem.addActionListener(flavorLister);
  188.         pop.add(metalItem);
  189.         pop.add(nimbusItem);
  190.         pop.add(windowsItem);
  191.         pop.add(classicItem);
  192.         pop.add(motifItem);
  194.         //调用ta组件的setComponentPopupMenu即可设置右键菜单，无需使用事件
  195.         ta.setComponentPopupMenu(pop);
  197.         // 设置关闭窗口时推出程序
  198.         f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  200.         //设置jFrame最佳大小并可见
  201.         f.pack();
  202.         f.setVisible(true);
  205.     }
  207.     //定义一个方法，用于改变界面风格
  208.     private void changeFlavor(String command) throws Exception{
  209.         switch (command){
  210.             case "Metal 风格":
  211.                 UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
  212.                 break;
  213.             case "Nimbus 风格":
  214.                 UIManager.setLookAndFeel("javax.swing.plaf.nimbus.NimbusLookAndFeel");
  215.                 break;
  216.             case "Windows 风格":
  217.                 UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
  218.                 break;
  219.             case "Windows 经典风格":
  220.                 UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsClassicLookAndFeel");
  221.                 break;
  222.             case "Motif 风格":
  223.                 UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");
  224.                 break;
  225.         }
  227.         //更新f窗口内顶级容器以及所有组件的UI
  228.         SwingUtilities.updateComponentTreeUI(f.getContentPane());
  229.         //更新mb菜单条及每部所有组件UI
  230.         SwingUtilities.updateComponentTreeUI(mb);
  231.         //更新右键菜单及内部所有菜单项的UI
  232.         SwingUtilities.updateComponentTreeUI(pop);
  233.     }
  236.     public static void main(String[] args) {
  237.         new SwingComponentDemo().init();
  238.     }
  240. }

注意细节：
1.Swing菜单项指定快捷键时必须通过组件名.setAccelerator(keyStroke.getKeyStroke(“大写字母”,InputEvent.CTRL_MASK))方法来设置，其中KeyStroke代表一次击键动作，可以直接通过按键对应字母来指定该击键动作 。
2.更新JFrame的风格时，调用了SwingUtilities.updateComponentTreeUI(f.getContentPane());这是因为如果直接更新 JFrame 本身 ，将会导致 JFrame 也被更新， JFrame 是一个特殊的容器 ， JFrame 依然部分依赖于本地平台的图形组件 。如果强制 JFrame 更新，则有可能导致该窗口失去标题栏和边框 。
3.给组件设置右键菜单，不需要使用监听器，只需要调用setComponentPopupMenu()方法即可，更简单。
4.关闭JFrame窗口，也无需监听器，只需要调用setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)方法即可，更简单。
5.如果需要让某个组件支持滚动条，只需要把该组件放入到JScrollPane中，然后使用JScrollPane即可。

JColorChooser 和JFileChooser

Swing提供了JColorChooser和JFileChooser这两种对话框，可以很方便的完成颜色的选择和本地文件的选择。

JColorChooser

JColorChooser 用于创建颜色选择器对话框 ， 该类的用法非常简单，只需要调用它的静态方法就可以快速生成一个颜色选择对话框：

  1. public static Color showDialog(Component component, String title,Color initialColor)
  3. /*
  4.     参数：
  5.         componet:指定当前对话框的父组件
  6.         title：当前对话框的名称
  7.         initialColor：指定默认选中的颜色
  9.     返回值：
  10.         返回用户选中的颜色
  11. */

案例：
使用颜色选择器，完成下图功能：
点击按钮，改变文本域的背景色
JColorChooser.jpg
演示代码：

  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.ActionEvent;
  5. public class JColorChooserDemo {
  7.     JFrame jFrame = new JFrame("测试颜色选择器");
  9.     JTextArea jta = new JTextArea("我爱中华",6,30);
  11.     JButton button = new JButton(new AbstractAction("改变文本框的本景色"){
  13.         @Override
  14.         public void actionPerformed(ActionEvent e) {
  16.             //弹出颜色选择器
  17.             Color result = JColorChooser.showDialog(jFrame, "颜色选择器", Color.WHITE);
  18.             jta.setBackground(result);
  19.         }
  20.     });
  22.     public void init(){
  23.         jFrame.add(jta);
  25.         jFrame.add(button,BorderLayout.SOUTH);
  27.         jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  28.         jFrame.pack();
  29.         jFrame.setVisible(true);
  30.     }
  32.     public static void main(String[] args) {
  33.         new JColorChooserDemo().init();
  34.     }
  36. }

JFileChooser

JFileChooser 的功能与AWT中的 FileDialog 基本相似，也是用于生成”打开文件”、”保存文件 “对话框。与 FileDialog 不同的是 ， JFileChooser 无须依赖于本地平台的 GUI ， 它由 100%纯 Java 实现 ， 在所有平台 上具有完全相同的行为，并可以在所有平台上具有相同的外观风格。
JFileChooser使用步骤：

  1. 创建JFileChooser对象：

    1. JFileChooser chooser = new JFileChooser("D:\\a");//指定默认打开的本地磁盘路径

  2. 调用JFileChooser的一系列可选方法，进行初始化

    1. setSelectedFile(File file)/setSelectedFiles(File[] selectedFiles):设定默认选中的文件
    2. setMultiSelectionEnabled(boolean b)：设置是否允许多选，默认是单选
    3. setFileSelectionMode(int mode)：设置可以选择内容，例如文件、文件夹等，默认只能选择文件

  3. 打开文件对话框

    1. showOpenDialog(Component parent):打开文件加载对话框，并指定父组件
    2. showSaveDialog(Component parent):打开文件保存对话框，并指定父组件

  4. 获取用户选择的结果

    1. File getSelectedFile():获取用户选择的一个文件
    2. File[] getSelectedFiles():获取用户选择的多个文件

    案例：
    使用JFileChooser完成下图效果：
    ImageIODemo.jpg
    演示代码： ```java import javax.imageio.ImageIO; import javax.swing.; import java.awt.; import java.awt.event.ActionEvent; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException;

public class JFileChooserDemo {

  1. //创建窗口对象
  2. JFrame jf = new JFrame("测试JFileChooser");
  4. //创建打开文件对话框
  5. JFileChooser chooser = new JFileChooser(".");
  7. //创建菜单条
  8. JMenuBar jmb = new JMenuBar();
  9. //创建菜单
  10. JMenu jMenu = new JMenu("文件");
  11. //创建菜单项
  12. JMenuItem open = new JMenuItem(new AbstractAction("打开"){
  14.     @Override
  15.     public void actionPerformed(ActionEvent e) {
  16.         chooser.showOpenDialog(jf);
  17.         File imageFile = chooser.getSelectedFile();
  18.         try {
  19.             image = ImageIO.read(imageFile);
  20.             drawArea.repaint();
  21.         } catch (IOException e1) {
  22.             e1.printStackTrace();
  23.         }
  24.     }
  25. });
  27. JMenuItem save = new JMenuItem(new AbstractAction("另存为"){
  29.     @Override
  30.     public void actionPerformed(ActionEvent e) {
  31.         chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
  32.         chooser.showSaveDialog(jf);
  33.         File dir = chooser.getSelectedFile();
  34.         try {
  35.             ImageIO.write(image,"jpeg",new File(dir,"a.jpg"));
  36.         } catch (Exception e1) {
  37.             e1.printStackTrace();
  38.         }
  39.     }
  40. });
  42. //用来记录用户选择的图片
  43. BufferedImage image;
  45. //显示图片
  46. class MyCanvas extends JPanel{
  47.     @Override
  48.     public void paint(Graphics g) {
  49.         if (image!=null){
  50.             g.drawImage(image,0,0,null);
  51.         }
  52.     }
  53. }
  55. JPanel drawArea = new MyCanvas();
  57. public void init(){
  58.     //设置图片显示区域大小
  59.     drawArea.setPreferredSize(new Dimension(500,300));
  60.     jf.add(drawArea);
  62.     //组装并设置菜单条
  63.     jMenu.add(open);
  64.     jMenu.add(save);
  65.     jmb.add(jMenu);
  66.     jf.setJMenuBar(jmb);
  68.     //显示jf
  69.     jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  70.     jf.pack();
  71.     jf.setVisible(true);
  72. }
  74. public static void main(String[] args) {
  75.     new JFileChooserDemo().init();
  76. }

}

  1. <a name="BkgDR"></a>
  2. ### 使用JOptionPane
  3. <a name="xs8jK"></a>
  4. #### 基本概述
  5. 通过 JOptionPane 可以非常方便地创建一些简单的对话框， Swing 已经为这些对话框添加了相应的组件，无须程序员手动添加组件 。 JOptionPane 提供了如下 4 个方法来创建对话框 。
  7. | **方法名称** | **方法功能** |
  8. | --- | --- |
  9. | showMessageDialog/showInternalMessageDialog | 消息对话框 ，告知用户某事己发生 ， 用户只能单击"确定"按钮 ， 类似于 JavaScript 的 alert 函数 。 |
  10. | showConfirmDialog/showInternalConfirmDialog | 确认对话框，向用户确认某个问题，用户可以选择 yes 、 no ~ cancel 等选项 。 类似于 JavaScript 的 comfirm 函数 。该方法返回用户单击了 哪个按钮 |
  11. | showInputDialog/showInternalInputDialog | 输入对话框，提示要求输入某些信息，类似于 JavaScript的 prompt 函数。该方法返回用户输入的字符串 。 |
  12. | showOptionDialog/showInternalOptionDialog | 自定义选项对话框 ，允许使用自 定义选项 ，可以取代showConfirmDialog 所产生的对话框，只是用起来更复杂 。 |
  14. 上述方法都有都有很多重载形式，选择其中一种最全的形式，参数解释如下：
  15. ```java
  16. showXxxDialog(Component parentComponent,
  17.         Object message, 
  18.         String title, 
  19.         int optionType, 
  20.         int messageType,
  21.             Icon icon,
  22.         Object[] options, 
  23.         Object initialValue)
  24. --参数解释：
  25. parentComponent：当前对话框的父组件
  26. message：对话框上显示的信息，信息可以是字符串、组件、图片等
  27. title：当前对话框的标题
  28. optionType：当前对话框上显示的按钮类型：DEFAULT_OPTION、YES_NO_OPTION、YES_NO_CANCEL_OPTION、OK_CANCEL_OPTION
  29. messageType:当前对话框的类型:ERROR_MESSAGE、INFORMATION_MESSAGE、WARNING_MESSAGE、QUESTION_MESSAGE、PLAIN_MESSAGE
  30. icon:当前对话框左上角的图标
  31. options:自定义下拉列表的选项
  32. initialValue:自定义选项中的默认选中项

当用户与对话框交互结束后，不同类型对话框的返回值如下：

  • showMessageDialog: 无返回值 。
  • showlnputDialog: 返回用户输入或选择的字符串 。
  • showConfirmDialog: 返回 一个整数代表用户选择的选项 。
  • showOptionDialog : 返回 一个整数代表用户选择的选项，如果用户选择第一项，则返回 0; 如果选择第二项，则返回1……依此类推 。

对 showConfirmDialog 所产生的对话框，有如下几个返回值：

  • YES OPTION: 用户 单击了 “是”按钮后返回 。
  • NO OPTION: 用 户单击了”否”按钮后返回 。
  • CANCEL OPTION: 用户单击了”取消”按钮后返回 。
  • OK OPTION : 用户单击了”确定”按钮后返回 。
  • CLOSED OPTION: 用户 单击了对话框右上角的 “ x” 按钮后返回。

    四种对话框演示

    消息对话框：
    消息提示框.jpg ```java import cn.itcast.swing.util.ImagePathUtil;

import javax.swing.; import java.awt.; import java.awt.event.ActionEvent;

public class MessageDialogTest {

  1. JFrame jf = new JFrame("测试消息对话框");
  3. JTextArea jta = new JTextArea(6, 30);
  5. JButton btn = new JButton(new AbstractAction("弹出消息对话框") {
  7.     @Override
  8.     public void actionPerformed(ActionEvent e) {
  9.         //JOptionPane.showMessageDialog(jf, jta.getText(), "消息对话框", JOptionPane.ERROR_MESSAGE);
  10.         //JOptionPane.showMessageDialog(jf, jta.getText(), "消息对话框", JOptionPane.INFORMATION_MESSAGE);
  11.         //JOptionPane.showMessageDialog(jf, jta.getText(), "消息对话框", JOptionPane.WARNING_MESSAGE);
  12.         //JOptionPane.showMessageDialog(jf, jta.getText(), "消息对话框", JOptionPane.QUESTION_MESSAGE);
  13.         //JOptionPane.showMessageDialog(jf, jta.getText(), "消息对话框", JOptionPane.PLAIN_MESSAGE);
  14.         JOptionPane.showMessageDialog(jf, jta.getText(), "消息对话框", JOptionPane.WARNING_MESSAGE, new ImageIcon(ImagePathUtil.getRealPath("2\\female.png")));
  16.     }
  17. });
  20. public void init(){
  21.     jf.add(jta);
  22.     jf.add(btn, BorderLayout.SOUTH);
  24.     jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  25.     jf.pack();
  26.     jf.setVisible(true);
  27. }
  29. public static void main(String[] args) {
  30.     new MessageDialogTest().init();
  31. }

}

  1. **确认对话框**<br />![确认对话框.jpg](https://cdn.nlark.com/yuque/0/2021/jpeg/22782459/1634573959498-90b757ea-4ccd-4cc1-96d0-02a3959086d5.jpeg#clientId=uaaa5a029-81e7-4&from=drop&id=ua7a8340c&originHeight=236&originWidth=672&originalType=binary&ratio=1&rotation=0&showTitle=false&size=37364&status=done&style=none&taskId=u597bc815-ebb5-4acf-8ff9-506920715c8&title=)
  2. ```java
  3. import javax.swing.*;
  4. import java.awt.*;
  5. import java.awt.event.ActionEvent;
  7. public class ConfirmDialogTest {
  10.     JFrame jf = new JFrame("测试确认对话框");
  12.     JTextArea jta = new JTextArea(6, 30);
  14.     JButton btn = new JButton(new AbstractAction("弹出确认对话框") {
  16.         @Override
  17.         public void actionPerformed(ActionEvent e) {
  19.             int result = JOptionPane.showConfirmDialog(jf, jta.getText(), "确认对话框",JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
  20.             if (result == JOptionPane.YES_OPTION){
  21.                 jta.append("\n用户点击了确定按钮");
  22.             }
  24.             if (result==JOptionPane.NO_OPTION){
  25.                 jta.append("\n用户点击了取消按钮");
  26.             }
  28.         }
  29.     });
  32.     public void init(){
  33.         jf.add(jta);
  34.         jf.add(btn, BorderLayout.SOUTH);
  36.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  37.         jf.pack();
  38.         jf.setVisible(true);
  39.     }
  41.     public static void main(String[] args) {
  42.         new ConfirmDialogTest().init();
  43.     }
  45. }

输入对话框：
输入对话框1.jpg
输入对话框2.jpg

  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.ActionEvent;
  5. public class InputDialogTest {
  8.     JFrame jf = new JFrame("测试输入对话框");
  10.     JTextArea jta = new JTextArea(6, 30);
  12.     JButton btn = new JButton(new AbstractAction("弹出输入对话框") {
  14.         @Override
  15.         public void actionPerformed(ActionEvent e) {
  18.            /* String result = JOptionPane.showInputDialog(jf, "请填写您的银行账号：", "输入对话框", JOptionPane.INFORMATION_MESSAGE);
  19.             if(result!=null){
  20.                 jta.append(result.toString());
  21.             }
  22.             */
  24.             Object result = JOptionPane.showInputDialog(jf, "", "输入对话框", JOptionPane.DEFAULT_OPTION, null, new String[]{"柳岩", "舒淇", "龚玥菲"}, "舒淇");
  25.             if (result!=null){
  26.                 jta.append(result.toString());
  27.             }
  28.         }
  29.     });
  32.     public void init(){
  33.         jf.add(jta);
  34.         jf.add(btn, BorderLayout.SOUTH);
  36.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  37.         jf.pack();
  38.         jf.setVisible(true);
  39.     }
  41.     public static void main(String[] args) {
  42.         new InputDialogTest().init();
  43.     }
  45. }

选项对话框：
选项对话框.jpg

  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.ActionEvent;
  5. public class OptionDialogTest {
  8.     JFrame jf = new JFrame("测试选项对话框");
  10.     JTextArea jta = new JTextArea(6, 30);
  12.     JButton btn = new JButton(new AbstractAction("弹出选项对话框") {
  14.         @Override
  15.         public void actionPerformed(ActionEvent e) {
  20.             int result = JOptionPane.showOptionDialog(jf, "请选择尿不湿号码", "选项对话框",JOptionPane.DEFAULT_OPTION,JOptionPane.INFORMATION_MESSAGE,
  21.                     null,new String[]{"大号","中号","小号"},"中号");
  23.             switch (result){
  24.                 case 0:
  25.                     jta.setText("用户选择了大号");
  26.                     break;
  27.                 case 1:
  28.                     jta.setText("用户选择了中号");
  29.                     break;
  30.                 case 2:
  31.                     jta.setText("用户选择了小号");
  32.                     break;
  33.             }
  34.         }
  35.     });
  38.     public void init(){
  39.         jf.add(jta);
  40.         jf.add(btn, BorderLayout.SOUTH);
  42.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  43.         jf.pack();
  44.         jf.setVisible(true);
  45.     }
  47.     public static void main(String[] args) {
  48.         new OptionDialogTest().init();
  49.     }
  51. }

Swing中的特殊容器

Swing提供了一些具有特殊功能的容器 ， 这些特殊容器可以用于创建一些更复杂的用户界面。

使用JSplitPane

JSplitPane 用于创建一个分割面板,它可以将 一个组件(通常是一个容器)分割成两个部分，并提供一个分割条 ， 用户可以拖动该分割条来调整两个部分的大小。
JSplitPaneDemo.jpg
JSplitPane使用步骤：
1.创建JSplitPane对象

  1. 通过如下构造方法可以创建JSplitPane对象
  2. JSplitPane(int newOrientation, Component newLeftComponent,Component newRightComponent)
  3.     newOrientation：指定JSplitPane容器的分割方向：
  4.         如果值为JSplitPane.VERTICAL_SPLIT,为纵向分割；
  5.         如果值为JSplitPane.HORIZONTAL_SPLIT，为横向分割；
  7.     newLeftComponent：左侧或者上侧的组件；
  8.     newRightComponent：右侧或者下侧的组件；

2.设置是否开启连续布局的支持(可选)

  1. setContinuousLayout(boolean newContinuousLayout):
  2.     默认是关闭的，如果设置为true，则打开连续布局的支持，但由于连续布局支持需要不断的重绘组件，所以效率会低一些

3.设置是否支持”一触即展”的支持(可选)

  1. setOneTouchExpandable(boolean newValue):
  2.     默认是关闭的，如果设置为true，则打开"一触即展"的支持

4.其他设置

  1. setDividerLocation(double proportionalLocation):设置分隔条的位置为JSplitPane的某个百分比
  2. setDividerLocation(int location)：通过像素值设置分隔条的位置
  3. setDividerSize(int newSize)：通过像素值设置分隔条的大小
  4. setLeftComponent(Component comp)/setTopComponent(Component comp)/setRightComponent(Component comp)/setBottomComponent(Component comp):设置指定位置的组件

案例：
使用JSplitPane实现下图效果：
点击右侧的图书名称，在左上方显示该图书的图片，左下方显示该图书的描述
JSplitPane.jpg
演示代码：

  1. public class Book {
  3.     private String name;
  5.     private Icon icon;
  7.     private String desc;
  9.     public Book(String name, Icon icon, String desc) {
  10.         this.name = name;
  11.         this.icon = icon;
  12.         this.desc = desc;
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public Icon getIcon() {
  24.         return icon;
  25.     }
  27.     public void setIcon(Icon icon) {
  28.         this.icon = icon;
  29.     }
  31.     public String getDesc() {
  32.         return desc;
  33.     }
  35.     public void setDesc(String desc) {
  36.         this.desc = desc;
  37.     }
  39.     @Override
  40.     public String toString() {
  41.         return name;
  42.     }
  43. }
  45. import cn.itcast.swing.util.ImagePathUtil;
  47. import javax.swing.*;
  48. import javax.swing.event.ListSelectionEvent;
  49. import javax.swing.event.ListSelectionListener;
  50. import java.awt.*;
  52. public class SplitPaneTest {
  54.     Book[] books = {new Book("java自学宝典", new ImageIcon(ImagePathUtil.getRealPath("3\\java.png")), "国内关于 Java 编程最全面的图书 \n 看得懂 ， 学得会"),
  56.             new Book("轻量级的JAVAEE企业应用实战", new ImageIcon(ImagePathUtil.getRealPath("3\\ee.png")), "SSM整合开发的经典图书，值的拥有"),
  58.             new Book("Android基础教程", new ImageIcon(ImagePathUtil.getRealPath("3\\android.png")), "全面介绍Android平台应用程序\n 开发的各方面知识")
  60.     };
  62.     JFrame jf = new JFrame("测试JSplitPane");
  64.     //列表展示图书
  65.     JList<Book> bookList = new JList<>(books);
  67.     JLabel bookCover = new JLabel();
  69.     JTextArea bookDesc = new JTextArea();
  71.     public void init(){
  73.         //为三个组件设置最佳大小
  74.         bookList.setPreferredSize(new Dimension(150,400));
  75.         bookCover.setPreferredSize(new Dimension(220,330));
  76.         bookDesc.setPreferredSize(new Dimension(220,70));
  78.         //为列表添加事件监听器
  79.         bookList.addListSelectionListener(new ListSelectionListener() {
  80.             @Override
  81.             public void valueChanged(ListSelectionEvent e) {
  82.                 Book book = bookList.getSelectedValue();
  83.                 bookCover.setIcon(book.getIcon());
  84.                 bookDesc.setText(book.getDesc());
  85.             }
  86.         });
  88.         //创建一个垂直的分割面板
  89.         JSplitPane left = new JSplitPane(JSplitPane.VERTICAL_SPLIT,bookCover,new JScrollPane(bookDesc));
  91.         //打开"一触即展"特性
  92.         left.setOneTouchExpandable(true);
  94.         //设置分隔条的大小
  96.         left.setDividerSize(10);
  97.         //设置分割面板根据组件的大小调整最佳布局
  98.         left.resetToPreferredSizes();
  100.         //创建一个水平分隔面板
  101.         JSplitPane content = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, left, bookList);
  102.         //设置支持连续布局
  103.         content.setContinuousLayout(true);
  105.         jf.add(content);
  107.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  108.         jf.pack();
  109.         jf.setVisible(true);
  112.     }
  114.     public static void main(String[] args) {
  115.         new SplitPaneTest().init();
  116.     }
  118. }

使用JTabledPane

JTabbedPane可以很方便地在窗口上放置多个标签页，每个标签页相当于获得了一个与外部容器具有相同大小的组件摆放区域。通过这种方式， 就可以在一个容器里放置更多的组件 ， 例如右击桌面上的” 我的电脑 “图标，在弹出的快捷菜单里单击”属性 “ 菜单工页 ， 就可以看 到 一个”系统属性 “ 对话框 ，这个对话框里包含了 若干个标签页。
properties.jpg
如果需要使用JTabbedPane在窗口上创建标签页 ，则可以按如下步骤进行:
1.创建JTabbedPane对象

  1.  JTabbedPane(int tabPlacement, int tabLayoutPolicy):
  2.     tabPlacement:
  3.         指定标签标题的放置位置，可以选择 SwingConstants中的四个常量：TOP、LEFT、BOTTOM、RIGHT
  4.     tabLaoutPolicy:
  5.         指定当窗口不能容纳标签页标题时的布局策略，可以选择JTabbedPane.WRAP_TAB_LAYOUT和JTabbedPane.SCROLL_TAB_LAYOUT

2.通过JTabbedPane对象堆标签进行增删改查

  1. addTab(String title, Icon icon, Component component, String tip):添加标签
  2.     title:标签的名称
  3.     icon:标签的图标
  4.     component:标签对应的组件
  5.     tip:光标放到标签上的提示
  7. insertTab(String title, Icon icon, Component component, String tip, int index):插入标签页
  8.     title:标签的名称
  9.     icon:标签的图标
  10.     component:标签对应的组件
  11.     tip:光标放到标签上的提示
  12.     index:在哪个索引处插入标签页
  13. setComponentAt(int index, Component component):修改标签页对应的组件
  14.     index:修改哪个索引处的标签
  15.     component:标签对应的组件
  16. removeTabAt(int index):
  17.     index:删除哪个索引处的标签

3.设置当前显示的标签页

  1. setSelectedIndex(int index):设置哪个索引处的标签被选中

4.设置JTabbedPane的其他属性

  1. setDisabledIconAt(int index, Icon disabledIcon): 将指定位置的禁用图标设置为 icon，该图标也可以是null表示不使用禁用图标。
  2. setEnabledAt(int index, boolean enabled): 设置指定位置的标签页是否启用。
  3. setTitleAt(int index, String title): 设置指定位置标签页的标题为 title，该title可以是null,这表明设置该标签页的标题为空。
  4. setToolTipTextAt(int index, String toolTipText): 设置指定位置标签页的提示文本 。

5.为JTabbedPane设置监听器

  1. addChangeListener(ChangeListener l)

案例：
请使用JTabbedPane完成下图功能：
JTabbedPane.jpg
演示代码：

  1. import javax.swing.*;
  2. import javax.swing.event.ChangeEvent;
  3. import javax.swing.event.ChangeListener;
  5. public class JTabbedPaneTest {
  6.     JFrame jf = new JFrame("测试JTabbedPane");
  10.     JTabbedPane tabbedPane = new JTabbedPane(SwingConstants.TOP,JTabbedPane.WRAP_TAB_LAYOUT);
  12.     public void init(){
  15.         //设置jf大小
  16.         jf.setBounds(400,400,400,400);
  17.         //设置jf大小不能变化
  18.         jf.setResizable(false);
  21.         ImageIcon icon = new ImageIcon(ImagePathUtil.getRealPath("3\\open.gif"));
  22.         //添加标签
  23.         tabbedPane.addTab("用户管理",icon,new JList<String>(new String[]{"用户一","用户二","用户三"}));
  24.         tabbedPane.addTab("商品管理",new JList<String>(new String[]{"商品一","商品二","商品三"}));
  25.         tabbedPane.addTab("订单管理",icon,new JList<String>(new String[]{"订单一","订单二","订单三"}));
  27.         //设置第二个标签默认选中
  28.         tabbedPane.setSelectedIndex(1);
  29.         //设置第一个标签不能用
  30.         tabbedPane.setEnabledAt(0,false);
  32.         tabbedPane.addChangeListener(new ChangeListener() {
  33.             @Override
  34.             public void stateChanged(ChangeEvent e) {
  35.                 int selectedIndex = tabbedPane.getSelectedIndex();
  36.                 JOptionPane.showMessageDialog(jf,"选中了第"+(selectedIndex+1)+"个标签");
  37.             }
  38.         });
  41.         jf.add(tabbedPane);
  42.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  43.         jf.setVisible(true);
  45.     }
  48.     public static void main(String[] args) {
  49.         new JTabbedPaneTest().init();
  50.     }
  51. }

使用JLayeredPane、JDesktopPane、JInternalFrame

JLayeredPane

JLayeredPane是 一个代表有层 次深度的容器 ， 它允许组件在需要 时 互相重叠。当向JLayeredPane容器中添加组件时， 需要为该组件指定一个深度索引 ， 其中层次索引较高 的层里的组件位于其他层的组件之上。
JLayeredPane1.gif
JLayeredPane 还将容器的层次深度分成几个默认层 ，程序只是将组件放入相应 的层 ，从而可以更容易地确保组件的正确重叠 ， 无须为组件指定具体的深度索引。JLayeredPane 提供了如下几个默认层：

  1. DEFAULT_LAYER:大多数组件位于标准层，这是最底层；
  2. PALETTE_LAYER : 调色板层位于默认层之上 。该层对于浮动工具栏和调色板很有用，因此可以位于其他组件之上 。
  3. MODAL_LAYER: 该层用于显示模式对话框。它们将出现在容器中所有工具栏 、调色板或标准组件的上面 。
  4. POPUP_LAYER : 该层用于显示右键菜单 ， 与对话框 、工具提示和普通组件关联的弹出式窗口将出现在对应的对话框、工具提示和普通组件之上。
  5. DRAG_LAYER: 该层用于放置拖放过程中的组件(关于拖放操作请看下一节内 容) ，拖放操作中的组件位于所有组件之上 。 一旦拖放操作结束后 ， 该组件将重新分配到其所属的正常层。

JLayeredPane 方法：

  1. moveToBack(Component c)：把当前组件c移动到所在层的所有组件的最后一个位置；
  2. moveToFront(Component c)：把当前组件c移动到所在层的所有组件的第一个位置；
  3. setLayer(Component c, int layer)：更改组件c所处的层；

需要注意的是，往JLayeredPane中添加组件，如果要显示，则必须手动设置该组件在容器中显示的位置以及大小。
案例：
使用JLayeredPane完成下图效果：
JLayeredPane2.jpg
演示代码：

  1. import cn.itcast.swing.util.ImagePathUtil;
  3. import javax.swing.*;
  4. import java.awt.*;
  6. public class JLayeredPaneTest {
  7.     JFrame jf = new JFrame("测试JLayeredPane");
  8.     JLayeredPane layeredPane = new JLayeredPane();
  10.     //自定义组件，继承JPanel
  11.     private class ContentPanel extends JPanel{
  13.         public ContentPanel(int xPos,int yPos,String title,String ico){
  14.             //设置边框
  15.             setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(),title));
  16.             JLabel label = new JLabel(new ImageIcon(ImagePathUtil.getRealPath("3\\"+ico)));
  17.             add(label);
  18.             setBounds(xPos,yPos,160,220);
  20.         }
  22.     }
  24.     public void init(){
  25.         //向LayeredPane中添加三个组件，往JLayeredPane中添加组件，都必须手动的设置组件显示的位置和大小，才能显示出来
  27.         layeredPane.add(new ContentPanel(10,20,"java自学宝典","java.png"),JLayeredPane.MODAL_LAYER);
  28.         layeredPane.add(new ContentPanel(100,60,"Android基础教程","android.png"),JLayeredPane.DEFAULT_LAYER);
  29.         layeredPane.add(new ContentPanel(80,100,"轻量级javaEE企业应用","ee.png"),JLayeredPane.DRAG_LAYER);
  31.         layeredPane.setPreferredSize(new Dimension(300,400));
  34.         jf.add(layeredPane);
  35.         jf.pack();
  36.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  37.         jf.setVisible(true);
  40.     }
  42.     public static void main(String[] args) {
  43.         new JLayeredPaneTest().init();
  44.     }
  45. }

JDesktopPane和JInternalFrame

JDesktopPane是JLayeredPane的子类，这种容器在开发中会更常用很多应用程序都需要启动多个内部窗口来显示信息（典型的比如IDEA、NotePad++），这些内部窗口都属于同一个外部窗口，当外部窗 口 最小化时， 这些内部窗口都被隐藏起来。在 Windows 环境中，这种用户界面被称为多文档界面 C Multiple Document Interface, MDI) 。
使用 Swing 可以非常简单地创建出这种 MDI 界面 ， 通常，内部窗口有自己的标题栏、标题、图标、三个窗口按钮，并允许拖动改变内部窗口 的大小和位置，但内部窗口不能拖出外部窗口。
内部窗口1.jpg
JDesktopPane 需要和 JIntemalFrame 结合使用，其中JDesktopPane 代表一 个虚拟桌面 ，而JIntemalFrame则用于创建内部窗口。使用 JDesktopPane 和 JIntemalFrame 创建内部窗口按如下步骤进行即可:

  1. 创建 一 个 JDesktopPane 对象,代表虚拟桌面
  1. JDesktopPane()
  1. 使用 JIntemalFrame 创建一个内部窗口
  1. JInternalFrame(String title, boolean resizable, boolean closable, boolean maximizable, boolean iconifiable):
  2.     title: 内部窗口标题
  3.     resizable:是否可改变大小
  4.     closeble: 是否可关闭
  5.     maximizable: 是否可最大化
  6.     iconifiable:是否可最小化
  1. 一旦获得了内部窗口之后，该窗口的用法和普通窗口的用法基本相似， 一样可以指定该窗口的布局管理器， 一样可以向窗口内添加组件、改变窗口图标等。
  2. 将该内部窗口以合适大小、在合适位置显示出来 。与普通窗口类似的是， 该窗口默认大小是 0x0像素，位于0，0 位置(虚拟桌面的左上角处)，并且默认处于隐藏状态，程序可以通过如下代码将内部窗口显示出来:
  1. reshape(int x, int y, int width, int height):设置内部窗口的大小以及在外部窗口中的位置；
  2. show():设置内部窗口可见
  1. 将内部窗口添加到 JDesktopPane 容器中，再将 JDesktopPane 容器添加到其他容器中。

案例：
请使用JDesktopPane和JInternalFrame完成下图效果：
JInternalFrame.jpg
演示代码：

  1. import cn.itcast.swing.util.ImagePathUtil;
  3. import javax.swing.*;
  4. import java.awt.*;
  5. import java.awt.event.ActionEvent;
  7. public class JInternalFrameTest {
  8.     final int DESKTOP_WIDTH = 480;
  9.     final int DESKTOP_HEIGHT = 360;
  10.     final int FRAME_DISTANCE = 20;
  12.     //创建外部窗口
  13.     JFrame jf = new JFrame("测试JInternalFrame");
  15.     //创建虚拟桌面
  16.     JDesktopPane desktop = new JDesktopPane();
  18.     //定义内部窗口为的大小
  19.     private int width = 230;
  20.     private int height = DESKTOP_HEIGHT;
  22.     //定义下一个内部窗口的横轴坐标
  23.     private int nextFrameX = 0;
  25.     //为外部窗口定义两个菜单
  26.     JMenu fileMenu = new JMenu("文件");
  29.     //定义Action，用于快捷创建菜单项和工具按钮
  30.     Action newAction = new AbstractAction("新建",new ImageIcon(ImagePathUtil.getRealPath("3\\new.png"))) {
  31.         @Override
  32.         public void actionPerformed(ActionEvent e) {
  33.             //创建内部窗口
  34.             JInternalFrame iframe = new JInternalFrame("新文档",true,true,true,true);
  35.             //往内部窗口中添加一个8行40列的文本框
  36.             iframe.add(new JScrollPane(new JTextArea(8,40)));
  37.             //将内部窗口添加到虚拟桌面中
  38.             desktop.add(iframe);
  39.             //设置内部窗口的原始位置
  40.             iframe.reshape(nextFrameX,0,width,height);
  41.             //使该窗口可见
  42.             iframe.show();
  44.             //计算下一个内部窗口的位置
  45.             nextFrameX+=FRAME_DISTANCE;
  48.             if (nextFrameX>DESKTOP_WIDTH-width){
  49.                 nextFrameX=0;
  50.             }
  51.         }
  52.     };
  54.     Action exitAction = new AbstractAction("退出",new ImageIcon(ImagePathUtil.getRealPath("3\\exit.png"))) {
  55.         @Override
  56.         public void actionPerformed(ActionEvent e) {
  57.             //结束当前程序
  58.             System.exit(0);
  59.         }
  60.     };
  63.     public void init(){
  65.         //为窗口安装菜单条
  66.         JMenuBar menuBar = new JMenuBar();
  68.         jf.setJMenuBar(menuBar);
  69.         menuBar.add(fileMenu);
  70.         fileMenu.add(newAction);
  71.         fileMenu.add(exitAction);
  75.         //设置虚拟桌面的最佳大小
  76.         desktop.setPreferredSize(new Dimension(DESKTOP_WIDTH,DESKTOP_HEIGHT));
  78.         //将虚拟桌面添加到外部窗口中
  79.         jf.add(desktop);
  81.         jf.pack();
  82.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  83.         jf.setVisible(true);
  85.     }
  88.     public static void main(String[] args) {
  89.         new JInternalFrameTest().init();
  90.     }
  92. }

JProcessBar、ProcessMonitor、BoundedRangeModel实现进度条

进度条是图形界面中广泛使用的GUI 组件，当复制一个较大的文件时，操作系统会显示一个进度条，用于标识复制操作完成的比例 : 当启动 Eclipse 等程序时， 因为需要加载较多的资源 ， 故而启动速度较慢 ， 程序也会在启动过程中显示一个进度条 ， 用以表示该软件启动完成的比例 ……

创建进度条

使用JProgressBar创建进度条的步骤：

  1. 创建JProgressBar对象
  1. public JProgressBar(int orient, int min, int max):
  2.     orint:方向
  3.     min:最小值
  4.     max:最大值
  1. 设置属性
  1. setBorderPainted(boolean b):设置进度条是否有边框
  2. setIndeterminate(boolean newValue):设置当前进度条是不是进度不确定的进度条，如果是，则将看到一个滑块在进度条中左右移动
  3. setStringPainted(boolean b)：设置进度条是否显示当前完成的百分比
  1. 获取和设置当前进度条的进度状态
  1. setValue(int n):设置当前进度值
  2. double getPercentComplete():获取进度条的完成百分比
  3. String  getStrin():返回进度字符串的当前值

案例：
请使用JProgressBar完成下图效果：
JProgressBar.jpg
演示代码：

  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.ActionEvent;
  4. import java.awt.event.ActionListener;
  6. public class JProgressTest {
  8.     JFrame jf = new JFrame("测试进度条");
  9.     //创建一个垂直进度条
  10.     JProgressBar bar = new JProgressBar(JProgressBar.HORIZONTAL);
  12.     JCheckBox indeterminate = new JCheckBox("不确定进度");
  13.     JCheckBox noBorder = new JCheckBox("不绘制边框");
  15.     public void init(){
  17.         Box box = new Box(BoxLayout.Y_AXIS);
  18.         box.add(indeterminate);
  19.         box.add(noBorder);
  21.         jf.setLayout(new FlowLayout());
  22.         jf.add(box);
  24.         //把进度条添加到jf窗口中
  25.         jf.add(bar);
  27.         //设置进度条的最大值和最小值
  28.         bar.setMinimum(0);
  29.         bar.setMaximum(100);
  31.         //设置进度条中绘制完成百分比
  32.         bar.setStringPainted(true);
  34.         //根据选择决定是否绘制进度条边框
  35.         noBorder.addActionListener(new ActionListener() {
  36.             @Override
  37.             public void actionPerformed(ActionEvent e) {
  38.                 boolean flag = noBorder.isSelected();
  39.                 bar.setBorderPainted(!flag);
  40.             }
  41.         });
  43.         //根据选择决定是否是不确定进度条
  44.         indeterminate.addActionListener(new ActionListener() {
  45.             @Override
  46.             public void actionPerformed(ActionEvent e) {
  47.                 boolean flag = indeterminate.isSelected();
  48.                 bar.setIndeterminate(flag);
  49.                 //不绘制百分比，因为之前设置了绘制百分比
  50.                 bar.setStringPainted(!flag);
  51.             }
  52.         });
  54.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  55.         jf.pack();
  56.         jf.setVisible(true);
  59.         //通过循环不断改变进度条的完成进度
  60.         for (int i = 0; i <= 100; i++) {
  61.             //改变进度条的完成进度
  62.             bar.setValue(i);
  64.             try {
  65.                 Thread.sleep(1000);
  66.             } catch (InterruptedException e) {
  67.                 e.printStackTrace();
  68.             }
  69.         }
  71.     }
  73.     public static void main(String[] args) {
  74.         new JProgressTest().init();
  75.     }
  76. }

在刚才的程序中，通过for循环来不断的更新进度条的进度，这仅仅是为了演示而已，实际开发中这样的操作是没有意义的。通常情况下是不断的检测一个耗时任务的完成情况，然后才去更新进度条的进度。下面的代码通过Timer定时器和Runnable接口，对上述代码进行改进，其运行结果没有变化，知识修改到了进度条进度更新的逻辑。

  1. import javax.swing.*;
  2. import javax.swing.event.ChangeEvent;
  3. import javax.swing.event.ChangeListener;
  4. import java.awt.*;
  5. import java.awt.event.ActionEvent;
  6. import java.awt.event.ActionListener;
  8. public class JProgressTest2 {
  10.     JFrame jf = new JFrame("测试进度条");
  11.     //创建一个垂直进度条
  12.     JProgressBar bar = new JProgressBar(JProgressBar.HORIZONTAL);
  14.     JCheckBox indeterminate = new JCheckBox("不确定进度");
  15.     JCheckBox noBorder = new JCheckBox("不绘制边框");
  17.     public void init(){
  19.         Box box = new Box(BoxLayout.Y_AXIS);
  20.         box.add(indeterminate);
  21.         box.add(noBorder);
  23.         jf.setLayout(new FlowLayout());
  24.         jf.add(box);
  26.         //把进度条添加到jf窗口中
  27.         jf.add(bar);
  29.         //开启耗时任务
  30.         SimulatedActivity simulatedActivity = new SimulatedActivity(100);
  31.         new Thread(simulatedActivity).start();
  34.         //设置进度条的最大值和最小值
  35.         bar.setMinimum(0);
  36.         bar.setMaximum(simulatedActivity.getAmount());
  38.         //设置进度条中绘制完成百分比
  39.         bar.setStringPainted(true);
  41.         //根据选择决定是否绘制进度条边框
  42.         noBorder.addActionListener(new ActionListener() {
  43.             @Override
  44.             public void actionPerformed(ActionEvent e) {
  45.                 boolean flag = noBorder.isSelected();
  46.                 bar.setBorderPainted(!flag);
  47.             }
  48.         });
  50.         //根据选择决定是否是不确定进度条
  51.         indeterminate.addActionListener(new ActionListener() {
  52.             @Override
  53.             public void actionPerformed(ActionEvent e) {
  54.                 boolean flag = indeterminate.isSelected();
  55.                 bar.setIndeterminate(flag);
  56.                 //不绘制百分比，因为之前设置了绘制百分比
  57.                 bar.setStringPainted(!flag);
  58.             }
  59.         });
  61.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  62.         jf.pack();
  63.         jf.setVisible(true);
  68.         //通过定时器，不断的读取simulatedActivity中的current值，更新进度条的进度
  69.         Timer timer = new Timer(300, new ActionListener() {
  70.             @Override
  71.             public void actionPerformed(ActionEvent e) {
  72.                 bar.setValue(simulatedActivity.getCurrent());
  73.             }
  74.         });
  75.         timer.start();
  76.         //监听进度条的变化，如果进度完成为100%，那么停止定时器
  77.         bar.addChangeListener(new ChangeListener() {
  78.             @Override
  79.             public void stateChanged(ChangeEvent e) {
  80.                 if (   bar.getValue()==bar.getMaximum()){
  81.                     timer.stop();
  82.                 }
  83.             }
  84.         });
  87.     }
  89.     public static void main(String[] args) {
  90.         new JProgressTest2().init();
  91.     }
  93.     //定义一个线程任务，模拟耗时操作
  94.     private class SimulatedActivity implements Runnable{
  95.         //内存可见
  96.         private volatile int current = 0;
  97.         private int amount;
  99.         public SimulatedActivity(int amount) {
  100.             this.amount = amount;
  101.         }
  103.         public int getCurrent() {
  104.             return current;
  105.         }
  107.         public void setCurrent(int current) {
  108.             this.current = current;
  109.         }
  112.         public int getAmount() {
  113.             return amount;
  114.         }
  116.         public void setAmount(int amount) {
  117.             this.amount = amount;
  118.         }
  120.         @Override
  121.         public void run() {
  122.             //通过循环，不断的修改current的值，模拟任务完成量
  123.             while(current<amount){
  124.                 try {
  125.                     Thread.sleep(50);
  126.                 } catch (InterruptedException e) {
  127.                     e.printStackTrace();
  128.                 }
  129.                 current++;
  130.             }
  131.         }
  132.     }
  133. }

之前我们学习过，其实Swing中很多组件的界面与数据都采用了MVC的设计思想：
mvc.png
Swing 组件大都将外观显示和 内部数据分离 ， JProgressBar 也不例外， JProgressBar 组件有一个内置的用于保存其状态数据的Model对象 ， 这个对象由BoundedRangeModel对象表示，程序调用JProgressBar对象的方法完成进度百分比的设置，监听进度条的数据变化，其实都是通过它内置的BoundedRangeModel对象完成的。下面的代码是对之前代码的改进，通过BoundedRangeModel完成数据的设置，获取与监听。

  1. import javax.swing.*;
  2. import javax.swing.event.ChangeEvent;
  3. import javax.swing.event.ChangeListener;
  4. import java.awt.*;
  5. import java.awt.event.ActionEvent;
  6. import java.awt.event.ActionListener;
  8. public class JProgressTest3 {
  10.     JFrame jf = new JFrame("测试进度条");
  11.     //创建一个垂直进度条
  12.     JProgressBar bar = new JProgressBar(JProgressBar.HORIZONTAL);
  14.     JCheckBox indeterminate = new JCheckBox("不确定进度");
  15.     JCheckBox noBorder = new JCheckBox("不绘制边框");
  17.     public void init(){
  19.         Box box = new Box(BoxLayout.Y_AXIS);
  20.         box.add(indeterminate);
  21.         box.add(noBorder);
  23.         jf.setLayout(new FlowLayout());
  24.         jf.add(box);
  26.         //把进度条添加到jf窗口中
  27.         jf.add(bar);
  29.         //开启耗时任务
  30.         SimulatedActivity simulatedActivity = new SimulatedActivity(100);
  31.         new Thread(simulatedActivity).start();
  34.         //设置进度条的最大值和最小值
  35.         bar.getModel().setMinimum(0);
  36.         bar.getModel().setMaximum(simulatedActivity.getAmount());
  38.         //设置进度条中绘制完成百分比
  39.         bar.setStringPainted(true);
  41.         //根据选择决定是否绘制进度条边框
  42.         noBorder.addActionListener(new ActionListener() {
  43.             @Override
  44.             public void actionPerformed(ActionEvent e) {
  45.                 boolean flag = noBorder.isSelected();
  46.                 bar.setBorderPainted(!flag);
  47.             }
  48.         });
  50.         //根据选择决定是否是不确定进度条
  51.         indeterminate.addActionListener(new ActionListener() {
  52.             @Override
  53.             public void actionPerformed(ActionEvent e) {
  54.                 boolean flag = indeterminate.isSelected();
  55.                 bar.setIndeterminate(flag);
  56.                 //不绘制百分比，因为之前设置了绘制百分比
  57.                 bar.setStringPainted(!flag);
  58.             }
  59.         });
  61.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  62.         jf.pack();
  63.         jf.setVisible(true);
  68.         //通过定时器，不断的读取simulatedActivity中的current值，更新进度条的进度
  69.         Timer timer = new Timer(300, new ActionListener() {
  70.             @Override
  71.             public void actionPerformed(ActionEvent e) {
  72.                 bar.getModel().setValue(simulatedActivity.getCurrent());
  73.             }
  74.         });
  75.         timer.start();
  76.         //监听进度条的变化，如果进度完成为100%，那么停止定时器
  77.         bar.getModel().addChangeListener(new ChangeListener() {
  78.             @Override
  79.             public void stateChanged(ChangeEvent e) {
  80.                 if (   bar.getModel().getValue()==bar.getModel().getMaximum()){
  81.                     timer.stop();
  82.                 }
  83.             }
  84.         });
  87.     }
  89.     public static void main(String[] args) {
  90.         new JProgressTest3().init();
  91.     }
  93.     //定义一个线程任务，模拟耗时操作
  94.     private class SimulatedActivity implements Runnable{
  95.         //内存可见
  96.         private volatile int current = 0;
  97.         private int amount;
  99.         public SimulatedActivity(int amount) {
  100.             this.amount = amount;
  101.         }
  103.         public int getCurrent() {
  104.             return current;
  105.         }
  107.         public void setCurrent(int current) {
  108.             this.current = current;
  109.         }
  112.         public int getAmount() {
  113.             return amount;
  114.         }
  116.         public void setAmount(int amount) {
  117.             this.amount = amount;
  118.         }
  120.         @Override
  121.         public void run() {
  122.             //通过循环，不断的修改current的值，模拟任务完成量
  123.             while(current<amount){
  124.                 try {
  125.                     Thread.sleep(50);
  126.                 } catch (InterruptedException e) {
  127.                     e.printStackTrace();
  128.                 }
  129.                 current++;
  130.             }
  131.         }
  132.     }
  133. }

创建进度对话框

ProgressMonitor的用法与JProgressBa 的用法基本相似，只是ProgressMonitor可以直接创 建一个进度对话框，它提供了下面的构造器完成对话框的创建：

  1.  public ProgressMonitor(Component parentComponent,Object message,String note, int min,int max):
  2.     parentComponent:对话框的父组件
  3.     message:对话框的描述信息
  4.     note:对话框的提示信息
  5.     min:进度条的最小值
  6.     max:进度条的最大值

使用 ProgressMonitor 创建的对话框里包含的进度条是非常固定的，程序甚至不能设置该进度条是否包含边框(总是包含边框) ， 不能设置进度不确定，不能改变进度条的方向(总是水平方向) 。
案例：
使用ProgressMonitor完成下图效果：
ProgressMonitor.jpg
演示代码：

  1. import javax.swing.*;
  2. import java.awt.event.ActionEvent;
  3. import java.awt.event.ActionListener;
  5. public class ProgressMonitorTest {
  7.     Timer timer;
  8.     public void init(){
  9.         final SimulatedActivity simulatedActivity = new SimulatedActivity(100);
  10.         final Thread targetThread= new Thread(simulatedActivity);
  11.         targetThread.start();
  14.         ProgressMonitor dialog = new ProgressMonitor(null, "等待任务完成", "已完成：", 0, simulatedActivity.getAmount());
  16.         timer = new Timer(300, new ActionListener() {
  17.             @Override
  18.             public void actionPerformed(ActionEvent e) {
  19.                 dialog.setProgress(simulatedActivity.getCurrent());
  20.                 if (dialog.isCanceled()){
  21.                     timer.stop();
  22.                     targetThread.interrupt();
  23.                     System.exit(0);
  24.                 }
  25.             }
  26.         });
  27.         timer.start();
  30.         System.out.println("aaa");
  31.     }
  33.     public static void main(String[] args) {
  34.         new ProgressMonitorTest().init();
  35.     }
  37.     //定义一个线程任务，模拟耗时操作
  38.     private class SimulatedActivity implements Runnable{
  39.         //内存可见
  40.         private volatile int current = 0;
  41.         private int amount;
  43.         public SimulatedActivity(int amount) {
  44.             this.amount = amount;
  45.         }
  47.         public int getCurrent() {
  48.             return current;
  49.         }
  51.         public void setCurrent(int current) {
  52.             this.current = current;
  53.         }
  56.         public int getAmount() {
  57.             return amount;
  58.         }
  60.         public void setAmount(int amount) {
  61.             this.amount = amount;
  62.         }
  64.         @Override
  65.         public void run() {
  66.             //通过循环，不断的修改current的值，模拟任务完成量
  67.             while(current<amount){
  68.                 try {
  69.                     Thread.sleep(50);
  70.                 } catch (InterruptedException e) {
  71.                     e.printStackTrace();
  72.                 }
  73.                 current++;
  74.             }
  75.         }
  76.     }
  78. }

JList、JComboBox实现列表框

无论从哪个角度来看， JList 和 JComboBox 都是极其相似的，它们都有一个列表框，只是 JComboBox的列表框需要 以下拉方式显示出来; JList 和 JComboBox 都可以通过调用 setRendererO方法来改变列表项的表现形式 。甚至维护这两个组件的 Model 都是相似的， JList 使用 ListModel, JComboBox 使用ComboBoxModel ，而 ComboBoxModel 是 ListModel 的子类 。

简单列表框

  1. 创建JList或JComboBox对象
  1. JList(final E[] listData):创建JList对象，把listData数组中的每项内容转换成一个列表项展示
  2. JList(final Vector<? extends E> listData):创建JList对象，把listData数组中的每项内容转换成一个列表项展示
  3. JComboBox(E[] items):
  4. JComboBox(Vector<E> items):
  1. 设置JList或JComboBox的外观行为
  1. ---------------------------JList----------------------------------------------
  2. addSelectionInterval(int anchor, int lead):在已经选中列表项的基础上，增加选中从anchor到lead索引范围内的所有列表项
  3. setFixedCellHeight(int height)/setFixedCellWidth(int width):设置列表项的高度和宽度
  4. setLayoutOrientation(int layoutOrientation)：设置列表框的布局方向
  5. setSelectedIndex(int index)：设置默认选中项
  6. setSelectedIndices(int[] indices)：设置默认选中的多个列表项
  7. setSelectedValue(Object anObject,boolean shouldScroll)：设置默认选中项，并滚动到该项显示
  8. setSelectionBackground(Color selectionBackground)：设置选中项的背景颜色
  9. setSelectionForeground(Color selectionForeground)：设置选中项的前景色
  10. setSelectionInterval(int anchor, int lead):设置从anchor到lead范围内的所有列表项被选中
  11. setSelectionMode(int selectionMode)：设置选中模式，默认没有限制，也可以设置为单选或者区域选中
  12. setVisibleRowCount(int visibleRowCount)：设置列表框的可是高度足以显示多少行列表项
  13. ---------------------------JComboBox---------------------------------------------- 
  14. setEditable(boolean aFlag)：设置是否可以直接修改列表文本框的值，默认为不可以
  15. setMaximumRowCount(int count)：设置列表框的可是高度足以显示多少行列表项
  16. setSelectedIndex(int anIndex)：设置默认选中项
  17. setSelectedItem(Object anObject)：根据列表项的值，设置默认选中项
  1. 设置监听器，监听列表项的变化，JList通过addListSelectionListener完成，JComboBox通过addItemListener完成

案例：
使用JList和JComboBox完成下图效果：
JList_JComboBox.jpg
演示代码：

  1. import javax.swing.*;
  2. import javax.swing.border.EtchedBorder;
  3. import javax.swing.border.TitledBorder;
  4. import javax.swing.event.ListSelectionEvent;
  5. import javax.swing.event.ListSelectionListener;
  6. import java.awt.*;
  7. import java.awt.event.ItemEvent;
  8. import java.awt.event.ItemListener;
  9. import java.util.List;
  10. import java.util.Vector;
  12. public class ListTest {
  13.     JFrame mainWin = new JFrame("列表框测试");
  14.     String[] books = {"java自学宝典","轻量级javaEE企业应用实战","Android基础教程","jQuery实战教程","SpringBoot企业级开发"};
  16.     //用一个字符串数组来创建一个JList对象
  17.     JList<String> bookList = new JList<>(books);
  18.     JComboBox<String> bookSelector;
  20.     //定义 布局选择按钮 所在的面板
  21.     JPanel layoutPanel = new JPanel();
  22.     ButtonGroup layoutGroup = new ButtonGroup();
  24.     //定义 选择模式按钮 所在面板
  25.     JPanel selectModePanel = new JPanel();
  26.     ButtonGroup selectModeGroup = new ButtonGroup();
  28.     JTextArea favorite = new JTextArea(4,40);
  30.     public void init(){
  31.         //设置JList的可视高度可以同时展示3个列表项
  32.         bookList.setVisibleRowCount(3);
  34.         //设置Jlist默认选中第三项到第五项
  35.         bookList.setSelectionInterval(2,4);
  36.         addLayoutButton("纵向滚动",JList.VERTICAL);
  37.         addLayoutButton("纵向换行",JList.VERTICAL_WRAP);
  38.         addLayoutButton("横向换行",JList.HORIZONTAL_WRAP);
  40.         addSelectModeButton("无限制", ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
  41.         addSelectModeButton("单选", ListSelectionModel.SINGLE_SELECTION);
  42.         addSelectModeButton("单范围", ListSelectionModel.SINGLE_INTERVAL_SELECTION);
  44.         Box listBox = Box.createVerticalBox();
  45.         //将JList组件放置到JScrollPane中，并将JScrollPane放置到box中
  46.         listBox.add(new JScrollPane(bookList));
  47.         listBox.add(layoutPanel);
  48.         listBox.add(selectModePanel);
  50.         //为JList添加事件监听器
  51.         bookList.addListSelectionListener(new ListSelectionListener() {
  52.             @Override
  53.             public void valueChanged(ListSelectionEvent e) {
  54.                 List<String> selectedValuesList = bookList.getSelectedValuesList();
  55.                 favorite.setText("");
  56.                 for (String s : selectedValuesList) {
  57.                     favorite.append(s+"\n");
  58.                 }
  59.             }
  60.         });
  63.         //定义一个Vector对象
  64.         Vector<String> bookCollection = new Vector<>();
  65.         List<String> books = List.of("java自学宝典","轻量级javaEE企业应用实战","Android基础教程","jQuery实战教程","SpringBoot企业级开发");
  66.         bookCollection.addAll(books);
  68.         //创建JComboBox对象
  69.         bookSelector = new JComboBox<>(bookCollection);
  71.         //为JComboBox添加事件监听器
  72.         bookSelector.addItemListener(new ItemListener() {
  73.             @Override
  74.             public void itemStateChanged(ItemEvent e) {
  75.                 Object selectedItem = bookSelector.getSelectedItem();
  76.                 favorite.setText(selectedItem.toString());
  77.             }
  78.         });
  80.         //设置JComboBox的列表项可编辑
  81.         bookSelector.setEditable(true);
  83.         //设置下拉列表的可视高度最多显示4个列表项
  84.         bookSelector.setMaximumRowCount(4);
  86.         JPanel panel = new JPanel();
  87.         panel.add(bookSelector);
  88.         Box box = Box.createHorizontalBox();
  89.         box.add(listBox);
  90.         box.add(panel);
  92.         JPanel favoritePanel = new JPanel();
  93.         favoritePanel.setLayout(new BorderLayout());
  94.         favoritePanel.add(new JScrollPane(favorite));
  95.         favoritePanel.add(new JLabel("您最喜欢的图书："),BorderLayout.NORTH);
  97.         mainWin.add(box);
  98.         mainWin.add(favoritePanel,BorderLayout.SOUTH);
  99.         mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  100.         mainWin.pack();
  101.         mainWin.setVisible(true);
  103.     }
  107.     public void addLayoutButton(String label,int orientation){
  108.         layoutPanel.setBorder(new TitledBorder(new EtchedBorder(),"确定选项布局"));
  110.         JRadioButton button = new JRadioButton(label);
  112.         layoutPanel.add(button);
  113.         //默认选中第一个按钮
  114.         if (layoutGroup.getButtonCount()==0){
  115.             button.setSelected(true);
  116.         }
  117.         layoutGroup.add(button);
  118.         button.addActionListener(e->{
  119.             //改变列表框里列表项的布局方向
  120.             bookList.setLayoutOrientation(orientation);
  121.         });
  123.     }
  125.     public void addSelectModeButton(String label,int selectMode){
  126.         selectModePanel.setBorder(new TitledBorder(new EtchedBorder(),"确定选择模式"));
  127.         JRadioButton button = new JRadioButton(label);
  128.         selectModePanel.add(button);
  129.         if (selectModeGroup.getButtonCount()==0){
  130.             button.setSelected(true);
  131.         }
  132.         selectModeGroup.add(button);
  133.         button.addActionListener(e->{
  134.             bookList.setSelectionMode(selectMode);
  135.         });
  138.     }
  140.     public static void main(String[] args) {
  141.         new ListTest().init();
  142.     }
  143. }

不强制存储列表项的ListModel和ComboBoxModel

与JProgressBar一样，JList和JComboBox也采用了MVC的设计模式，JList和JComboBox只负责外观的显示，而组件底层的状态数据则由对应的Model来维护。JList对应的Model是ListModel接口，JComboBox对应的Model是ComboBox接口，其代码如下：

  1. public interface ListModel<E>{
  3.   int getSize();
  5.   E getElementAt(int index);
  7.   void addListDataListener(ListDataListener l);
  9.   void removeListDataListener(ListDataListener l);
  10. }
  12. public interface ComboBoxModel<E> extends ListModel<E> {
  14.   void setSelectedItem(Object anItem);
  16.   Object getSelectedItem();
  17. }

从上面接口来看，这个 ListMode l 不管 JList 里的所有列表项的存储形式，它甚至不强制存储所有的列表项，只要 ListModel的实现类提供了getSize()和 getElementAt()两个方法 ， JList 就可以根据该ListModel 对象来生成列表框 。ComboBoxModel 继承了 ListModel ，它添加了”选择项”的概念，选择项代表 JComboBox 显示区域内可见的列表项 。
在使用JList和JComboBox时，除了可以使用jdk提供的Model实现类，程序员自己也可以根据需求，自己定义Model的实现类，实现对应的方法使用。
案例：
自定义NumberListModel和NumberComboBoxModel实现类，允许使用数值范围来创建JList和JComboBox
ListModelTest.jpg
演示代码：

  1. import javax.swing.*;
  2. import java.math.BigDecimal;
  3. import java.math.RoundingMode;
  5. public class NumberListModel extends AbstractListModel<BigDecimal> {
  7.     protected BigDecimal start;
  8.     protected BigDecimal end;
  9.     protected BigDecimal step;
  12.     public NumberListModel(double start,double end,double step) {
  13.         this.start = new BigDecimal(start);
  14.         this.end = new BigDecimal(end);
  15.         this.step = new BigDecimal(step);
  16.     }
  18.     @Override
  19.     public int getSize() {
  20.         int floor = (int) Math.floor(end.subtract(start).divide(step,2, RoundingMode.HALF_DOWN).doubleValue());
  21.         return floor+1;
  22.     }
  24.     @Override
  25.     public BigDecimal getElementAt(int index) {
  26.         return BigDecimal.valueOf(index).multiply(step).add(start).setScale(1,RoundingMode.HALF_DOWN);
  27.     }
  28. }
  33. import javax.swing.*;
  34. import java.math.BigDecimal;
  35. import java.math.RoundingMode;
  37. public class NumberComboBoxModel extends NumberListModel implements ComboBoxModel<BigDecimal> {
  38.     //用于保存用户选中项的索引
  39.     private int selectId = 0;
  41.     public NumberComboBoxModel(double start, double end, double step) {
  42.         super(start, end, step);
  43.     }
  45.     //设置选择项
  46.     @Override
  47.     public void setSelectedItem(Object anItem) {
  48.         if (anItem instanceof BigDecimal){
  49.             BigDecimal target = (BigDecimal) anItem;
  50.             selectId = target.subtract(super.start).divide(super.step,2, RoundingMode.HALF_DOWN).intValue();
  51.         }
  52.     }
  54.     //获取选中项的索引
  55.     @Override
  56.     public BigDecimal getSelectedItem() {
  57.          return BigDecimal.valueOf(selectId).multiply(step).add(start).setScale(1,RoundingMode.HALF_DOWN);
  59.     }
  60. }
  63. import javax.swing.*;
  64. import javax.swing.event.ListSelectionEvent;
  65. import javax.swing.event.ListSelectionListener;
  66. import java.awt.*;
  67. import java.awt.event.ItemEvent;
  68. import java.awt.event.ItemListener;
  69. import java.math.BigDecimal;
  70. import java.util.List;
  72. public class ListModelTest {
  73.     JFrame mainWin = new JFrame("测试ListModel");
  75.     //根据NumberListModel对象创建一个JList
  76.     JList<BigDecimal> numScopeList = new JList<>(new NumberListModel(1,21,2));
  78.     //根据NumberComboBoxModel对象创建一个JComboBox
  79.     JComboBox<BigDecimal> numScopeSelector = new JComboBox<>(new NumberComboBoxModel(0.1,1.2,0.1));
  81.     JTextField showVal = new JTextField(10);
  83.     public void init(){
  84.         //JList可视高度可同时显示四个列表项
  85.         numScopeList.setVisibleRowCount(4);
  87.         //默认选中第三项到第五项
  88.         numScopeList.setSelectionInterval(2,4);
  90.         //设置每个列表项具有指定高度和宽度
  91.         numScopeList.setFixedCellHeight(30);
  92.         numScopeList.setFixedCellWidth(90);
  94.         //为numScopeList添加监听器
  95.         numScopeList.addListSelectionListener(new ListSelectionListener() {
  96.             @Override
  97.             public void valueChanged(ListSelectionEvent e) {
  98.                 //获取用户选中的所有数字
  99.                 List<BigDecimal> selectedValuesList = numScopeList.getSelectedValuesList();
  100.                 showVal.setText("");
  101.                 for (BigDecimal bigDecimal : selectedValuesList) {
  102.                     showVal.setText(showVal.getText()+bigDecimal.toString()+", ");
  103.                 }
  104.             }
  105.         });
  107.         //设置下拉列表的可视高度可显示5个列表项
  108.         numScopeSelector.setMaximumRowCount(5);
  110.         Box box = Box.createHorizontalBox();
  111.         box.add(new JScrollPane(numScopeList));
  113.         JPanel p = new JPanel();
  114.         p.add(numScopeSelector);
  115.         box.add(p);
  117.         //为numberScopeSelector添加监听器
  118.         numScopeSelector.addItemListener(new ItemListener() {
  119.             @Override
  120.             public void itemStateChanged(ItemEvent e) {
  121.                 Object value = numScopeSelector.getSelectedItem();
  122.                 showVal.setText(value.toString());
  123.             }
  124.         });
  127.         JPanel bottom = new JPanel();
  128.         bottom.add(new JLabel("您选择的值是："));
  129.         bottom.add(showVal);
  131.         mainWin.add(box);
  132.         mainWin.add(bottom, BorderLayout.SOUTH);
  133.         mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  134.         mainWin.pack();
  135.         mainWin.setVisible(true);
  137.     }
  139.     public static void main(String[] args) {
  140.         new ListModelTest().init();
  141.     }
  142. }

强制存储列表项的DefaultListModel和DefaultComboBoxModel

前面只是介绍了如何创建 JList 、 JComboBox 对象， 当 调用 JList 和 JComboBox构造方法时时传入数组或 Vector 作为参数，这些数组元素或集合元素将会作为列表项。当使用JList 或 JComboBox 时 常常还需要动态地增加、删除列表项,例如JCombox提供了下列方法完成增删操作：

  1. addItem(E item):添加一个列表项
  2. insertItemAt(E item, int index)：向指定索引处插入一个列表项
  3. removeAllItems()：删除所有列表项
  4. removeItem(Object anObject)：删除指定列表项
  5. removeItemAt(int anIndex)：删除指定索引处的列表项

JList 并没有提供这些类似的方法。如果需要创建一个可以增加、删除列表项的 JList 对象，则应该在创建 JLi st 时显式使用 DefaultListModel作为构造参数 。因为 DefaultListModel 作为 JList 的 Model，它负责维护 JList 组件的所有列表数据，所以可以通过向 DefaultListModel 中添加、删除元素来实现向 JList 对象中增加 、删除列表项 。DefaultListModel 提供了如下几个方法来添加、删除元素:

  1. add(int index, E element): 在该 ListModel 的指定位置处插入指定元素 。
  2. addElement(E obj): 将指定元素添加到该 ListModel 的末尾 。
  3. insertElementAt(E obj, int index): 在该 ListModel 的指定位置处插入指定元素 。
  4. Object remove(int index): 删除该 ListModel 中指定位置处的元素 
  5. removeAllElements(): 删 除该 ListModel 中的所有元素，并将其的大小设置为零 。
  6. removeElement(E obj): 删除该 ListModel 中第一个与参数匹配的元素。
  7. removeElementAt(int index): 删除该 ListModel 中指定索引处的元素 。
  8. removeRange(int 企omIndex ， int toIndex): 删除该 ListModel 中指定范围内的所有元素。
  9. set(int index, E element) : 将该 ListModel 指定索引处的元素替换成指定元素。
  10. setElementAt(E obj, int index): 将该 ListModel 指定索引处的元素替换成指定元素。

案例：
使用DefaultListModel完成下图效果：
DefaultListModel.jpg
演示代码：

  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.ActionEvent;
  4. import java.awt.event.ActionListener;
  6. public class DefaultListModelTest {
  8.     JFrame mainWin = new JFrame("测试DefaultListModel");
  10.     //定义一个JList对象
  11.     JList<String> bookList;
  12.     //定义一个DefaultListModel对象
  13.     DefaultListModel<String> bookModel = new DefaultListModel<>();
  15.     JTextField bookName = new JTextField(20);
  17.     JButton removeBtn = new JButton("删除选中图书");
  18.     JButton addBtn = new JButton("添加指定图书");
  20.     public void init(){
  21.         //向bookModel中添加元素
  22.         bookModel.addElement("java自学宝典");
  23.         bookModel.addElement("轻量级javaEE企业应用实战");
  24.         bookModel.addElement("Android基础教程");
  25.         bookModel.addElement("jQuery实战教程");
  26.         bookModel.addElement("SpringBoot企业级开发");
  28.         //根据DefaultListModel创建一个JList对象
  29.         bookList = new JList<>(bookModel);
  30.         //设置最大可视高度
  31.         bookList.setVisibleRowCount(4);
  33.         //设置只能单选
  34.         bookList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  36.         //为addBtn添加事件监听器
  37.         addBtn.addActionListener(new ActionListener() {
  38.             @Override
  39.             public void actionPerformed(ActionEvent e) {
  40.                 //当bookName文本框内容不为空时添加列表项
  41.                 if (!bookName.getText().trim().equals("")){
  43.                     bookModel.addElement(bookName.getText());
  44.                 }
  46.             }
  47.         });
  49.         //为removeBtn添加事件监听器
  50.         removeBtn.addActionListener(new ActionListener() {
  51.             @Override
  52.             public void actionPerformed(ActionEvent e) {
  53.                 int selectedIndex = bookList.getSelectedIndex();
  54.                 if (selectedIndex>=0){
  56.                     bookModel.remove(selectedIndex);
  57.                 }
  58.             }
  59.         });
  61.         JPanel p = new JPanel();
  62.         p.add(bookName);
  63.         p.add(addBtn);
  64.         p.add(removeBtn);
  66.         mainWin.add(new JScrollPane(bookList));
  67.         mainWin.add(p, BorderLayout.SOUTH);
  68.         mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  69.         mainWin.pack();
  70.         mainWin.setVisible(true);
  72.     }
  74.     public static void main(String[] args) {
  75.         new DefaultListModelTest().init();
  76.     }
  78. }

使用ListCellRenderer改变列表外观

前面程序中的 JList 和 JComboBox 采用的都是简单的字符串列表项， 实际上 ， JList 和 JComboBox还可以支持图标列表项，如果在创建 JList 或 JComboBox 时传入图标数组，则创建的 JList 和 JComboBox的列表项就是图标 。
如果希望列表项是更复杂 的组件，例如，希望像 QQ 程序那样每个列表项既有图标，此时需要使用ListCellRenderer接口的实现类对象，自定义每个条目组件的渲染过程：

  1. public interface ListCellRenderer<E>
  2. {
  3.     Component getListCellRendererComponent(
  4.         JList<? extends E> list,//列表组件
  5.         E value,//当前列表项的值额索引
  6.         int index,//当前列表项d
  7.         boolean isSelected,//当前列表项是否被选中
  8.         boolean cellHasFocus);//当前列表项是否获取了焦点
  9. }

通过JList的setCellRenderer(ListCellRenderer<? super E> cellRenderer)方法，把自定义的ListCellRenderer对象传递给JList，就可以按照自定义的规则绘制列表项组件了。
案例：
使用ListCellRenderer实现下图效果：
ListCellRenderer.jpg
演示代码：

  1. import cn.itcast.swing.util.ImagePathUtil;
  3. import javax.swing.*;
  4. import java.awt.*;
  6. public class ListCellRendererTest {
  8.     private JFrame mainWin = new JFrame("好友列表");
  10.     private String[] friends = {
  11.             "李清照",
  12.             "苏格拉底",
  13.             "李白",
  14.             "弄玉",
  15.             "虎头"
  16.     };
  18.     //定义一个JList对象
  19.     JList friendsList = new JList(friends);
  21.     public void init() {
  22.         //设置JList使用ImageCellRenderer作为列表项绘制器
  23.         friendsList.setCellRenderer(new ImageCellRenderer());
  25.         mainWin.add(new JScrollPane(friendsList));
  26.         mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  27.         mainWin.pack();
  28.         mainWin.setVisible(true);
  30.     }
  33.     public static void main(String[] args) {
  34.         new ListCellRendererTest().init();
  35.     }
  37.     class ImageCellRenderer extends JPanel implements ListCellRenderer {
  40.         private ImageIcon icon;
  41.         private String name;
  42.         //定义绘制单元格的背景色
  43.         private Color background;
  44.         //定义绘制单元格的前景色
  45.         private Color foreground;
  48.         @Override
  49.         public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
  51.             icon = new ImageIcon(ImagePathUtil.getRealPath("9\\" + value + ".gif"));
  52.             name = value.toString();
  53.             background = isSelected ? list.getSelectionBackground() : list.getBackground();
  54.             foreground = isSelected ? list.getSelectionForeground() : list.getForeground();
  56.             //返回当前JPanel对象，作为列表项绘制器
  57.             return this;
  58.         }
  60.         @Override
  61.         protected void paintComponent(Graphics g) {
  62.             int width = icon.getImage().getWidth(null);
  63.             int height = icon.getImage().getHeight(null);
  65.             //填充背景矩形
  66.             g.setColor(background);
  67.             g.fillRect(0,0,getWidth(),getHeight());
  69.             g.setColor(foreground);
  70.             //绘制好友头像
  71.             g.drawImage(icon.getImage(),getWidth()/2-width/2,10,null);
  73.             //绘制好友昵称
  74.             g.setFont(new Font("SansSerif",Font.BOLD,18));
  75.             g.drawString(name,getWidth()/2-name.length()*10,height+30);
  76.         }
  79.         @Override
  80.         public Dimension getPreferredSize() {
  81.             return new Dimension(60,80);
  82.         }
  83.     }
  84. }

JTree、TreeModel实现树

树也是图形用户界面中使用非常广泛的 GUI 组件，例如使用 Windows 资源管理器时，将看到如下图所示的目录树:
目录树.jpg
如上图所示的树，代表计算机世界里的树，它从自然界实际的树抽象而来 。 计算机世界里的树是由一系列具有严格父子关系的节点组成的，每个节点既可以是其上一级节点的子节点，也可以是其下一级节点的父节点，因此同一个节点既可以是父节点，也可以是子节点(类似于一个人，他既是他儿子的父亲，又是他父亲的儿子)。
按照结点是否包含子结点，可以把结点分为下面两类：
普通结点：包含子结点的结点；
叶子结点：没有子结点的结点；
按照结点是否具有唯一的父结点，可以把结点分为下面两类：
根结点：没有父结点的结点，计算机中，一棵树只能有一个根结点
普通结点：具有唯一父结点的结点
使用 Swing 里的 Jtree 、 TreeModel 及其相关的辅助类可以很轻松地开发出计算机世界里的树。

创建树

Swing 使用 JTree 对 象来代表一棵树，JTree 树中结点可以使用 TreePath 来标识，该对象封装了当前结点及其所有的父结点。
当一个结点具有子结点时，该结点有两种状态：
展开状态:当父结点处于展开状态时，其子结点是可见的；
折叠状态: 当父结点处于折叠状态时，其子结点都是不可见的 。
如果某个结点是可见的，则该结点的父结点(包括直接的、间接的父结点)都必须处于展开状态，只要有任意一个父结点处于折叠状态，该结点就是不可见的 。
JTree常用构造方法：

  1. JTree(TreeModel newModel):使用指定 的数据模型创建 JTree 对象，它默认显示根结点。
  2. JTree(TreeNode root): 使用 root 作为根节 点创建 JTree 对象，它默认显示根结点 。
  3. JTree(TreeNode root, boolean asksAllowsChildren): 使用root作为根结点创建JTree对象，它默认显示根结点。 asksAllowsChildren 参数控制怎样的结点才算叶子结点，如果该参数为 true ，则只有当程序使用 setAllowsChildren(false)显式设置某个结点不允许添加子结点时(以后也不会拥有子结点) ，该结点才会被 JTree 当成叶子结点:如果该参数为 false ，则只要某个结点当时没有子结点(不管以后是否拥有子结点) ，该结点都会被 JTree 当成叶子结点。

TreeNode继承体系及使用：
TreeNode.png
在构建目录树时，可以先创建很多DefaultMutableTreeNode对象，并调用他们的add方法构建好子父级结构，最后根据根结点构建一个JTree即可。
案例：
使用JTree和TreeNode完成下图效果：
SimpleJTree.jpg
演示代码：

  1. import javax.swing.*;
  2. import javax.swing.tree.DefaultMutableTreeNode;
  4. public class SimpleJTree {
  5.     JFrame jf = new JFrame("简单树");
  7.     JTree tree;
  8.     DefaultMutableTreeNode root;
  9.     DefaultMutableTreeNode guangdong;
  10.     DefaultMutableTreeNode guangxi;
  11.     DefaultMutableTreeNode foshan;
  12.     DefaultMutableTreeNode shantou;
  13.     DefaultMutableTreeNode guilin;
  14.     DefaultMutableTreeNode nanning;
  16.     public void init(){
  17.         //依次创建所有结点
  18.         root = new DefaultMutableTreeNode("中国");
  19.         guangdong = new DefaultMutableTreeNode("广东");
  20.         guangxi = new DefaultMutableTreeNode("广西");
  21.         foshan = new DefaultMutableTreeNode("佛山");
  22.         shantou = new DefaultMutableTreeNode("汕头");
  23.         guilin = new DefaultMutableTreeNode("桂林");
  24.         nanning = new DefaultMutableTreeNode("南宁");
  27.         //通过add()方法建立父子层级关系
  28.         guangdong.add(foshan);
  29.         guangdong.add(shantou);
  30.         guangxi.add(guilin);
  31.         guangxi.add(nanning);
  32.         root.add(guangdong);
  33.         root.add(guangxi);
  35.         //依据根结点，创建JTree
  36.         tree = new JTree(root);
  38.         jf.add(new JScrollPane(tree));
  39.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  40.         jf.pack();
  41.         jf.setVisible(true);
  43.     }
  46.     public static void main(String[] args) {
  47.         new SimpleJTree().init();
  48.     }
  49. }

JTree的其他外观设置方法：

  1. tree.putClientProperty( "JTree.lineStyle", "None"):设置结点之间没有连接线
  2. tree.putClientProperty("JTree.lineStyle" , "Horizontal")：设置结点之间只有水平分割线
  3. tree.setShowsRootHandles(true)：设置根结点有"展开、折叠"图标
  4. tree.setRootVisible(false)：隐藏根结点

DefaultMutableTreeNode其他成员方法：

  1. Enumeration breadthFirstEnumerationO/preorderEnumeration(): 按广度优先的顺序遍历以此结点为根的子树，并返回所有结点组成的枚举对象 。
  2. Enumeration depthFirstEnumerationO/postorderEnumeration(): 按深度优先的顺序遍历以此结点为根的子树，并返回所有结点组成的枚举对象 。
  3. DefaultMutableTreeNode getNextSibling(): 返回此结点的下一个兄弟结点 。
  4. TreeNode getParent(): 返回此结点的父结点 。 如果此结点没有父结点，则返回null 。
  5. TreeNode[] getPath(): 返回从根结点到达此结点的所有结点组成的数组。
  6. DefaultMutableTreeNode getPreviousSibling(): 返回此结点的上一个兄弟结点。
  7. TreeNode getRoot(): 返回包含此结点的树的根结点 。
  8. TreeNode getSharedAncestor(DefaultMutableTreeNode aNode): 返回此结点和aNode最近的共同祖先 。
  9. int getSiblingCount(): 返回此结点的兄弟结点数 。
  10. boolean isLeaf(): 返回该结点是否是叶子结点 。
  11. boolean isNodeAncestor(TreeNode anotherNode): 判断anotherNode是否是当前结点的祖先结点(包括父结点) 。
  12. boolean isNodeChild(TreeNode aNode): 如果aNode是此结点的子结点，则返回true。
  13. boolean isNodeDescendant(DefaultMutableTreeNode anotherNode): 如果 anotherNode 是此结点的后代，包括是此结点本身、此结点的子结点或此结点的子结点的后代，都将返回true 。
  14. boolean isNodeRelated(DefaultMutableTreeNode aNode) : 当aNode和当前结点位于同一棵树中时返回 true 。
  15. boolean isNodeSibling(TreeNode anotherNode): 返回anotherNode是否是当前结点的兄弟结点 。
  16. boolean isRoot(): 返回当前结点是否是根结点 。
  17. Enumeration pathFromAncestorEnumeration(TreeNode ancestor): 返回从指定祖先结点到当前结点的所有结点组成的枚举对象 。

拖动、编辑树结点

JTree 生成的树默认是不可编辑的，不可以添加、删除结点，也不可以改变结点数据 :如果想让某个 JTree 对象变成可编辑状态，则可以调用 JTree 的setEditable(boolean b)方法，传入 true 即可把这棵树变成可编辑的树(可以添加、删除结点，也可以改变结点数据) 。
编辑树结点的步骤：

  1. 获取当前被选中的结点：
    1. 获取当前被选中的结点，会有两种方式：
    2.  一：
    3.      通过JTree对象的某些方法，例如 TreePath getSelectionPath()等，得到一个TreePath对象，包含了从根结点到当前结点路径上的所有结点；
    4.      调用TreePath对象的 Object getLastPathComponent()方法，得到当前选中结点
    5.  二：
    6.      调用JTree对象的 Object getLastSelectedPathComponent() 方法获取当前被选中的结点
    调用DefaultTreeModel数据模型有关增删改的一系列方法完成编辑，方法执行完后，会自动重绘JTree
    案例：
    使用JTree以及DefaultTreeModel、DefaultMutableTreeNode、TreePath完成下图效果：
    EditTree.jpg
    演示代码： ```java import javax.swing.; import javax.swing.tree.; import java.awt.*; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import java.awt.event.MouseListener;

public class EditTree {

  1. JFrame jf ;
  2. JTree tree;
  4. //JTree关联的数据模型对象
  5. DefaultTreeModel model;
  7. //定义几个初始结点
  8. DefaultMutableTreeNode root = new DefaultMutableTreeNode("中国");
  9. DefaultMutableTreeNode guangdong = new DefaultMutableTreeNode("广东");
  10. DefaultMutableTreeNode guangxi = new DefaultMutableTreeNode("广西");
  11. DefaultMutableTreeNode foshan = new DefaultMutableTreeNode("佛山");
  12. DefaultMutableTreeNode shantou = new DefaultMutableTreeNode("汕头");
  13. DefaultMutableTreeNode guilin = new DefaultMutableTreeNode("桂林");
  14. DefaultMutableTreeNode nanning = new DefaultMutableTreeNode("南宁");
  16. //定义需要被拖动的TreePath
  17. TreePath movePath;
  19. //定义按钮，完成操作
  20. JButton addSiblingBtn = new JButton("添加兄弟结点");
  21. JButton addChildBtn = new JButton("添加子结点");
  22. JButton deleteBtn = new JButton("删除结点");
  23. JButton editBtn = new JButton("编辑当前结点");
  25. public void init(){
  27.     //通过add()方法建立父子层级关系
  28.     guangdong.add(foshan);
  29.     guangdong.add(shantou);
  30.     guangxi.add(guilin);
  31.     guangxi.add(nanning);
  32.     root.add(guangdong);
  33.     root.add(guangxi);
  35.     jf = new JFrame("可编辑结点的树");
  36.     tree = new JTree(root);
  38.     //获取JTree关联的数据模型TreeModel对象
  39.     model = (DefaultTreeModel) tree.getModel();
  41.     //设置JTree可编辑
  42.     tree.setEditable(true);
  44.     //创建鼠标事件监听器
  45.     MouseListener ml = new MouseAdapter() {
  47.         //按下鼠标时，获得被拖动的结点
  48.         @Override
  49.         public void mousePressed(MouseEvent e) {
  50.             //如果需要唯一确定某个结点，则必须通过TreePath来获取
  51.             TreePath tp = tree.getPathForLocation(e.getX(), e.getY());
  52.             if (tp!=null){
  53.                 movePath = tp;
  54.             }
  55.         }
  57.         //松开树表示，确定即将被拖入到的父结点
  58.         @Override
  59.         public void mouseReleased(MouseEvent e) {
  61.             TreePath tp = tree.getPathForLocation(e.getX(), e.getY());
  62.             if (tp!=null && movePath!=null){
  63.                 //阻止向子结点拖动
  64.                 if (movePath.isDescendant(tp) && movePath!=tp){
  65.                     JOptionPane.showMessageDialog(jf,"目标结点是被移动结点的子结点，无法移动！","非法移动",JOptionPane.WARNING_MESSAGE);
  66.                 }
  67.                 //不是向子结点移动，并且鼠标按下和松开也不是同一个结点
  69.                 if (movePath!=tp){
  70.                     //add方法内部，先将该结点从原父结点删除，然后再把该结点添加到新结点中
  71.                     DefaultMutableTreeNode tartParentNode = (DefaultMutableTreeNode) tp.getLastPathComponent();
  72.                     DefaultMutableTreeNode moveNode = (DefaultMutableTreeNode) movePath.getLastPathComponent();
  73.                     tartParentNode.add(moveNode);
  75.                     movePath=null;
  76.                     tree.updateUI();
  77.                 }
  78.             }
  79.         }
  80.     };
  82.     //为JTree添加鼠标监听器
  83.     tree.addMouseListener(ml);
  85.     JPanel panel = new JPanel();
  87.     addSiblingBtn.addActionListener(e -> {
  88.         //获取选中结点
  89.         DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
  91.         //如果结点为空，则直接返回
  92.         if (selectedNode==null){
  93.             return;
  94.         }
  96.         //获取该选中结点的父结点
  97.         DefaultMutableTreeNode parent = (DefaultMutableTreeNode) selectedNode.getParent();
  99.         //如果父结点为空，则直接返回
  100.         if (parent==null){
  101.             return;
  102.         }
  104.         //创建一个新结点
  105.         DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("新结点");
  107.         //获取选中结点的索引
  108.         int selectedIndex = parent.getIndex(selectedNode);
  110.         //在选中位置插入新结点
  111.         model.insertNodeInto(newNode,parent,selectedIndex);
  113.         //----------显示新结点---------------
  114.         //获取从根结点到新结点的所有结点
  115.         TreeNode[] pathToRoot = model.getPathToRoot(newNode);
  117.         //使用指定的结点数组创建TreePath
  118.         TreePath treePath = new TreePath(pathToRoot);
  120.         //显示指定的treePath
  121.         tree.scrollPathToVisible(treePath);
  124.     });
  126.     panel.add(addSiblingBtn);
  128.     addChildBtn.addActionListener(e -> {
  129.         //获取选中结点
  130.         DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
  132.         if (selectedNode==null){
  133.             return ;
  134.         }
  136.         //创建新结点
  137.         DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("新结点");
  139.         //model.insertNodeInto(newNode,selectedNode,selectedNode.getChildCount());使用TreeModel的方法添加，不需要手动刷新UI
  140.         selectedNode.add(newNode);//使用TreeNode的方法添加，需要手动刷新UI
  142.         //显示新结点
  144.         TreeNode[] pathToRoot = model.getPathToRoot(newNode);
  145.         TreePath treePath = new TreePath(pathToRoot);
  146.         tree.scrollPathToVisible(treePath);
  148.         //手动刷新UI
  149.         tree.updateUI();
  151.     });
  153.     panel.add(addChildBtn);
  155.     deleteBtn.addActionListener(e -> {
  157.         DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
  159.         if (selectedNode!=null && selectedNode.getParent()!=null){
  160.             model.removeNodeFromParent(selectedNode);
  161.         }
  163.     });
  165.     panel.add(deleteBtn);
  167.     //实现编辑结点的监听器
  168.     editBtn.addActionListener(e -> {
  170.         TreePath selectionPath = tree.getSelectionPath();
  172.         if (selectionPath!=null){
  173.             //编辑选中结点
  174.             tree.startEditingAtPath(selectionPath);
  175.         }
  177.     });
  179.     panel.add(editBtn);
  181.     jf.add(new JScrollPane(tree));
  182.     jf.add(panel, BorderLayout.SOUTH);
  184.     jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  185.     jf.pack();
  186.     jf.setVisible(true);
  188. }
  190. public static void main(String[] args) {
  191.     new EditTree().init();
  192. }

}

  1. <a name="RZxV2"></a>
  2. ### 监听结点事件
  3. **修改JTree的选择模式：**<br />JTree 专门提供了 一个 TreeSelectionModel 对象来保存该 JTree 选中状态的信息 。 也就是说，JTree组件背后隐藏了两个 model 对象 ， 其中TreeModel 用于保存该 JTree 的所有节点数据 ， 而TreeSelectionModel 用于保存该 JTree的所有选中状态的信息 。
  5. 程序可以改变 JTree 的选择模式 ， 但必须先获取该 JTree 对应的 TreeSelectionMode1 对象 ， 再调用该对象的 setSelectionMode(int mode);方法来设置该JTree的选择模式 ，其中model可以有如下3种取值：
  7. 1. TreeSelectionModel.CONTIGUOUS_TREE_SELECTION: 可 以连续选中多个 TreePath 。
  8. 2. TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION : 该选项对于选择没有任何限制 。
  9. 3. TreeSelectionModel.SINGLE_TREE_SELECTION: 每次只能选择一个 TreePath 。
  11. **为JTree添加监听器:**
  13. 1. addTreeExpansionListener(TreeExpansionListener tel) : 添加树节点展开/折叠事件的监听器。
  14. 2. addTreeSelectionListener(TreeSelectionListener tsl) : 添加树节点选择事件的监听器。
  16. **案例：**<br />实现下图效果：<br />![SelectJTree.jpg](https://cdn.nlark.com/yuque/0/2021/jpeg/22782459/1634606636429-b49c8359-930f-49fd-a910-0d675491cace.jpeg#clientId=uda3b1a02-d789-4&from=drop&id=u4fe1f223&originHeight=500&originWidth=572&originalType=binary&ratio=1&rotation=0&showTitle=false&size=41471&status=done&style=none&taskId=u9e9fdcd1-9110-432d-9985-9dfe7feb63a&title=)<br />**演示代码：**
  17. ```java
  18. import javax.swing.*;
  19. import javax.swing.tree.DefaultMutableTreeNode;
  21. public class SelectJTree {
  22.     JFrame jf = new JFrame("监听树的选择事件");
  24.     JTree tree;
  26.     DefaultMutableTreeNode root = new DefaultMutableTreeNode("中国");
  27.     DefaultMutableTreeNode guangdong = new DefaultMutableTreeNode("广东");
  28.     DefaultMutableTreeNode guangxi = new DefaultMutableTreeNode("广西");
  29.     DefaultMutableTreeNode foshan = new DefaultMutableTreeNode("佛山");
  30.     DefaultMutableTreeNode shantou = new DefaultMutableTreeNode("汕头");
  31.     DefaultMutableTreeNode guilin = new DefaultMutableTreeNode("桂林");
  32.     DefaultMutableTreeNode nanning = new DefaultMutableTreeNode("南宁");
  34.     JTextArea eventTxt = new JTextArea(5, 20);
  36.     public void init() {
  38.         //通过add()方法建立父子层级关系
  39.         guangdong.add(foshan);
  40.         guangdong.add(shantou);
  41.         guangxi.add(guilin);
  42.         guangxi.add(nanning);
  43.         root.add(guangdong);
  44.         root.add(guangxi);
  46.         tree = new JTree(root);
  48.         //添加监听器
  49.         tree.addTreeSelectionListener(e -> {
  50.             if (e.getOldLeadSelectionPath()!=null){
  51.                 eventTxt.append("原选中结点的路径："+e.getOldLeadSelectionPath().toString()+"\n");
  52.             }
  54.             eventTxt.append("新选中结点的路径："+e.getNewLeadSelectionPath().toString()+"\n");
  55.         });
  57.         tree.setShowsRootHandles(true);
  58.         tree.setRootVisible(true);
  60.         Box box = Box.createHorizontalBox();
  61.         box.add(new JScrollPane(tree));
  62.         box.add(new JScrollPane(eventTxt));
  64.         jf.add(box);
  65.         jf.pack();
  66.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  67.         jf.setVisible(true);
  68.     }
  70.     public static void main(String[] args) {
  71.         new SelectJTree().init();
  72.     }
  73. }

使用DefaultTreeCellRenderer改变结点外观

JTree默认的外观是比较单一的，它提供了如下几种改变结点外观的方式：

  1. 使用 DefaultTreeCellRenderer 直接改变节点的外观，这种方式可 以 改变整棵树所有节点 的字体、颜色和图标 。
  2. 为 JTree 指定 DefaultTreeCellRenderer 的扩展类对象作为 JTree 的节点绘制器，该绘制器负责为不同节点使用不同的字体、颜色和图标。通常使用这种方式来改变节点的外观 。
  3. 为 JTree 指定一个实现 TreeCellRenderer 接口的节点绘制器，该绘制器可以为不同的节点自由绘制任意内容，这是最复杂但最灵活的节点绘制器 。

第 一种方式最简单 ， 但灵活性最差 ，因为它会改变整棵树所有节点的外观 。 在这种情况下 ， Jtree的所有节点依然使用相同的图标 ，相当于整体替换了 Jtree 中 节点的所有默认图标 。 用户指定 的节点图标未必就比 JTree 默认的图标美观 。
DefaultTreeCellRenderer 提供了如下几个方法来修改节点的外观：

  1. setBackgroundNonSelectionColor(Color newColor): 设置用于非选定节点的背景颜色 。
  2. setBackgroundSelectionColor(Color newColor): 设置节点在选中状态下的背景颜色 。
  3. setBorderSelectionColor(Color newColor): 设置选中状态下节点的边框颜色 。
  4. setClosedIcon(Icon newIcon): 设置处于折叠状态下非叶子节点的图标 。
  5. setFont(Font font) : 设置节点文本 的 字体。
  6. setLeaflcon(Icon newIcon): 设置叶子节点的图标 。
  7. setOpenlcon(Icon newlcon): 设置处于展开状态下非叶子节 点的图标。
  8. setTextNonSelectionColor(Color newColor): 设置绘制非选中状态下节点文本的颜色 。
  9. setTextSelectionColor(Color newColor): 设置绘制选中状态下节点文本的颜色 。

案例：
使用DefaultTreeCellRenderer完成下图效果：
CellRender1.jpg
演示代码：

  1. import cn.itcast.swing.util.ImagePathUtil;
  3. import javax.swing.*;
  4. import javax.swing.tree.DefaultMutableTreeNode;
  5. import javax.swing.tree.DefaultTreeCellRenderer;
  6. import java.awt.*;
  8. public class ChangeAllCellRender {
  10.     JFrame jf = new JFrame("改变所有结点外观");
  12.     JTree tree;
  14.     DefaultMutableTreeNode root = new DefaultMutableTreeNode("中国");
  15.     DefaultMutableTreeNode guangdong = new DefaultMutableTreeNode("广东");
  16.     DefaultMutableTreeNode guangxi = new DefaultMutableTreeNode("广西");
  17.     DefaultMutableTreeNode foshan = new DefaultMutableTreeNode("佛山");
  18.     DefaultMutableTreeNode shantou = new DefaultMutableTreeNode("汕头");
  19.     DefaultMutableTreeNode guilin = new DefaultMutableTreeNode("桂林");
  20.     DefaultMutableTreeNode nanning = new DefaultMutableTreeNode("南宁");
  22.     public void init(){
  23.         //通过add()方法建立父子层级关系
  24.         guangdong.add(foshan);
  25.         guangdong.add(shantou);
  26.         guangxi.add(guilin);
  27.         guangxi.add(nanning);
  28.         root.add(guangdong);
  29.         root.add(guangxi);
  31.         tree = new JTree(root);
  33.         //创建一个DefaultTreeCellRenderer对象
  34.         DefaultTreeCellRenderer cellRenderer = new DefaultTreeCellRenderer();
  35.         //设置非选定结点的背景颜色
  36.         cellRenderer.setBackgroundNonSelectionColor(new Color(220,220,220));
  37.         //设置选中结点的背景色
  38.         cellRenderer.setBackgroundSelectionColor(new Color(140,140,140));
  39.         //设置选中状态下结点的边框颜色
  40.         cellRenderer.setBorderSelectionColor(Color.BLACK);
  41.         //设置处于折叠状态下非叶子结点的图标
  42.         cellRenderer.setClosedIcon(new ImageIcon(ImagePathUtil.getRealPath("10\\close.gif")));
  43.         //设置结点文本的字体
  44.         cellRenderer.setFont(new Font("SansSerif",Font.BOLD,16));
  45.         //设置叶子结点图标
  46.         cellRenderer.setLeafIcon(new ImageIcon(ImagePathUtil.getRealPath("10\\leaf.png")));
  47.         //设置处于展开状态下非叶子结点图标跑
  48.         cellRenderer.setOpenIcon(new ImageIcon(ImagePathUtil.getRealPath("10\\open.gif")));
  49.         //设置绘制非选中状态下结点文本颜色
  50.         cellRenderer.setTextNonSelectionColor(new Color(255,0,0));
  51.         //设置选中状态下结点的文本颜色
  52.         cellRenderer.setTextSelectionColor(new Color(0,0,255));
  54.         tree.setCellRenderer(cellRenderer);
  56.         tree.setShowsRootHandles(true);
  58.         tree.setRootVisible(true);
  60.         jf.add(new JScrollPane(tree));
  61.         jf.pack();
  62.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  63.         jf.setVisible(true);
  65.     }
  68.     public static void main(String[] args) {
  69.         new ChangeAllCellRender().init();
  70.     }
  72. }

扩展DefaultTreeCellRenderer改变结点外观

DefaultTreeCellRenderer 实现类实现了TreeCellRenderer接口，该接口里只有 一个用于绘制节点内容的方法: getTreeCellRendererComponent() ， 该方法负责绘制 JTree 节点 。学习JList的时候，如果要绘制JList的列表项外观的内容，需要实现ListCellRenderer 接口，通过重写getTreeCellRendererComponent()方法返回一个Component 对象 ， 该对象就是 JTree 的节点组件 。两者之间非常类似
DefaultTreeCellRende rer 类继承了JLabel，实现 getTreeCellRendererComponent()方法时返回 this ，即返回一个特殊的 JLabel 对象 。 如果需要根据节点内容来改变节点的外观，则可以再次扩展DefaultTreeCellRenderer 类，并再次重写它提供的 getTreeCellRendererComponent()方法。
案例：
自定义类继承DefaultTreeCellRenderer,重写getTreeCellRendererComponent()方法，实现下图效果：
扩展DefaultTreeCellRenderer.jpg
演示代码：

  1. import cn.itcast.swing.util.ImagePathUtil;
  3. import javax.swing.*;
  4. import javax.swing.tree.DefaultMutableTreeNode;
  5. import javax.swing.tree.DefaultTreeCellRenderer;
  6. import java.awt.*;
  8. public class ExtendsDefaultCellTreeRenderer {
  10.     JFrame jf = new JFrame("根据结点类型定义图标");
  12.     JTree tree;
  14.     //定义几个初始结点
  15.     DefaultMutableTreeNode root = new DefaultMutableTreeNode(new NodeData(DBObjectType.ROOT,"数据库导航"));
  16.     DefaultMutableTreeNode salaryDb = new DefaultMutableTreeNode(new NodeData(DBObjectType.DATABASE,"公司工资数据库"));
  17.     DefaultMutableTreeNode customerDb = new DefaultMutableTreeNode(new NodeData(DBObjectType.DATABASE,"公司客户数据库"));
  18.     DefaultMutableTreeNode employee = new DefaultMutableTreeNode(new NodeData(DBObjectType.TABLE,"员工表"));
  19.     DefaultMutableTreeNode attend = new DefaultMutableTreeNode(new NodeData(DBObjectType.TABLE,"考勤表"));
  20.     DefaultMutableTreeNode concat = new DefaultMutableTreeNode(new NodeData(DBObjectType.TABLE,"联系方式表"));
  21.     DefaultMutableTreeNode id = new DefaultMutableTreeNode(new NodeData(DBObjectType.INDEX,"员工ID"));
  22.     DefaultMutableTreeNode name = new DefaultMutableTreeNode(new NodeData(DBObjectType.COLUMN,"姓名"));
  23.     DefaultMutableTreeNode gender = new DefaultMutableTreeNode(new NodeData(DBObjectType.COLUMN,"性别"));
  25.     public void init(){
  26.         //通过结点的add方法，建立结点的父子关系
  28.         root.add(salaryDb);
  29.         root.add(customerDb);
  31.         salaryDb.add(employee);
  32.         salaryDb.add(attend);
  34.         customerDb.add(concat);
  36.         concat.add(id);
  37.         concat.add(name);
  38.         concat.add(gender);
  40.         tree = new JTree(root);
  42.         tree.setCellRenderer(new MyRenderer());
  44.         tree.setShowsRootHandles(true);
  45.         tree.setRootVisible(true);
  47.         //设置使用windows外观风格
  48.         try {
  49.             UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
  50.         } catch (Exception e) {
  51.             e.printStackTrace();
  52.         }
  54.         //更新JTree的UI外观
  55.         SwingUtilities.updateComponentTreeUI(tree);
  57.         jf.add(new JScrollPane(tree));
  58.         jf.pack();
  59.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  60.         jf.setVisible(true);
  62.     }
  64.     public static void main(String[] args) {
  65.         new ExtendsDefaultCellTreeRenderer().init();
  66.     }
  68.     class MyRenderer extends DefaultTreeCellRenderer{
  69.         //初始化5个图标
  70.         ImageIcon rootIcon = new ImageIcon(ImagePathUtil.getRealPath("10\\root.gif"));
  71.         ImageIcon databaseIcon = new ImageIcon(ImagePathUtil.getRealPath("10\\database.gif"));
  72.         ImageIcon tableIcon = new ImageIcon(ImagePathUtil.getRealPath("10\\table.gif"));
  73.         ImageIcon columnIcon = new ImageIcon(ImagePathUtil.getRealPath("10\\column.gif"));
  74.         ImageIcon indexIcon = new ImageIcon(ImagePathUtil.getRealPath("10\\index.gif"));
  76.         @Override
  77.         public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) {
  78.             //执行父类默认的绘制结点操作
  79.             super.getTreeCellRendererComponent(tree,value,sel,expanded,leaf,row,hasFocus);
  80.             DefaultMutableTreeNode  node = (DefaultMutableTreeNode) value;
  82.             NodeData data = (NodeData) node.getUserObject();
  83.             //根据结点数据中的nodeType决定结点的图标
  84.             ImageIcon icon = null;
  85.             switch (data.nodeType){
  86.                 case DBObjectType.ROOT:
  87.                     icon = rootIcon;
  88.                     break;
  89.                 case DBObjectType.DATABASE:
  90.                     icon = databaseIcon;
  91.                     break;
  92.                 case DBObjectType.TABLE:
  93.                     icon = tableIcon;
  94.                     break;
  95.                 case DBObjectType.COLUMN:
  96.                     icon = columnIcon;
  97.                     break;
  98.                 case DBObjectType.INDEX:
  99.                     icon = indexIcon;
  100.                     break;
  101.             }
  103.             //改变图标
  104.             this.setIcon(icon);
  106.             return this;
  107.         }
  108.     }
  111.     //定义一个NodeData类，用于封装结点数据
  112.     class NodeData{
  113.         public int nodeType;
  114.         public String nodeData;
  116.         public NodeData(int nodeType, String nodeData) {
  117.             this.nodeType = nodeType;
  118.             this.nodeData = nodeData;
  119.         }
  121.         @Override
  122.         public String toString() {
  123.             return this.nodeData;
  124.         }
  125.     }
  127.     //定义一个接口，该接口里包含数据库对象类型的常量
  128.     interface  DBObjectType{
  129.         int ROOT=0;
  130.         int DATABASE=1;
  131.         int TABLE=2;
  132.         int COLUMN=3;
  133.         int INDEX=4;
  134.     }
  136. }

实现TreeCellRenderer接口改变结点外观

这种改变结点外观的方式是最灵活的，程序实现TreeCellRenderer接口时同样需要实现getTreeCellRendererComponent()方法，该方法可以返回任意类型的组件，该组件将作为JTree的结点。通过这种方式可以最大程度的改变结点的外观。
案例：
自定义类，继承JPanel类，实现TreeCellRenderer接口，完成下图效果：
TreeCellRenderer.jpg
演示代码：

  1. import cn.itcast.swing.util.ImagePathUtil;
  3. import javax.swing.*;
  4. import javax.swing.tree.DefaultMutableTreeNode;
  5. import javax.swing.tree.TreeCellRenderer;
  6. import java.awt.*;
  8. public class CustomerTreeNode {
  10.     JFrame jf = new JFrame("定制树的结点");
  12.     JTree tree;
  14.     //定义几个初始结点
  16.     DefaultMutableTreeNode friends = new DefaultMutableTreeNode("我的好友");
  17.     DefaultMutableTreeNode qingzhao = new DefaultMutableTreeNode("李清照");
  18.     DefaultMutableTreeNode suge = new DefaultMutableTreeNode("苏格拉底");
  19.     DefaultMutableTreeNode libai = new DefaultMutableTreeNode("李白");
  20.     DefaultMutableTreeNode nongyu = new DefaultMutableTreeNode("弄玉");
  21.     DefaultMutableTreeNode hutou = new DefaultMutableTreeNode("虎头");
  23.     public void init() {
  25.         friends.add(qingzhao);
  26.         friends.add(suge);
  27.         friends.add(libai);
  28.         friends.add(nongyu);
  29.         friends.add(hutou);
  31.         tree = new JTree(friends);
  33.         tree.setShowsRootHandles(true);
  34.         tree.setRootVisible(true);
  37.         tree.setCellRenderer(new ImageCellRenderer());
  41.         jf.add(new JScrollPane(tree));
  42.         jf.pack();
  43.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  44.         jf.setVisible(true);
  46.     }
  48.     public static void main(String[] args) {
  49.         new CustomerTreeNode().init();
  50.     }
  53.     class ImageCellRenderer extends JPanel implements TreeCellRenderer {
  55.         private ImageIcon icon;
  56.         private String name;
  57.         //定义绘制单元格时的背景色
  58.         private Color background;
  59.         //定义绘制单元格时的前景色
  60.         private Color foreground;
  63.         @Override
  64.         public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
  65.             icon = new ImageIcon(ImagePathUtil.getRealPath("10\\" + value + ".gif"));
  67.             name = value.toString();
  69.             background = hasFocus ? new Color(140, 200, 235) : new Color(255, 255, 255);
  70.             foreground = hasFocus ? new Color(255,255,3) : new Color(0,0,0);
  71.             //返回当前JPanel作为结点
  72.             return this;
  73.         }
  75.         //重写paintComponent改变JPanel的外观
  77.         @Override
  78.         protected void paintComponent(Graphics g) {
  79.             int imageWidth = icon.getImage().getWidth(null);
  80.             int imageHeight = icon.getImage().getHeight(null);
  81.             g.setColor(background);
  82.             g.fillRect(0,0,getWidth(),getHeight());
  84.             g.setColor(foreground);
  85.             //绘制好友图标
  86.             g.drawImage(icon.getImage(),getWidth()/2-imageWidth/2,10,null);
  88.             //绘制好友姓名
  89.             g.setFont(new Font("SansSerif",Font.BOLD,18));
  91.             g.drawString(name,getWidth()/2-name.length()*10,imageHeight+30);
  93.         }
  96.         //设置当前组件结点最佳大小
  97.         @Override
  98.         public Dimension getPreferredSize() {
  99.             return new Dimension(80,80);
  100.         }
  101.     }
  102. }

JTable、TableModel实现表格

表格也是GUI程序中常用的组件，表格是一个由多行、多列组成的二维显示区 。 Swing 的 JTable 以及相关类提供了这种表格支持 ， 通过使用 JTable 以及相关类，程序既可以使用简单的代码创建出表格来显示二维数据，也可以开发出功能丰富的表格，还可以为表格定制各种显示外观、编辑特性 。

创建简单表格

使用JTable创建简单表格步骤:

  1. 创建一个一维数组，存储表格中每一列的标题
  2. 创建一个二维数组，存储表格中每一行数据，其中二维数组内部的每个一维数组，代表表格中的一行数据
  3. 根据第一步和第二步创建的一维数组和二维数组，创建JTable对象
  4. 把JTable添加到其他容器中显示

案例：
使用JTable实现下图效果：
SimpleTable.jpg
演示代码：

  1. import javax.swing.*;
  3. public class SimpleTable {
  5.     JFrame jf = new JFrame("简单表格");
  7.     JTable table;
  9.     //定义二维数组作为表格数据
  11.     Object[][] tableData = {
  13.             new Object[]{"李清照",29,"女"},
  14.             new Object[]{"苏格拉底",56,"男"},
  15.             new Object[]{"李白",35,"男"},
  16.             new Object[]{"弄玉",18,"女"},
  17.             new Object[]{"虎头",2,"男"},
  19.     };
  21.     //定义一个一维数组，作为列标题
  22.     Object[] columnTitle = {"姓名","年龄","性别"};
  24.     public void init(){
  25.         //以二维数组和一维数组来创建一个JTable对象
  27.         table = new JTable(tableData,columnTitle);
  29.         jf.add(new JScrollPane(table));
  30.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  31.         jf.pack();
  32.         jf.setVisible(true);
  33.     }
  35.     public static void main(String[] args) {
  36.         new SimpleTable().init();
  37.     }
  38. }

在上面实现的简单表格中，大概有如下几个功能：

  1. 当表格高度不足以显示所有的数据行时，该表格会自动显示滚动条 。
  2. 把鼠标移动到两列之间的分界符时，鼠标形状会变成可调整大小的形状，表明用户可以自由调整表格列的大小 。
  3. 在表格列上按下鼠标并拖动时，可以将表格的整列拖动到其他位置 。
  4. 当单击某一个单元格时，系统会自动选中该单元格所在的行 。
  5. 当双击某一个单元格时，系统会自动进入该单元格的修改状态 。

JTable调整列：
JTable提供了一个setAutoResizeMode(int mode)方法用来调整表格的格式，该方法可以接收下面几个值：

  1. JTable.AUTO_RESIZE_OFF: 关闭表格的自动调整功能。当调整某一列的宽度时，其他列的宽度不会发生变化；
  2. JTable.AUTO_RESIZE_NEXT_COLUMN:只调整下一列的宽度，其他列及表格的宽度不会发生改变；
  3. JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS:平均调整当前列后面所有列的宽度，当前列的前面所有列及表格的宽度都不会发生变化，这是默认的调整方式
  4. JTable.AUTO_RESIZE_LAST_COLUMN:只调整最后一列的宽度，其他列及表格的宽度不会发生变化；
  5. JTable.AUTO_RESIZE_ALL_COLUMNS:平均调整表格中所有列的宽度，表格的宽度不会发生改变

如果需要精确控制每一列的宽度，则可通过 TableColumn 对象来实现 。 JTable 使用 TableColumn 来表示表格中的每一列， JTable 中表格列的所有属性，如最佳宽度、是否可调整宽度、最小和最大宽度等都保存在该 TableColumn 中 。 此外， TableColumn 还允许为该列指定特定的单元格绘制器和单元格编辑器(这些内容将在后面讲解) 。 TableColumn 具有如下方法 。

  1. setMaxWidth(int maxWidth): 设置该列的最大宽度 。 如果指定的 maxWidth 小于该列的最小宽度， 则 maxWidth 被设置成最小宽度 。
  2. setMinWidth(int minWidth): 设置该列的最小宽度 。
  3. setPreferredWidth(int preferredWidth): 设置该列的最佳宽度 。
  4. setResizable(boolean isResizable): 设置是否可以调整该列的 宽度 。
  5. sizeWidthToFit(): 调整该列的宽度，以适合其标题单元格的 宽度 。

JTable调整选择模式：

  1. 选则行：JTable默认的选择方式就是选择行，也可以调用setRowSelectionAllowed(boolean rowSelectionAllowed)来修改；
  2. 选择列：调用 setColumnSelectionAllowed(boolean columnSelectionAllowed)方法，修改当前JTable的选择模式为列；
  3. 选择单元格：setCellSelectionEnabled(boolean cellSelectionEnabled) ，修改当前JTable的选择模式为单元格；

JTable调整表格选择状态：
与 JList 、 JTree 类似的是， JTable 使用了 一个 ListSelectionModel 表示该表格的选择状态，程序可以 通过 ListSelectionModel 来控制 JTable 的选择模式 。 JTable 的选择模式有如下三种：

  1. ListSelectionMode.MULTIPLE_INTERVAL_SELECTION:没有任何限制，可以选择表格中任何表格单元，这是默认的选择模式 。 通过 Shi负和 Ctrl 辅助键的帮助可以选择多个表格单元 。
  2. ListSelectionMode.SINGLE_INTERVAL_SELECTION:选择单个连续区域，该选项可以选择多个表格单元，但多个表格单元之间必须是连续的 。 通过 Shift 辅助键的帮助来选择连续区域。
  3. ListSelectionMode.SINGLE_SELECTION:只能选择单个表格单元 。

案例：
通过JTable实现的宽度调整，选择模式调整，选择状态调整，实现下图效果：
adjust1.png
adjust2.png
adjust3.png
演示代码：

  1. import javax.swing.*;
  2. import javax.swing.table.TableColumn;
  4. public class AdjustingWidth {
  6.     JFrame jf = new JFrame("调整表格宽度");
  8.     JMenuBar menuBar = new JMenuBar();
  10.     JMenu adjustModeMenu = new JMenu("调整方式");
  11.     JMenu selectUnitMenu = new JMenu("选择单元");
  12.     JMenu selectModeMenu = new JMenu("选择方式");
  14.     //定义5个单选框按钮，用以控制表格的宽度调整方式
  15.     JRadioButtonMenuItem[] adjustModeItem = new JRadioButtonMenuItem[5];
  17.     //定义3个单选框按钮，用以控制表格的选择方式
  18.     JRadioButtonMenuItem[] selectModeItem = new JRadioButtonMenuItem[3];
  20.     //定义复选菜单项，控制选择单元
  21.     JCheckBoxMenuItem rowsItem = new JCheckBoxMenuItem("选择行");
  22.     JCheckBoxMenuItem columnItem = new JCheckBoxMenuItem("选择列");
  23.     JCheckBoxMenuItem cellItem = new JCheckBoxMenuItem("选择单元格");
  25.     //定义按钮组，实现单选
  26.     ButtonGroup adjustBg = new ButtonGroup();
  27.     ButtonGroup selectBg = new ButtonGroup();
  29.     //定义一个int类型的数组，用于保存表格所有的宽度调整方式
  31.     int[] adjustModes = {
  32.             JTable.AUTO_RESIZE_OFF,
  33.             JTable.AUTO_RESIZE_NEXT_COLUMN,
  34.             JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS,
  35.             JTable.AUTO_RESIZE_LAST_COLUMN,
  36.             JTable.AUTO_RESIZE_ALL_COLUMNS
  37.     };
  40.     //定义一个int乐行数组，用于保存表格所有的选择方式
  41.     int[] selectModes = {
  42.             ListSelectionModel.MULTIPLE_INTERVAL_SELECTION,
  43.             ListSelectionModel.SINGLE_INTERVAL_SELECTION,
  44.             ListSelectionModel.SINGLE_SELECTION
  45.     };
  47.     //声明JTable
  48.     JTable table;
  50.     //定义一个二维数组，作为表格行数据
  51.     Object[][] tableData = {
  53.             new Object[]{"李清照",29,"女"},
  54.             new Object[]{"苏格拉底",56,"男"},
  55.             new Object[]{"李白",35,"男"},
  56.             new Object[]{"弄玉",18,"女"},
  57.             new Object[]{"虎头",2,"男"},
  59.     };
  61.     //定义一个一维数组，作为列标题
  62.     Object[] columnTitle = {"姓名","年龄","性别"};
  65.     public void init(){
  67.         //创建JTable对象
  68.         table  = new JTable(tableData,columnTitle);
  71.         //-----------------为窗口安装设置表格调整方式的菜单--------------------
  72.         adjustModeItem[0] = new JRadioButtonMenuItem("只调整表格");
  73.         adjustModeItem[1] = new JRadioButtonMenuItem("只调整下一列");
  74.         adjustModeItem[2] = new JRadioButtonMenuItem("平均调整余下列");
  75.         adjustModeItem[3] = new JRadioButtonMenuItem("只调整最后一列");
  76.         adjustModeItem[4] = new JRadioButtonMenuItem("平均调整所有列");
  78.         menuBar.add(adjustModeMenu);
  80.         for (int i = 0; i < adjustModeItem.length; i++) {
  81.             //默认选中第三个菜单项，即对应表格默认的宽度调整方式
  82.             if (i==2){
  83.                 adjustModeItem[i].setSelected(true);
  84.             }
  85.             adjustBg.add(adjustModeItem[i]);
  86.             adjustModeMenu.add(adjustModeItem[i]);
  88.             //为菜单项设置事件监听器
  89.             int index = i;
  90.             adjustModeItem[i].addActionListener(e -> {
  91.                 if (adjustModeItem[index].isSelected()){
  92.                     table.setAutoResizeMode(adjustModes[index]);
  93.                 }
  94.             });
  95.         }
  97.         //---------------为窗口安装设置表格选择方式的菜单-------------------
  98.         selectModeItem[0] = new JRadioButtonMenuItem("无限制");
  99.         selectModeItem[1] = new JRadioButtonMenuItem("单独的连续区");
  100.         selectModeItem[2] = new JRadioButtonMenuItem("单选");
  102.         menuBar.add(selectModeMenu);
  104.         for (int i = 0; i < selectModeItem.length; i++) {
  106.             //默认选中第一个菜单项，即表格的默认选择方式
  107.             if (i==0){
  108.                 selectModeItem[i].setSelected(true);
  109.             }
  111.             selectBg.add(selectModeItem[i]);
  112.             selectModeMenu.add(selectModeItem[i]);
  115.             int index = i;
  117.             selectModeItem[i].addActionListener(e -> {
  119.                 if (selectModeItem[index].isSelected()){
  120.                     table.getSelectionModel().setSelectionMode(selectModes[index]);
  121.                 }
  123.             });
  125.         }
  127.         //---------------为窗口添加选择单元菜单----------------------
  128.         menuBar.add(selectUnitMenu);
  129.         rowsItem.setSelected(table.getRowSelectionAllowed());
  130.         columnItem.setSelected(table.getColumnSelectionAllowed());
  131.         cellItem.setSelected(table.getCellSelectionEnabled());
  133.         rowsItem.addActionListener(e -> {
  134.             //清除表格的选中状态
  135.             table.clearSelection();
  136.             //如果该菜单项处于选中状态，设置表格的选择单元是行
  137.             table.setRowSelectionAllowed(rowsItem.isSelected());
  138.             //如果选择行、选择列同时被选中，其实质是选择单元格
  139.             table.setCellSelectionEnabled(table.getCellSelectionEnabled());
  141.         });
  143.         selectUnitMenu.add(rowsItem);
  145.         columnItem.addActionListener(e -> {
  146.             //清除表格的选中状态
  147.             table.clearSelection();
  149.             //如果该菜单项处于选中状态，设置表格的选择单元是列
  150.             table.setColumnSelectionAllowed(columnItem.isSelected());
  151.             ///如果选择行、选择列同时被选中，其实质是选择单元格
  152.             table.setCellSelectionEnabled(table.getCellSelectionEnabled());
  153.         });
  155.         selectUnitMenu.add(columnItem);
  157.         cellItem.addActionListener(e -> {
  158.             //清除表格的选中状态
  159.             table.clearSelection();
  161.             //如果该菜单项处于选中状态，设置表格的选择单元是单元格
  162.             table.setCellSelectionEnabled(cellItem.isSelected());
  163.             ///该选项的改变会同时影响选择行、选择列两个菜单
  164.             table.setRowSelectionAllowed(table.getRowSelectionAllowed());
  165.             table.setColumnSelectionAllowed(table.getColumnSelectionAllowed());
  167.         });
  169.         selectUnitMenu.add(cellItem);
  171.         jf.setJMenuBar(menuBar);
  173.         //分别获取表格的三个表格列，并设置三列的最小宽、最佳宽度和最大宽度
  174.         TableColumn nameColumn = table.getColumn(columnTitle[0]);
  175.         nameColumn.setMinWidth(40);
  176.         TableColumn ageColumn = table.getColumn(columnTitle[1]);
  177.         ageColumn.setPreferredWidth(50);
  178.         TableColumn genderColumn = table.getColumn(columnTitle[2]);
  179.         genderColumn.setMaxWidth(50);
  181.         jf.add(new JScrollPane(table));
  182.         jf.pack();
  183.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  184.         jf.setVisible(true);
  186.     }
  188.     public static void main(String[] args) {
  189.         new AdjustingWidth().init();
  190.     }
  192. }

TableModel和监听器

与 JList、 JTree 类似的是 ， JTable 采用了 TableModel 来保存表格中的所有状态数据 : 与 ListModel类似的是， TableModel 也不强制保存该表格显示的数据 。 虽然在前面程序中看到的是直接利用 一个二维数组来创建 JTable 对象，但也可以通过 TableModel 对象来创建表格。
使用TableModel步骤：

  1. 自定义类，继承AbstractTableModel抽象类，重写下面几个方法：
    1. int getColumnCount():返回表格列的数量
    2. int getRowCount()：返回表格行的数量
    3. Object getValueAt(int rowIndex, int columnIndex)：返回rowIndex行，column列的单元格的值
    4. String getColumnName(int columnIndex)：返回columnIndex列的列名称
    5. boolean isCellEditable(int rowIndex, int columnIndex)：设置rowIndex行，columnIndex列单元格是否可编辑
    6. setValueAt(Object aValue, int rowIndex, int columnIndex)：设置rowIndex行，columnIndex列单元格的值
    创建自定义类对象，根据该对象，创建JTable对象

案例：

  1. 连接数据库，把库中所有的表名称显示到下拉列表中
  2. 点击下拉列表中某个表名时，查询数据库该表的数据，并把结果封装到TableModel中，使用JTable展示
  3. 点击表格中某个单元格，修改数据，能实时修改数据库中的数据
  4. 每修改一次数据，把修改的信息打印到下方的文本域中

TableModel.png
演示代码：

  1. import javax.swing.*;
  2. import javax.swing.event.TableModelEvent;
  3. import javax.swing.event.TableModelListener;
  4. import javax.swing.table.AbstractTableModel;
  5. import java.awt.*;
  6. import java.awt.event.WindowAdapter;
  7. import java.awt.event.WindowEvent;
  8. import java.sql.*;
  10. public class TableModelTest {
  11.     JFrame jf = new JFrame("数据表管理工具");
  13.     JScrollPane scrollPane;
  14.     ResultSetTableModel model;
  16.     //用于装载数据表的JComboBox
  17.     JComboBox<String> tableNames = new JComboBox<>();
  18.     JTextArea changeMsg = new JTextArea(4, 80);
  20.     ResultSet rs;
  22.     Connection conn;
  23.     Statement stmt;
  25.     public void init() {
  26.         //为JComboBox添加监听事件，当用户选择某个数据表时，触发该方法
  27.         tableNames.addActionListener(e -> {
  29.             try {
  30.                 //如果装载JTable的JScrollPane不为空
  31.                 if (scrollPane != null) {
  32.                     //从主窗口中删除表格
  33.                     jf.remove(scrollPane);
  34.                 }
  36.                 //从JComboBox中取出用户视图管理的数据表的表名
  37.                 String tableName = (String) tableNames.getSelectedItem();
  39.                 //如果结果集不为空，则关闭结果集
  40.                 if (rs != null) {
  41.                     rs.close();
  42.                 }
  44.                 String query = "select * from " + tableName;
  45.                 //查询用户选择的数据表
  46.                 rs = stmt.executeQuery(query);
  47.                 //使用查询到的ResultSet创建TableModel对象
  48.                 model = new ResultSetTableModel(rs);
  50.                 //为TableModel添加监听器，监听用户的修改
  51.                 model.addTableModelListener(new TableModelListener() {
  52.                     @Override
  53.                     public void tableChanged(TableModelEvent e) {
  54.                         int row = e.getFirstRow();
  55.                         int column = e.getColumn();
  56.                         changeMsg.append("修改的列：" + column + ",修改的行：" + row + ",修改后的值：" + model.getValueAt(row, column)+".\n");
  57.                     }
  58.                 });
  60.                 //使用TableModel创建JTable
  61.                 JTable table = new JTable(model);
  63.                 scrollPane = new JScrollPane(table);
  64.                 jf.add(scrollPane);
  65.                 jf.validate();
  67.             } catch (SQLException e1) {
  68.                 e1.printStackTrace();
  69.             }
  71.         });
  73.         JPanel p = new JPanel();
  74.         p.add(tableNames);
  75.         jf.add(p, BorderLayout.NORTH);
  76.         jf.add(new JScrollPane(changeMsg), BorderLayout.SOUTH);
  79.         //--------------数据库相关操作--------------------
  80.         try {
  81.             //获取数据库连接
  82.             conn = getConn();
  83.             //获取数据库的metaData对象
  84.             DatabaseMetaData metaData = conn.getMetaData();
  87.             //游标可以上下移动，可以使用结果集更新数据库中的表
  88.             stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
  91.             //查询数据库中的全部表
  92.             ResultSet tables = metaData.getTables(null, null, null, new String[]{"TABLE"});
  94.             //将全部表添加到JCombox中
  95.             while(tables.next()){
  96.                 tableNames.addItem(tables.getString(3));
  97.             }
  98.             tables.close();
  100.         } catch (ClassNotFoundException e) {
  101.             e.printStackTrace();
  102.         } catch (SQLException e) {
  103.             e.printStackTrace();
  104.         }
  106.         //为JFrame添加窗口事件
  107.         jf.addWindowListener(new WindowAdapter() {
  108.             @Override
  109.             public void windowClosing(WindowEvent e) {
  110.                 if (conn!=null){
  111.                     try {
  112.                         conn.close();
  113.                     } catch (SQLException e1) {
  115.                     }
  116.                 }
  117.             }
  118.         });
  120.         jf.pack();
  121.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  122.         jf.setVisible(true);
  124.     }
  126.     public static void main(String[] args) {
  127.         new TableModelTest().init();
  128.     }
  131.     public Connection getConn() throws ClassNotFoundException, SQLException {
  132.         Class.forName("com.mysql.jdbc.Driver");
  134.         return DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "root");
  135.     }
  138.     class ResultSetTableModel extends AbstractTableModel {
  141.         private ResultSet rs;
  142.         private ResultSetMetaData rsmd;
  144.         //构造方法，初始化rs和rsmd两个属性
  145.         public ResultSetTableModel(ResultSet aResultSet) {
  146.             this.rs = aResultSet;
  147.             try {
  148.                 rsmd = rs.getMetaData();
  149.             } catch (SQLException e) {
  150.                 e.printStackTrace();
  151.             }
  152.         }
  154.         //重写getColumnName方法，为表格设置列名
  155.         @Override
  156.         public String getColumnName(int column) {
  157.             //column是表格列的标号，从0开始，而rsmd获取列时，标号从1开始，所以要column+1
  158.             try {
  159.                 return rsmd.getColumnName(column + 1);
  160.             } catch (SQLException e) {
  161.                 e.printStackTrace();
  162.                 return "";
  163.             }
  164.         }
  166.         //重写getValueAt()方法，用于设置该表格指定单元格的值
  167.         @Override
  168.         public Object getValueAt(int rowIndex, int columnIndex) {
  170.             try {
  171.                 //把游标移动到指定行,swing表格中行号从0开始，但是游标中行号从1开始，所以要修正
  172.                 rs.absolute(rowIndex+1);
  173.                 return rs.getObject(columnIndex + 1);
  174.             } catch (SQLException e) {
  175.                 e.printStackTrace();
  176.                 return null;
  177.             }
  179.         }
  181.         //重写getRowCount()方法，用于设置该TableModel的行数
  182.         @Override
  183.         public int getRowCount() {
  184.             try {
  185.                 rs.last();
  186.                 return rs.getRow();
  187.             } catch (SQLException e) {
  188.                 e.printStackTrace();
  189.                 return 0;
  190.             }
  192.         }
  194.         //重写getColumnCount()方法，用于设置表格的列数
  195.         @Override
  196.         public int getColumnCount() {
  197.             try {
  198.                 return rsmd.getColumnCount();
  199.             } catch (SQLException e) {
  200.                 e.printStackTrace();
  201.                 return 0;
  202.             }
  203.         }
  205.         //重写isEditable()方法，让每个单元格可编辑
  208.         @Override
  209.         public boolean isCellEditable(int rowIndex, int columnIndex) {
  210.             return true;
  211.         }
  213.         //重写setValueAt()方法，当用户编辑单元格时，会触发该方法
  216.         @Override
  217.         public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
  219.             try {
  220.                 //把游标定位到对应的行数
  221.                 rs.absolute(rowIndex+1);
  222.                 //修改对应单元格的值
  223.                 rs.updateObject(columnIndex + 1, aValue);
  224.                 //提交修改
  225.                 rs.updateRow();
  226.                 //触发单元格的修改事件
  227.                 fireTableCellUpdated(rowIndex, columnIndex);
  229.             } catch (SQLException e) {
  230.                 e.printStackTrace();
  231.             }
  233.         }
  234.     }
  235. }
  1. 不仅用户可以扩展 AbstractTableModel 抽象类， Swing 本身也为 AbstractTableModel 提供了 一个DefaultTableModel 实现类，程序可以通过使用 DefaultTableModel 实现类来创建 JTable 对象 。 通过DefaultTableModel 对象创建 JTable 对象后，就可以调用它提供的方法来添加数据行、插入数据行 、删除数据行和移动数据行 。 DefaultTableModel 提供了如下几个方法来控制数据行操作:
  1. addColumn(Object columnName)/addColumn(Object columnName, Object[] columnData):添加一列
  2. addRow(Object[] rowData)：添加一行
  3. insertRow(int row, Object[] rowData)：指定位置处插入一行
  4. removeRow(int row)：删除一行
  5. moveRow(int start, int end, int to)：移动指定范围内的数据行

TableColumnModel和监听器

JTable 使用 TableColumnModel 来保存该表格所有数据列的状态数据，如果程序需要访问 JTable 的所有列状态信息，则可以通过获取该 JTable 的 TableColumnModel 来实现 。 TableColumnModel 提供了如下几个方法来增加、删除和移动数据列 ：

  1. addColumn(TableColumn aColumn): 该方法用于为 TableModel 添加一列 。 该方法主要用于将原来隐藏的数据列显示出来 。
  2. moveColumn(int columnIndex, int newIndex): 该方法用于将指定列移动到其他位置 。
  3. removeColumn(TableColumn column): 该方法用于从 TableModel 中删 除指定列。实际上，该方法并未真正删除指定列，只是将该列在TableColumnModel 中隐藏起来，使之不可见 。

JTable中也提供了类似的方法完成列的操作，只是其底层依然是通过TableColumnModel来完成的。
案例：
使用DefaultTableModel和TableColumnModel完成下图效果：
DefaultTableModel.png
演示代码：

  1. import javax.swing.*;
  2. import javax.swing.table.DefaultTableModel;
  3. import javax.swing.table.TableColumn;
  4. import javax.swing.table.TableColumnModel;
  5. import java.awt.*;
  6. import java.util.ArrayList;
  8. public class DefaultTableModelTest {
  10.     JFrame mainWin = new JFrame("管理数据行、数据列");
  12.     final int COLUMN_COUNT = 5;
  14.     DefaultTableModel model;
  16.     JTable table;
  17.     //用于保存被隐藏列的List集合
  18.     ArrayList<TableColumn> hiddenColumns = new ArrayList<>();
  20.     public void init(){
  22.         //创建DefaultTableModel，5行5列
  23.         model = new DefaultTableModel(COLUMN_COUNT,COLUMN_COUNT);
  25.         //给每个单元格设置内容
  26.         for (int i = 0; i < COLUMN_COUNT; i++) {
  27.             for (int j = 0; j < COLUMN_COUNT; j++) {
  28.                 model.setValueAt("老单元格值"+i+" "+j,i,j);
  30.             }
  31.         }
  33.         //创建表格
  34.         table = new JTable(model);
  35.         mainWin.add(new JScrollPane(table), BorderLayout.CENTER);
  37.         //为窗口安装菜单
  38.         JMenuBar menuBar = new JMenuBar();
  39.         mainWin.setJMenuBar(menuBar);
  40.         JMenu tableMenu = new JMenu("管理");
  41.         menuBar.add(tableMenu);
  43.         JMenuItem hideColumnsItem = new JMenuItem("隐藏选中列");
  44.         hideColumnsItem.addActionListener(e -> {
  45.             //获取所有选中列的索引
  46.             int[] selectedColumns = table.getSelectedColumns();
  47.             TableColumnModel columnModel = table.getColumnModel();
  48.             //依次把每个选中的列隐藏起来，并使用hideColumns集合把隐藏的列保存起来
  50.             for (int i = 0; i < selectedColumns.length; i++) {
  51.                 //获取列对象TableColumn
  52.                 TableColumn column = columnModel.getColumn(selectedColumns[i]);
  53.                 //隐藏指定列
  54.                 table.removeColumn(column);
  56.                 //把隐藏的列保存起来，确保以后可以显示出来
  57.                 hiddenColumns.add(column);
  58.             }
  59.         });
  61.         tableMenu.add(hideColumnsItem);
  63.         JMenuItem showColumsItem = new JMenuItem("显示隐藏列");
  64.         showColumsItem.addActionListener(e -> {
  66.             for (TableColumn column : hiddenColumns) {
  67.                 table.addColumn(column);
  68.             }
  70.             //清空隐藏列集合
  71.             hiddenColumns.clear();
  73.         });
  75.         tableMenu.add(showColumsItem);
  77.         JMenuItem addColumnItem = new JMenuItem("插入选中列");
  78.         addColumnItem.addActionListener(e -> {
  79.             //获取所有选中列的索引
  80.             int[] selectedColumns = table.getSelectedColumns();
  81.             TableColumnModel columnModel = table.getColumnModel();
  82.             //依次插入选中列
  83.             for (int i = selectedColumns.length-1; i >=0; i--) {
  84.                 TableColumn column = columnModel.getColumn(selectedColumns[i]);
  85.                 table.addColumn(column);
  87.             }
  88.         });
  90.         tableMenu.add(addColumnItem);
  93.         JMenuItem addRowItem = new JMenuItem("增加行");
  94.         addRowItem.addActionListener(e -> {
  95.             //创建一个String数组，作为新增行的内容
  96.             String[] newCells = new String[COLUMN_COUNT];
  97.             for (int i = 0; i < newCells.length; i++) {
  98.                 newCells[i] = "新单元格的值"+model.getRowCount()+" "+i;
  99.             }
  101.             //向table中新增一行
  102.             model.addRow(newCells);
  103.         });
  105.         tableMenu.add(addRowItem);
  107.         JMenuItem removeRowsItem = new JMenuItem("删除选中行");
  109.         removeRowsItem.addActionListener(e -> {
  110.             //获取被选中的行
  111.             int[] selectedRows = table.getSelectedRows();
  113.             //依次删除每一行
  114.             for (int i = selectedRows.length-1; i >=0; i--) {
  115.                 model.removeRow(selectedRows[i]);
  116.             }
  118.         });
  120.         tableMenu.add(removeRowsItem);
  122.         mainWin.pack();
  123.         mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  124.         mainWin.setVisible(true);
  126.     }
  129.     public static void main(String[] args) {
  130.         new DefaultTableModelTest().init();
  131.     }
  133. }

如果程序需要监昕 JTable 里列状态的改变，例如监听列的增加、删除 、 移动等改变， 则必须使用该 JTable 所对应的 TableColumnModel 对象，该对象提供了 一个 addColumnModelListener()方法来添加监听器， 该监听器接口里包含如下几个方法 ：

  1. columnAdded(TableColumnModelEvent e) : 当向 TableColumnModel 里添加数据列时将会触发该方法。
  2. columnMarginChanged(ChangeEvent e) : 当由于页面距 ( Margin ) 的改变引起列状态改变时将会触发该方法 。
  3. columnMoved(TableColumnModelEvent e): 当移动 TableColumnModel 里的数据列时将会触发该方法 。
  4. columnRemoved(TableColumnModelEvent e): 当删除 TableColumnModel 里的数据列时将会触发该方法 。
  5. columnSelectionChanged(ListSelectionEvent e): 当改变表格的选择模式时将会触发该方法。

但表格的数据列通常需要程序来控制增加、 删除 ，用户操作通常无法直接为表格增加 、删除数据列，所以使用监听器来监听 TableColumnModel 改变的情况比较少见。

实现列排序

使用 JTable 实现的表格并没有实现根据指定列排序的功能 ， 但开发者可以利用 AbstractTableModel 类来实现该功能。由于 TableModel 不强制要求保存表格里的数据，只要 TableModel 实现了 getValueAt()、getColumnCount()和 getRowCount()三个方法， JTable 就可以根据该 TableModel 生成表格 。 因此可以创建个 SortableTableModel 实现类 ， 它可以将原 TableModel 包装起来，并实现根据指定列排序的功能 。

程序创建的 SortableTableModel 实现类会对原 TableModel 进行包装，但它实际上并不保存任何数据，它会把所有的方法实现委托给原 TableModel 完成。 SortableTableModel 仅保存原 TableModel 里每行的行索引， 当程序对 SortableTableModel 的指定列排序时， 实际上仅仅对SortableTableModel 里的行索引进排序一一这样造成的结果是 : SortableTableModel 里的数据行的行索引与原 TableModel 里数据行的行索引不一致，所以对于 TableModel 的那些涉及行索引的方法都需要进行相应的转换。下面程序实现了SortableTableModel 类，并使用该类来实现对表格根据指定列排序的功能 。
案例：
实现下图功能：
双击列的头部，按照该列从小到大的顺序进行排序
sorttable.png
演示代码：

  1. import javax.swing.*;
  2. import javax.swing.table.AbstractTableModel;
  3. import javax.swing.table.TableModel;
  4. import java.awt.event.MouseAdapter;
  5. import java.awt.event.MouseEvent;
  6. import java.util.Arrays;
  8. public class SortTable {
  10.     JFrame jf = new JFrame("可按照列排序的表格");
  12.     //定义二维数组作为表格数据
  14.     Object[][] tableData = {
  16.             new Object[]{"李清照",29,"女"},
  17.             new Object[]{"苏格拉底",56,"男"},
  18.             new Object[]{"李白",35,"男"},
  19.             new Object[]{"弄玉",18,"女"},
  20.             new Object[]{"虎头",2,"男"},
  22.     };
  24.     //定义一个一维数组，作为列标题
  25.     Object[] columnTitle = {"姓名","年龄","性别"};
  27.     JTable table = new JTable(tableData,columnTitle);
  29.     //将原表格里面的TableModel封装成SortTableModel对象
  30.     SortTableModel sorterModel = new SortTableModel(table.getModel());
  32.     public void init(){
  33.         //使用包装后的SortTableModel对象作为JTable的model对象
  34.         table.setModel(sorterModel);
  36.         //为每一列的列头增加鼠标监听器
  37.         table.getTableHeader().addMouseListener(new MouseAdapter() {
  38.             @Override
  39.             public void mouseClicked(MouseEvent e) {
  40.                 //如果单击次数小于2，则返回，不是双击
  41.                 if (e.getClickCount()<2){
  42.                     return;
  43.                 }
  45.                 //找出鼠标双击事件所在列的索引
  46.                 int tableColumn = table.columnAtPoint(e.getPoint());
  48.                 //将JTable中的列索引，转换成对应的TableModel中的列索引
  49.                 int modelColumn = table.convertColumnIndexToModel(tableColumn);
  51.                 //根据指定列进行排序
  52.                 sorterModel.sort(modelColumn);
  53.             }
  54.         });
  56.         jf.add(new JScrollPane(table));
  57.         jf.pack();
  58.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  59.         jf.setVisible(true);
  60.     }
  63.     public static void main(String[] args) {
  64.         new SortTable().init();
  65.     }
  68.     //自定义SortTableModel，增强原有的TableModel
  70.     class SortTableModel extends AbstractTableModel{
  72.         private TableModel model;
  73.         private int sortColumn;
  74.         private Row[] rows;
  76.         public SortTableModel(TableModel model){
  77.             this.model = model;
  78.             rows = new Row[model.getRowCount()];
  79.             //将原TableModel中的每行记录的索引用Row数组保存起来
  80.             for (int i = 0; i < rows.length; i++) {
  81.                 rows[i] = new Row(i);
  82.             }
  84.         }
  86.         //实现根据指定列进行排序
  87.         public void sort(int c){
  88.             sortColumn = c;
  89.             Arrays.sort(rows);
  90.             //触发数据改变的事件
  91.             fireTableDataChanged();
  92.         }
  94.         //下面3个方法需要访问model中的数据，所以涉及本model中数据和被封装model数据中的索引转换，程序使用rows完成这种转换
  96.         @Override
  97.         public Object getValueAt(int rowIndex, int columnIndex) {
  98.             return model.getValueAt(rows[rowIndex].index,columnIndex);
  99.         }
  101.         @Override
  102.         public boolean isCellEditable(int rowIndex, int columnIndex) {
  103.             return isCellEditable(rows[rowIndex].index,columnIndex);
  104.         }
  106.         @Override
  107.         public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
  108.             model.setValueAt(aValue,rows[rowIndex].index,columnIndex);
  109.         }
  111.         //下面方法的实现把该model的方法委托给原封装的model来实现
  114.         @Override
  115.         public int getRowCount() {
  117.             return model.getRowCount();
  118.         }
  120.         @Override
  121.         public int getColumnCount() {
  122.             return model.getColumnCount();
  123.         }
  126.         @Override
  127.         public String getColumnName(int column) {
  128.             return model.getColumnName(column);
  129.         }
  131.         @Override
  132.         public Class<?> getColumnClass(int columnIndex) {
  133.             return model.getColumnClass(columnIndex);
  134.         }
  136.         private class Row implements Comparable<Row>{
  137.             //该index保存着被封装Model里每行记录的索引
  138.             public int index;
  140.             public Row(int index) {
  141.                 this.index = index;
  142.             }
  144.             //实现两行之间大小的比较
  145.             @Override
  146.             public int compareTo(Row o) {
  147.                 Object a = model.getValueAt(index, sortColumn);
  148.                 Object b = model.getValueAt(o.index, sortColumn);
  150.                 if (a instanceof Comparable){
  151.                     return ((Comparable) a).compareTo(b);
  152.                 }else{
  153.                     return a.toString().compareTo(b.toString());
  154.                 }
  155.             }
  156.         }
  157.     }
  159. }

绘制单元格内容

前面看到的所有表格的单元格内容都是宇符串，实际上表格的单元格内容也可以是更复杂的内容。JTable 使用 TableCellRenderer 绘制单元格， Swing 为该接口提供了 一 个实现类 : DefaultTableCellRenderer,该单元格绘制器可以绘制如下三种类型的单元格值(根据其 TableModel 的 getColurnnClass()方法来决定该单元格值的类型) :

  1. Icon: 默认的单元格绘制器会把该类型的单元格值绘制成该Icon对象所代表的图标 。
  2. Boolean: 默认的单元格绘制器会把该类型的单元格值绘制成复选按钮。
  3. Object: 默认的单元格绘制器在单元格内绘制出该对象的 toString()方法返回的字符串 。

在默认情况下，如果程序直接使用 二维数组或 Vector 来创建 JTable ， 程序将会使用 JTable 的匿名内部类或 DefaultTableModel 充当该表格的 model 对象，这两个 TableModel 的 getColumnClass()方法的返回值都是 Object 。 这意味着，即使该二维数组里值的类型是 Icon ， 但由于两个默认的 TableModel 实现类的 getColumnClass()方法总是返回 Object，这将导致默认的单元格绘制器把 Icon 值当成 Object 值处
理一一只是绘制出其 toString()方法返回的字符串。

  1. 为了让默认的单元格绘制器可以将 Icon 类型 的值绘制成图标，把 Boolean 类型的值绘制成复边框 ，创建 JTable 时所使用的 TableModel 绝不能采用默认的 TableModel ，必须采用扩展后的 TableModel 类，如下所示 :
  1. //定义一个DefaultTableModel的子类
  2. class ExtendedTableModel extends DefaultTableModel{
  3.     ...
  4.     //重写getColumnClass方法，根据每列的第一个值，来返回每列的真实数据类型
  5.         public class getColumnClass(int c){
  6.             return getValueAt(0,c).getClass();
  7.         }
  9.     ...
  11. }
  1. 提供了上面的 ExtendedTableModel 类之后 ， 程序应该先创建 ExtendedTableModel 对象，再利用该对象来创建 JTable，这样就可以保证 JTable 的 model 对象的 getColumnClass()方法会返回每列真实的数据类型，默认的单元格绘制器就会将 Icon 类型的单元格值绘制成图标 ， 将 Boolean 类型 的单元格值绘制成复选框。
  3. 如果希望程序采用自己定制的单元格绘制器，则必须实现自己的单元格绘制器，单元格绘制器必须实现 TableCellRenderer 接口。与前面的TreeCellRenderer 接口完全相似， 该接口里也只包含一 个getTableCellRendererComponent()方法，该该方法返回的 Component 将会作为指定单元格绘制的组件。
  5. 一旦实现了自己的单元格绘制器之后，还必须将该单元格绘制器安装到指定的 JTable 对象上，为指定的 JTable 对象安装单元格绘制器有如下两种方式 ：
  1. 局部方式 ( 列级 ) : 调用 TableColumn的setCellRenderer()方法为指定列安装指定的单元格绘制器。
  2. 全局方式 (表级) :调用 JTable 的setDefaultRendererO方法为指定的 JTable 对象安装单元格绘制器, setDefaultRendererO方法需要传入两个参数,即列类型和单元格绘制器 ， 表明指定类型的数据列才会使用该单元格绘制器 。

案例：
使用TableCellRenderer和TableModel实现下图效果：
TableCellRenderer.png
演示代码：

  1. import cn.itcast.swing.util.ImagePathUtil;
  3. import javax.swing.*;
  4. import javax.swing.table.DefaultTableModel;
  5. import javax.swing.table.TableCellRenderer;
  6. import javax.swing.table.TableColumn;
  7. import java.awt.*;
  9. public class TableCellRendererTest {
  11.     JFrame jf = new JFrame("使用单元格绘制器");
  13.     JTable table;
  15.     //定义二维数组作为表格数据
  17.     Object[][] tableData = {
  19.             new Object[]{"李清照",29,"女",new ImageIcon(ImagePathUtil.getRealPath("11\\3.gif")),true},
  20.             new Object[]{"苏格拉底",56,"男",new ImageIcon(ImagePathUtil.getRealPath("11\\1.gif")),false},
  21.             new Object[]{"李白",35,"男",new ImageIcon(ImagePathUtil.getRealPath("11\\4.gif")),true},
  22.             new Object[]{"弄玉",18,"女",new ImageIcon(ImagePathUtil.getRealPath("11\\2.gif")),true},
  23.             new Object[]{"虎头",2,"男",new ImageIcon(ImagePathUtil.getRealPath("11\\5.gif")),false},
  25.     };
  27.     //定义一个一维数组，作为列标题
  28.     String[] columnTitle = {"姓名","年龄","性别","主头像","是否中国人"};
  30.     public void init(){
  31.         //以二维数组和一维数组来创建一个ExtendedTableModel对象
  32.         ExtendedTableModel model = new ExtendedTableModel(columnTitle,tableData);
  34.         //创建JTable
  35.         table = new JTable(model);
  37.         table.setRowSelectionAllowed(false);
  38.         table.setRowHeight(40);
  40.         //获取第三列
  41.         TableColumn column = table.getColumnModel().getColumn(2);
  42.         //对第三列采用自定义的单元格绘制器
  43.         column.setCellRenderer(new GenderTableCellRenderer());
  45.         jf.add(new JScrollPane(table));
  46.         jf.pack();
  47.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  48.         jf.setVisible(true);
  49.     }
  51.     public static void main(String[] args) {
  52.         new TableCellRendererTest().init();
  53.     }
  55.     //自定义ExtendedTableModel对象
  56.     class ExtendedTableModel extends DefaultTableModel{
  58.         //重新提供一个构造器，该构造器的实现委托给DefaultTableModel父类
  59.         public  ExtendedTableModel(String[] columnNames,Object[][] cells){
  60.             super(cells,columnNames);
  61.         }
  63.         //重写getColumnClass方法，根据每列第一个值，返回其真实的数据类型
  65.         @Override
  66.         public Class<?> getColumnClass(int columnIndex) {
  67.             return getValueAt(0,columnIndex).getClass();
  68.         }
  69.     }
  71.     //自定义的单元格绘制器
  72.     class GenderTableCellRenderer extends JPanel implements TableCellRenderer {
  73.         private String cellValue;
  74.         //定义图标的宽度和高度
  75.         final int ICON_WIDTH = 23;
  76.         final int ICON_HEIGHT = 21;
  79.         @Override
  80.         public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
  81.             cellValue = (String) value;
  83.             //设置选中状态的绘制边框
  84.             if (hasFocus){
  85.                 setBorder(UIManager.getBorder("Table.focusCellHighlightBorder"));
  86.             }else{
  87.                 setBorder(null);
  88.             }
  89.             return this;
  90.         }
  92.         //重写paint方法，负责绘制单元格的内容
  93.         @Override
  94.         public void paint(Graphics g) {
  95.             //如果表格的内容为男或male,则绘制一个男性图标
  96.             if (cellValue.equals("男") || cellValue.equals("male")){
  97.                 drawImage(g,new ImageIcon(ImagePathUtil.getRealPath("11\\male.gif")).getImage());
  98.             }
  100.             //如果表格的内容为nv或female，则绘制一个女性图标
  101.             if (cellValue.equals("女") || cellValue.equals("female")){
  102.                 drawImage(g,new ImageIcon(ImagePathUtil.getRealPath("11\\female.gif")).getImage());
  103.             }
  104.         }
  106.         private void drawImage(Graphics g,Image image){
  107.             g.drawImage(image,(getWidth()-ICON_WIDTH)/2,(getHeight()-ICON_HEIGHT)/2,null);
  108.         }
  109.     }
  110. }

编辑单元格内容

如果用户双击 JTable 表格的指定单元格，系统将会开始编辑该单元格的内容。在默认情况下，系统会使用文本框来编辑该单元格的内容，与此类似的是 ，如果用户双击 JTree 的节 点，默认也会采用文本框来编辑节点 的内容 。

但如果单元格内容不是文字内容，用户当然不希望使用文本编辑器来编辑该单元格的内容，因为这种编辑方式非常不直观，用户体验相当差 。 为了避免这种情况，可以实现自己的单元格编辑器，从而可以给用户提供更好的操作界面。

实现 JTable 的单元格编辑器应该实现 TableCellEditor 接口 ，Swing 为 TableCellEditor提供了 DefaultCellEditor 实现类，efaultCellEditor 类有三个构造器， 它们分别使用文本框、复选框和JComboBox 作 为单元格编辑器，其中使用文本框编辑器是最常见的情形，如果单元格的值是 Boolean类型 ，则系统默认使用复选框编辑器。如果想指定某列使用 JComboBox 作为单元格编辑器，则需要显式创建 JComboBox 实例 ，然后以此实例来创建 DefaultCellEditor 编辑器 。

使用DefaultCellEditor步骤：

  1. 自定义类，继承DefaultCellEditor，重写getTableCellEditorComponent()方法；
  2. 创建自定义类对象
  3. 为JTable安装单元格编辑器
    1. 局部安装：通过TableColumn的setEditor（）方法完成安装，只是为某一列安装。
    2. 全局安装：调用 JTable 的 setDefaultEditor（）方法为该表格安装默认的单元格编辑器。该方法需要两个参数，即列类型和单元格编辑器，这两个参数表明对于指定类型的数据列使用该单元格编辑器 。
    案例：
    使用TableCellEditor和TableModel完成下图效果：
    TableCellEditor1.png
    TableCellEditor2.png
    演示代码： ```java import cn.itcast.swing.util.ImagePathUtil;

import javax.swing.; import javax.swing.filechooser.FileFilter; import javax.swing.table.DefaultTableModel; import javax.swing.table.TableColumn; import java.awt.; import java.io.File;

public class TableCellEditorTest { JFrame jf = new JFrame(“使用单元格编辑器”);

  1. JTable table;
  3. //定义二维数组作为表格数据
  5. Object[][] tableData = {
  7.         new Object[]{"李清照",29,"女",new ImageIcon(ImagePathUtil.getRealPath("11\\3.gif")),new ImageIcon(ImagePathUtil.getRealPath("11\\3.gif")),true},
  8.         new Object[]{"苏格拉底",56,"男",new ImageIcon(ImagePathUtil.getRealPath("11\\1.gif")),new ImageIcon(ImagePathUtil.getRealPath("11\\1.gif")),false},
  9.         new Object[]{"李白",35,"男",new ImageIcon(ImagePathUtil.getRealPath("11\\4.gif")),new ImageIcon(ImagePathUtil.getRealPath("11\\4.gif")),true},
  10.         new Object[]{"弄玉",18,"女",new ImageIcon(ImagePathUtil.getRealPath("11\\2.gif")),new ImageIcon(ImagePathUtil.getRealPath("11\\2.gif")),true},
  11.         new Object[]{"虎头",2,"男",new ImageIcon(ImagePathUtil.getRealPath("11\\5.gif")),new ImageIcon(ImagePathUtil.getRealPath("11\\5.gif")),false},
  13. };
  15. //定义一个一维数组，作为列标题
  16. String[] columnTitle = {"姓名","年龄","性别","主头像","次头像","是否中国人"};
  19. public void init(){
  20.     ExtendedTableModel model = new ExtendedTableModel(columnTitle,tableData);
  22.     table  =  new JTable(model);
  24.     table.setRowSelectionAllowed(false);
  25.     table.setRowHeight(40);
  27.     //为表格指定默认的编辑器
  28.     table.setDefaultEditor(ImageIcon.class,new ImageCellEditor());
  30.     //获取第5列
  31.     TableColumn column = table.getColumnModel().getColumn(4);
  32.     //创建JComboBox对象，并添加多个图标列表项
  33.     JComboBox<ImageIcon> editCombo = new JComboBox<>();
  34.     for (int i = 1; i <= 10; i++) {
  35.         editCombo.addItem(new ImageIcon(ImagePathUtil.getRealPath("11\\"+i+".gif")));
  36.     }
  38.     //设置第5列使用基于JComboBox的DefaultCellEditor
  39.     column.setCellEditor(new DefaultCellEditor(editCombo));
  41.     jf.add(new JScrollPane(table));
  42.     jf.pack();
  43.     jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  44.     jf.setVisible(true);
  45. }
  48. public static void main(String[] args) {
  49.     new TableCellEditorTest().init();
  50. }
  53. //自定义ExtendedTableModel对象
  54. class ExtendedTableModel extends DefaultTableModel {
  56.     //重新提供一个构造器，该构造器的实现委托给DefaultTableModel父类
  57.     public  ExtendedTableModel(String[] columnNames,Object[][] cells){
  58.         super(cells,columnNames);
  59.     }
  61.     //重写getColumnClass方法，根据每列第一个值，返回其真实的数据类型
  63.     @Override
  64.     public Class<?> getColumnClass(int columnIndex) {
  65.         return getValueAt(0,columnIndex).getClass();
  66.     }
  67. }
  69. //扩展DefaultCellEditor来实现TableCellEditor
  70. class ImageCellEditor extends DefaultCellEditor{
  72.     //定义文件选择器
  73.     private JFileChooser fDialog = new JFileChooser();
  74.     //定义文本域
  75.     private JTextField field = new JPasswordField(15);
  76.     //定义按钮
  77.     private JButton button = new JButton("...");
  80.     public ImageCellEditor() {
  81.         //因为DefaultCellEditor没有无参构造器
  82.         //所以这里显示调用父类有参数的构造器
  83.         super(new JTextField());
  84.         initEditor();
  85.     }
  87.     private void initEditor() {
  88.         //禁止编辑
  89.         field.setEnabled(false);
  90.         //为按钮添加监听器，当用户单击按钮时，
  91.         //系统将出现一个文件选择器让用户选择图标文件
  92.         button.addActionListener(e->{
  93.             fDialog.setCurrentDirectory(new File(ImagePathUtil.getRealPath("11")));
  94.             int result = fDialog.showOpenDialog(null);
  96.             if (result==JFileChooser.CANCEL_OPTION){
  97.                 //用户点击了取消
  98.                 super.cancelCellEditing();
  99.                 return;
  100.             }else{
  101.                 //用户点击了确定按钮
  102.                 field.setText(ImagePathUtil.getRealPath("11\\"+fDialog.getSelectedFile().getName()));
  103.                 button.getParent().transferFocus();
  104.             }
  105.         });
  107.         //为文件选择器安装文件过滤器
  108.         fDialog.addChoosableFileFilter(new FileFilter() {
  109.             @Override
  110.             public boolean accept(File f) {
  111.                 if (f.isDirectory()){
  112.                     return true;
  113.                 }
  115.                 String extension = Utils.getExtension(f);
  116.                 if (extension!=null){
  117.                     if (extension.equals(Utils.tiff)
  118.                         || extension.equals(Utils.tif)
  119.                         || extension.equals(Utils.gif)
  120.                         || extension.equals(Utils.jpeg)
  121.                         || extension.equals(Utils.jpg)
  122.                         || extension.equals(Utils.png)
  124.                     ){
  125.                         return true;
  126.                     }else {
  127.                         return false;
  128.                     }
  129.                 }
  131.                 return false;
  132.             }
  134.             @Override
  135.             public String getDescription() {
  136.                 return "有效的图片文件";
  137.             }
  138.         });
  140.         fDialog.setAcceptAllFileFilterUsed(false);
  141.     }
  143.     //重写getTableCellEditorComponent方法，绘制单元格组件
  146.     @Override
  147.     public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
  148.         this.button.setPreferredSize(new Dimension(20,20));
  149.         JPanel panel = new JPanel();
  150.         panel.setLayout(new BorderLayout());
  151.         field.setText(value.toString());
  152.         panel.add(this.field,BorderLayout.CENTER);
  153.         panel.add(this.button,BorderLayout.EAST);
  155.         return panel;
  156.     }
  158.     //重写getCellEditorValue方法，填充单元格的内容
  159.     @Override
  160.     public Object getCellEditorValue() {
  161.         return new ImageIcon(field.getText());
  162.     }
  165. }

} class Utils{ public final static String jpeg = “jpeg”; public final static String jpg = “jpg”; public final static String gif = “gif”; public final static String tiff = “tiff”; public final static String tif = “tif”; public final static String png = “png”;

  1. public static String getExtension(File f){
  2.     String ext = null;
  3.     String s = f.getName();
  4.     int i = s.lastIndexOf('.');
  5.     if (i>0 && i<s.length()-1){
  6.         ext=s.substring(i+1).toLowerCase();
  7.     }
  8.     return ext;
  9. }

} ```