devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

idea插件开发(5)-Swing图形化设计_idea swing

作者：Monodyee | 2024-02-19 02:26:15

赞

踩

idea swing

     Java-GUI提供了两套设计AWT和Swing，其中Swing是基于AWT开发的，两者在功能上基本一样。发展至今天，最大的区别就是在显示样式上，AWT会匹配当前操作系统的UI而在不同平台下表现出不同的样式，但Swing不会。所以建议插件开发时采用Swing-GUI。

一、Idea-UI开发基础

1、UI控件架构

        Idea的图形界面是基于Swing开发的，官方文档也有推荐，详细的UI控件可查看官方文档IntelliJ Platform UI Guidelines ，虽说Swing内容比较多，但相对来讲比较简单。 所有GUI开发基本都遵循如下关系来设计：

2、Swing体系

        idea控件开发只要了解这一张图即可，开发时参考此图再查相应的API文档。不需要太高深的技术(Canvas开发除外，那个涉及很多图形方面的专业知识。

 二、Swing容器

        本章会从容器、布局、复杂控件几个方式给出一些示例。

1、JFrame

        显示一个空白窗口

  1. public class Windowsdemo {
  2.     public static void main(String[] args) {
  3.         //1.创建一个窗口对象
  4.         JFrame frame = new JFrame("window窗口演示");
  5.         //2.指定窗口的位置，大小
  6.         frame.setLocation(100,100);
  7.         frame.setSize(500,300);
  8.         //3.设置窗口对象可见
  9.         frame.setVisible(true);
  10.     }
  11. }

2、JDialog

  1. public class DialogTest {
  2.     public static void main(String[] args) {
  3.  
  4.         JFrame frame = new JFrame("这里测试Dialog");
  5.         JDialog d1 = new JDialog(frame, "模式对话框", true);
  6.  
  7.         //2.通过setBounds方法设置Dialog的位置以及大小
  8.         d1.setBounds(20,30,300,200);
  9.         //3.创建两个按钮
  10.         JButton b1 = new JButton("打开模式对话框");
  11.  
  12.         //4.给这两个按钮添加点击后的行为
  13.         b1.addActionListener(new ActionListener() {
  14.             @Override
  15.             public void actionPerformed(ActionEvent e) {
  16.                 d1.setVisible(true);
  17.             }
  18.         });
  19.  
  20.         //5.把按钮添加到frame中
  21.         frame.add(b1, BorderLayout.NORTH);
  22.  
  23.         //设置frame最佳大小并可见
  24.         frame.pack();
  25.         frame.setVisible(true);
  26.     }
  27. }

 

3、MessageDialog

        简化版本的弹出窗口确定框，注意这些Dialog全是模态化的。

  1. public class MessageDialogTest {
  2.  
  3.  
  4.     JFrame jf = new JFrame("测试消息对话框");
  5.  
  6.     JTextArea jta = new JTextArea(6, 30);
  7.  
  8.     //声明按钮
  9.     JButton btn = new JButton(new AbstractAction("弹出消息对话框") {
  10.         @Override
  11.         public void actionPerformed(ActionEvent e) {
  12.             //弹出一个消息对话框，并且显示  文本域中输入的内容
  13.             String text = jta.getText();
  14.  
  15.             //参数：int messageType  指定消息对话框的类型： 错误消息，警告消息，问题消息...
  16.             //JOptionPane.showMessageDialog(jf,text,"消息对话框",JOptionPane.ERROR_MESSAGE);
  17.             //JOptionPane.showMessageDialog(jf,text,"消息对话框",JOptionPane.INFORMATION_MESSAGE);
  18.             //JOptionPane.showMessageDialog(jf,text,"消息对话框",JOptionPane.WARNING_MESSAGE);
  19.             //JOptionPane.showMessageDialog(jf,text,"消息对话框",JOptionPane.QUESTION_MESSAGE);
  20.             //JOptionPane.showMessageDialog(jf,text,"消息对话框",JOptionPane.PLAIN_MESSAGE);
  21.  
  22.             JOptionPane.showMessageDialog(jf,text,"消息对话框",JOptionPane.WARNING_MESSAGE,new ImageIcon("E:\\GUISwing\\img\\component\\female.png"));
  23.  
  24.         }
  25.     });
  26.  
  27.     public void init(){
  28.         //组装视图
  29.         jf.add(jta);
  30.         jf.add(btn, BorderLayout.SOUTH);
  31.  
  32.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  33.         jf.pack();
  34.         jf.setVisible(true);
  35.     }
  36.  
  37.     public static void main(String[] args) {
  38.         new MessageDialogTest().init();
  39.     }

4、为容器添加工具栏

Frame菜单

        菜单分为两种：一种是嵌入到Frame中的，另一种是右键。

  1. public class SimpleMenu {
  2.     //创建窗口
  3.     private JFrame frame = new JFrame("这里测试菜单相关组件");
  4.  
  5.     //创建菜单条
  6.     JMenuBar menuBar = new JMenuBar();
  7.  
  8.     //创建菜单组件
  9.     JMenu fileMenu = new JMenu("文件");
  10.     JMenu editMenu = new JMenu("编辑");
  11.  
  12.     //菜单项组件
  13.     JMenuItem copy = new JMenuItem("复制");
  14.     JMenuItem paste = new JMenuItem("粘贴");
  15.  
  16.     public void init(){
  17.         //组装编辑菜单
  18.         editMenu.add(copy);
  19.         editMenu.add(paste);
  20.  
  21.         //组装菜单条
  22.         menuBar.add(fileMenu);
  23.         menuBar.add(editMenu);
  24.  
  25.         //把菜单条放入到Frame中
  26.         frame.setJMenuBar(menuBar);
  27.  
  28.         //设置frame最佳大小并可见
  29.         frame.pack();
  30.         frame.setVisible(true);
  31.     }
  32.  
  33.     public static void main(String[] args) {
  34.         new SimpleMenu().init();
  35.     }
  36. }

Toolbar工具栏

        这个工具栏是可以拖动的。

  1. public class JToolBarTest {
  2.  
  3.     JFrame jf = new JFrame("测试工具条");
  4.     JTextArea jta = new JTextArea(6,35);
  5.  
  6.     //声明工具条相关内容
  7.     JToolBar jToolBar = new JToolBar("播放工具条",SwingConstants.HORIZONTAL);
  8.  
  9.     //创建3个Action对象
  10.     //传递的参数，name和icon，最终在添加到工具条中时，会被拿出来作为按钮的名称和图标
  11.     Action pre = new AbstractAction("上一曲",new ImageIcon("E:\\GUISwing\\img\\component\\上一曲16.png")) {
  12.         @Override
  13.         public void actionPerformed(ActionEvent e) {
  14.             jta.append("上一曲.\n");
  15.         }
  16.     };
  17.  
  18.  
  19.     public void init(){
  20.         //通过Action对象来创建JButton
  21.         JButton preBtn = new JButton(pre);
  22.  
  23.         jToolBar.add(preBtn);
  24.         jToolBar.addSeparator();
  25.  
  26.         //让工具条可以拖动
  27.         jToolBar.setFloatable(true);
  28.         jf.add(jToolBar, BorderLayout.NORTH);
  29.  
  30.         //把一个组件设置到JScrollPane中，那么该组件就支持滚动条了
  31.         JScrollPane jScrollPane = new JScrollPane(jta);
  32.  
  33.         jf.add(jScrollPane);
  34.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  35.         jf.pack();
  36.         jf.setVisible(true);
  37.     }
  38.  
  39.     public static void main(String[] args) {
  40.         new JToolBarTest().init();
  41.     }
  42. }

5、特殊容器

 JSplitPane-可调整大小的面板

  1. public class SplitPaneTest {
  2.  
  3.     Book[] books = {new Book("java自学宝典",  "国内关于 Java 编程最全面的图书 \n 看得懂 ， 学得会"),
  4.             new Book("轻量级的JAVAEE企业应用实战", "SSM整合开发的经典图书，值的拥有"),
  5.  
  6.     };
  7.  
  8.     JFrame jf = new JFrame("测试JSplitPane");
  9.  
  10.     //声明程序中用到的组件
  11.     JList<Book> bookJList = new JList<>(books);
  12.     JLabel bookCover = new JLabel();
  13.     JTextArea bookDesc = new JTextArea();
  14.  
  15.     public void init(){
  16.         //组装视图
  17.         //设定组件大小
  18.         bookJList.setPreferredSize(new Dimension(150,400));
  19.         bookCover.setPreferredSize(new Dimension(220,270));
  20.         bookDesc.setPreferredSize(new Dimension(220,130));
  21.  
  22.         //为jList设置条目选中监听器
  23.         bookJList.addListSelectionListener(new ListSelectionListener() {
  24.             @Override
  25.             public void valueChanged(ListSelectionEvent e) {
  26.                 //获取当前选中的是哪个条目
  27.                 Book book = bookJList.getSelectedValue();
  28.                 //把书籍的图片用bookCover展示
  29.                 bookDesc.setText(book.getDesc());
  30.             }
  31.         });
  32.  
  33.         //组装左边区域
  34.         JSplitPane left = new JSplitPane(JSplitPane.VERTICAL_SPLIT,bookCover,new JScrollPane(bookDesc));
  35.         left.setOneTouchExpandable(true);//一触即展
  36.  
  37.         //组装整体
  38.         JSplitPane hole = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,left,bookJList);
  39.  
  40.         //支持连续布局
  41.         hole.setContinuousLayout(true);
  42.         hole.setDividerSize(10);
  43.         jf.add(hole);
  44.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  45.         jf.pack();
  46.         jf.setVisible(true);
  47.  
  48.     }
  49.  
  50.     public static void main(String[] args) {
  51.         new SplitPaneTest().init();
  52.     }
  53.  
  54. }
  55.  
  56. @Data
  57. @AllArgsConstructor
  58. class Book {
  59.     private String name;
  60.  
  61.     private String desc;
  62. }

 TabbedPane-标签页面板

  1. public class JTabbedPaneTest {
  2.     JFrame jf = new JFrame("测试JTabbedPane");
  3.  
  4.     JTabbedPane tabbedPane = new JTabbedPane(SwingConstants.LEFT,JTabbedPane.SCROLL_TAB_LAYOUT);
  5.  
  6.     public void init(){
  7.  
  8.         //添加标签
  9.         tabbedPane.addTab("用户管理",new ImageIcon("swing\\img\\container\\open.gif"),new JList<String>(new String[]{"用户一","用户二","用户三"}));
  10.         tabbedPane.addTab("商品管理",new JList<String>(new String[]{"商品一","商品二","商品三"}));
  11.         tabbedPane.addTab("订单管理",new ImageIcon("swing\\img\\container\\open.gif"),new JList<String>(new String[]{"订单一","订单二","订单三","订单四"}));
  12.  
  13.         //完成设置
  14.         tabbedPane.setEnabledAt(0,false);//禁用用户管理
  15.         tabbedPane.setSelectedIndex(1);//默认商品管理
  16.  
  17.         //监听当前标签面板的选中情况
  18.         tabbedPane.addChangeListener(new ChangeListener() {
  19.             @Override
  20.             public void stateChanged(ChangeEvent e) {
  21.                 int selectedIndex = tabbedPane.getSelectedIndex();
  22.                 JOptionPane.showMessageDialog(jf,"当前选中了第 "+(selectedIndex+1)+"个标签");
  23.             }
  24.         });
  25.  
  26.         jf.add(tabbedPane);
  27.         jf.setBounds(400,400,400,400);
  28.         jf.setResizable(false);
  29.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  30.         jf.setVisible(true);
  31.     }
  32.  
  33.     public static void main(String[] args) {
  34.         new JTabbedPaneTest().init();
  35.     }
  36. }

三、Swing布局

1、BorderLayout

        其中边上的4个方向可以不设置，这样就可以实现列和行布局模式了。

  1. public class BorderLayoutTest extends JFrame {  //0.继承JFrame
  2.  
  3.     public BorderLayoutTest() {
  4.         //1. 创建组件
  5.         JButton jButton = new JButton("中间");
  6.         JButton jButton2 = new JButton("北间");
  7.         JButton jButton3 = new JButton("西间");
  8.         JButton jButton4 = new JButton("东间");
  9.         JButton jButton5 = new JButton("南间");
  10.  
  11.         //2. 添加各个组件
  12.         this.add(jButton, BorderLayout.CENTER);  //布局的中间
  13.         this.add(jButton2, BorderLayout.NORTH);  //布局的北边
  14.         this.add(jButton3, BorderLayout.WEST);   //布局的西边
  15.         this.add(jButton4, BorderLayout.EAST);   //布局的东边
  16.         this.add(jButton5, BorderLayout.SOUTH);  //布局的南边
  17.  
  18.         //3. 设置窗体属性
  19.         this.setTitle("演示边界布局管理器");
  20.         this.setSize(300, 200);
  21.         this.setLocation(200, 200);
  22.         this.setVisible(true);
  23.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  24.     }
  25.     public static void main(String[] args) {
  26.         new BorderLayoutTest();
  27.     }
  28. }

 2、FlowLayout

        一种流布局模式，控件会按添加顺序依次摆放，如果超过容器大小会自动换行。

  1. public class FlowLayoutTest extends JFrame {  //0.继承JFrame
  2.  
  3.     public FlowLayoutTest() {
  4.         //1. 创建组件
  5.         JButton jButton1 = new JButton("A");
  6.         JButton jButton2 = new JButton("B");
  7.         JButton jButton3 = new JButton("C");
  8.         JButton jButton4 = new JButton("D");
  9.         JButton jButton5 = new JButton("E");
  10.  
  11.         //2. 添加各个组件
  12.         this.add(jButton1);
  13.         this.add(jButton2);
  14.         this.add(jButton3);
  15.         this.add(jButton4);
  16.         this.add(jButton5);
  17.         //设置流布局
  18.         this.setLayout(new FlowLayout(FlowLayout.LEFT));
  19.  
  20.  
  21.         //4. 设置窗体属性
  22.         this.setTitle("演示流布局管理器"); //设置标题
  23.         this.setSize(300, 200);       //设置
  24.         this.setLocation(200, 200);   //设置窗体出现的位置
  25.         this.setVisible(true);        //设置窗体可见
  26.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //设置窗体关闭的同时关闭jvm
  27.         this.setResizable(false);  //Resizable:可调整大小的，设置窗体大小不可变
  28.     }
  29.     public static void main(String[] args) {
  30.         new FlowLayoutTest();
  31.     }
  32. }

 3、GridLayout

        网格模式，适合比较复杂的布局方式。

  1. public class GridLayoutTest extends JFrame {
  2.     //定义组件
  3.     int size = 9;
  4.     //定义按钮数组
  5.     JButton jButton[] = new JButton[size];
  6.  
  7.     //构造函数
  8.     public GridLayoutTest() {
  9.         //创建组件
  10.         for(int i = 0; i<size; i++){
  11.             jButton[i] = new JButton(String.valueOf(i+1));
  12.             this.add(jButton[i]);
  13.         }
  14.  
  15.         //设置网格布局
  16.         this.setLayout(new GridLayout(3, 3, 10, 30));
  17.  
  18.         //设置窗格属性
  19.         this.setTitle("演示网格布局管理器");
  20.         this.setSize(400, 400);
  21.         this.setLocation(200, 200);
  22.         this.setVisible(true);
  23.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  24.         this.setResizable(false);  //Resizable:可调整大小的
  25.  
  26.     }
  27.     public static void main(String[] args) {
  28.         GridLayoutTest testGridLayout = new GridLayoutTest();
  29.     }
  30. }

4、BoxLayout

        可指定BoxLayout参数控制容器内的元素是按行还是按列排列。

  1. public class BoxLayoutTest {
  2.     public static void main(String[] args) {
  3.         Frame frame = new Frame("这里测试BoxLayout");
  4.         //1.基于frame容器，创建一个BoxLayout对象，并且，该对象存放组件是垂直存放
  5.         //BoxLayout boxLayout = new BoxLayout(frame, BoxLayout.Y_AXIS);
  6.  
  7.         BoxLayout boxLayout = new BoxLayout(frame, BoxLayout.X_AXIS);//水平排列
  8.  
  9.         //2.把BoxLayout对象设置给Frame
  10.         frame.setLayout(boxLayout);
  11.  
  12.         //3.往frame中添加两个按钮组件
  13.         frame.add(new Button("按钮1"));
  14.         frame.add(new Button("按钮2"));
  15.  
  16.         frame.pack();
  17.         frame.setVisible(true);
  18.     }
  19. }

  四、Swing事件

        事件的类型比较多，一个简单的示例如下，有两种方式绑定事件。允许一个事件源绑定多个事件，也允许绑定多个同类型的事件。在内部会形成一个事件链依次执行。

1、定制侦听器

  1. public class EventDemo1 {
  2.     Frame  frame = new Frame("这里测试事件处理");
  3.  
  4.     TextField tf = new TextField(30);
  5.     //事件源
  6.     Button ok = new Button("确定");
  7.  
  8.     public void init(){//组装视图
  9.  
  10.         //注册监听
  11.         ok.addActionListener(new ActionListener() {
  12.             @Override
  13.             public void actionPerformed(ActionEvent e) {
  14.                 System.out.println("ok按钮被点击了...");
  15.                 tf.setText("Hello World");
  16.             }
  17.         });
  18.  
  19.         //把tf和ok放入到Frame中
  20.         frame.add(tf, BorderLayout.NORTH);
  21.         frame.add(ok);
  22.  
  23.         frame.pack();
  24.         frame.setVisible(true);
  25.  
  26.     }
  27.  
  28.  
  29.     public static void main(String[] args) {
  30.         new EventDemo1().init();
  31.     }
  32. }

2、共享侦听器

  1. public class EventDemo1 {
  2.     Frame  frame = new Frame("这里测试事件处理");
  3.     TextField tf = new TextField(30);
  4.     Button ok = new Button("确定");
  5.  
  6.     public void init(){//组装视图
  7.         //监听器,这种写法适合公共监听器，后面多个摈控件通过addActionListener()来共享
  8.         MyListener myListener = new MyListener();
  9.         ok.addActionListener(myListener);
  10.  
  11.         //把tf和ok放入到Frame中
  12.         frame.add(tf, BorderLayout.NORTH);
  13.         frame.add(ok);
  14.  
  15.         frame.pack();
  16.         frame.setVisible(true);
  17.  
  18.     }
  19.  
  20.     public static void main(String[] args) {
  21.         new EventDemo1().init();
  22.     }
  23. }
  24.  
  25. class MyListener implements ActionListener{
  26.     @Override
  27.     public void actionPerformed(ActionEvent e) {
  28.         System.out.println("ok按钮被点击了...");
  29.     }
  30. }

五、Swing进度条

        主要使用JProgressBar、ProgressMonitor、BoundedRangeModel实现进度条。

1、主线程内的进度条

        这种耗时操作放在主线程的话，会导致执行耗时操作时，用户无法再进行任何操作，因此最好将耗时操作放入子线程中。

  1. public class JProgressTest {
  2.     JFrame jf = new JFrame("测试进度条");
  3.  
  4.  
  5.     //创建进度条
  6.     JProgressBar bar = new JProgressBar(JProgressBar.HORIZONTAL,0,100);
  7.  
  8.     public void init(){
  9.         //组装视图
  10.         Box vBox = Box.createVerticalBox();
  11.  
  12.         //设置进度条的属性
  13.         bar.setStringPainted(true);
  14.         bar.setBorderPainted(true);
  15.  
  16.         //把当前窗口的布局方式修改为FlowLayout
  17.         jf.setLayout(new FlowLayout());
  18.         jf.add(vBox);
  19.         jf.add(bar);
  20.  
  21.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  22.         jf.pack();
  23.         jf.setVisible(true);
  24.  
  25.         //通过循环模拟修改进度条的进度
  26.         for (int i = 0; i <= 100; i++) {
  27.             //修改已经完成的工作量，也就是百分比
  28.             bar.setValue(i);
  29.  
  30.             try {
  31.                 Thread.sleep(500);
  32.             } catch (InterruptedException e) {
  33.                 e.printStackTrace();
  34.             }
  35.         }
  36.     }
  37.  
  38.     public static void main(String[] args) {
  39.         new JProgressTest().init();
  40.     }
  41. }

 2、线程内的进度条（推荐）

  1. public class JProgressTest2 {
  2.  
  3.     JFrame jf = new JFrame("测试进度条");
  4.  
  5.     //创建进度条
  6.     JProgressBar bar = new JProgressBar(JProgressBar.HORIZONTAL,0,100);
  7.  
  8.  
  9.     public void init(){
  10.         //组装视图
  11.         Box vBox = Box.createVerticalBox();
  12.  
  13.         //设置进度条的属性
  14.         bar.setStringPainted(true);
  15.         bar.setBorderPainted(true);
  16.  
  17.         //把当前窗口的布局方式修改为FlowLayout
  18.         jf.setLayout(new FlowLayout());
  19.         jf.add(vBox);
  20.         jf.add(bar);
  21.  
  22.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  23.         jf.pack();
  24.         jf.setVisible(true);
  25.  
  26.         //开启子线程，模拟耗时操作
  27.         SimulaterActivity simulaterActivity = new SimulaterActivity();
  28.         simulaterActivity.setAmount(bar.getMaximum());
  29.         new Thread(simulaterActivity).start();
  30.  
  31.         //设置一个定时任务
  32.         Timer timer = new Timer(200, new ActionListener() {
  33.             @Override
  34.             public void actionPerformed(ActionEvent e) {
  35.                 //读取线程任务对象的当前完成量，设置给进度条
  36.                 int current = simulaterActivity.getCurrent();
  37.                 bar.setValue(current);
  38.             }
  39.         });
  40.         timer.start();
  41.  
  42.         //监听进度条的任务变化
  43.         bar.addChangeListener(new ChangeListener() {
  44.             @Override
  45.             public void stateChanged(ChangeEvent e) {
  46.                 int value = bar.getValue();
  47.                 if (value == simulaterActivity.getAmount()){
  48.                     timer.stop();
  49.                 }
  50.             }
  51.         });
  52.     }
  53.  
  54.     @Data
  55.     private class SimulaterActivity implements  Runnable{
  56.         //记录任务总量
  57.         private int amount;
  58.  
  59.         //记录当前任务的完成量
  60.         private volatile int current;
  61.  
  62.         @Override
  63.         public void run() {
  64.             //子线程的任务  模拟耗时操作
  65.             while(current<amount){
  66.                 try {
  67.                     Thread.currentThread().sleep(50);
  68.                 } catch (InterruptedException e) {
  69.                     e.printStackTrace();
  70.                 }
  71.                 current++;
  72.             }
  73.         }
  74.     }
  75.  
  76.     public static void main(String[] args) {
  77.         new JProgressTest2().init();
  78.     }
  79. }

 3、获取进度条数据

        Swing组件大都将外观显示和内部数据分离，JProgressBar也不例外，JProgressBar组件有一个内置的用于保存其状态数据的Model对象，这个对象由BoundedRangeModel对象表示，程序调用JProgressBar对象的方法完成进度百分比的设置，监听进度条的数据变化，其实都是通过
它内置的BoundedRangeModel对象完成的。下面的代码是对之前代码的改进，通过BoundedRangeModel完成数据的设置，获取和监听。

  1. public class JProgressTest3 {
  2.  
  3.     JFrame jf = new JFrame("测试进度条");
  4.  
  5.     //创建进度条
  6.     JProgressBar bar = new JProgressBar(JProgressBar.HORIZONTAL,0,100);
  7.  
  8.     //获取处进度条内置的数据模型对象
  9.     BoundedRangeModel model = bar.getModel();
  10.  
  11.     public void init(){
  12.         //组装视图
  13.         Box vBox = Box.createVerticalBox();
  14.  
  15.         //设置进度条的属性
  16.         bar.setStringPainted(true);
  17.         bar.setBorderPainted(true);
  18.  
  19.         //把当前窗口的布局方式修改为FlowLayout
  20.         jf.setLayout(new FlowLayout());
  21.         jf.add(vBox);
  22.         jf.add(bar);
  23.  
  24.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  25.         jf.pack();
  26.         jf.setVisible(true);
  27.  
  28.         //开启子线程，模拟耗时操作
  29.         SimulaterActivity simulaterActivity = new SimulaterActivity();
  30.         simulaterActivity.setAmount(bar.getMaximum());
  31.         new Thread(simulaterActivity).start();
  32.  
  33.         //设置一个定时任务
  34.         Timer timer = new Timer(200, new ActionListener() {
  35.             @Override
  36.             public void actionPerformed(ActionEvent e) {
  37.                 //读取线程任务对象的当前完成量，设置给进度条
  38.                 int current = simulaterActivity.getCurrent();
  39.                 model.setValue(current);
  40.             }
  41.         });
  42.         timer.start();
  43.  
  44.         //监听进度条的任务变化
  45.         model.addChangeListener(new ChangeListener() {
  46.             @Override
  47.             public void stateChanged(ChangeEvent e) {
  48.                 int value = model.getValue();
  49.                 if (value == simulaterActivity.getAmount()){
  50.                     timer.stop();
  51.                 }
  52.             }
  53.         });
  54.  
  55.  
  56.     }
  57.  
  58.     @Data
  59.     private class SimulaterActivity implements  Runnable{
  60.         //记录任务总量
  61.         private int amount;
  62.  
  63.         //记录当前任务的完成量
  64.         private volatile int current;
  65.  
  66.         @Override
  67.         public void run() {
  68.             //子线程的任务  模拟耗时操作
  69.             while(current<amount){
  70.                 try {
  71.                     Thread.currentThread().sleep(50);
  72.                 } catch (InterruptedException e) {
  73.                     e.printStackTrace();
  74.                 }
  75.  
  76.                 current++;
  77.             }
  78.         }
  79.     }
  80.  
  81.     public static void main(String[] args) {
  82.         new JProgressTest2().init();
  83.     }
  84. }

4、ProgressMonitor

        使用ProgressMonitor创建的对话框里包含的进度条是非常固定的，程序甚至不能设置该进度条是否包含边框（总是包含边框），不能设置进度不确定，不能改变进度条的方向（总是水平方向）。

  1. public class ProgressMonitorTest {
  2.     Timer timer;
  3.     public void init(){
  4.         //创建进度对话框
  5.         ProgressMonitor monitor = new ProgressMonitor(null,"等待任务完成","已完成",0,100);
  6.  
  7.         SimulaterActivity simulaterActivity = new SimulaterActivity(100);
  8.         new Thread(simulaterActivity).start();
  9.  
  10.  
  11.         //设置定时任务
  12.         timer = new Timer(200, new ActionListener() {
  13.             @Override
  14.             public void actionPerformed(ActionEvent e) {
  15.                 //读取当前任务量，修改进度
  16.                 int current = simulaterActivity.getCurrent();
  17.                 monitor.setProgress(current);
  18.  
  19.                 //判断用户是否点击了取消按钮，停止定时任务，关闭对话框，退出程序
  20.                 if (monitor.isCanceled()){
  21.                     timer.stop();
  22.                     monitor.close();
  23.                     System.exit(0);
  24.                 }
  25.  
  26.             }
  27.         });
  28.         timer.start();
  29.  
  30.     }
  31.  
  32.     public static void main(String[] args) {
  33.         new ProgressMonitorTest().init();
  34.     }
  35.  
  36.     //定义一个线程任务，模拟耗时操作
  37.     @Data
  38.     private class SimulaterActivity implements Runnable{
  39.         //内存可见
  40.         private volatile int current = 0;
  41.         private int amount;
  42.  
  43.         public SimulaterActivity(int amount) {
  44.             this.amount = amount;
  45.         }
  46.  
  47.         @Override
  48.         public void run() {
  49.             //通过循环，不断的修改current的值，模拟任务完成量
  50.             while(current<amount){
  51.                 try {
  52.                     Thread.sleep(50);
  53.                 } catch (InterruptedException e) {
  54.                     e.printStackTrace();
  55.                 }
  56.                 current++;
  57.             }
  58.         }
  59.     }
  60.  
  61. }

六、Swing下拉列表

1、简单列表

  1. public class ListTest {
  2.     JFrame jf = new JFrame("列表框测试");
  3.     String[] books = {"java自学宝典","轻量级javaEE企业应用实战","Android基础教程","jQuery实战教程","SpringBoot企业级开发"};
  4.  
  5.     //定义 布局选择按钮 所在的面板
  6.     JPanel layoutPanel = new JPanel();
  7.     ButtonGroup layoutGroup = new ButtonGroup();
  8.  
  9.     //定义 选择模式按钮 所在面板
  10.     JPanel selectModePanel = new JPanel();
  11.     ButtonGroup selectModeGroup = new ButtonGroup();
  12.  
  13.     //用一个字符串数组来创建一个JList对象
  14.     JList<String> bookList ;
  15.     JComboBox<String> bookSelector;
  16.  
  17.     public void init(){
  18.         //组装视图
  19.  
  20.         //组装Jlist相关内容
  21.         bookList = new JList<>(books);
  22.  
  23.         addBtn2LayoutPanel("纵向滚动",JList.VERTICAL);
  24.         addBtn2LayoutPanel("纵向换行",JList.VERTICAL_WRAP);
  25.         addBtn2LayoutPanel("横向换行",JList.HORIZONTAL_WRAP);
  26.  
  27.         addBtn2SelectModelPanel("无限制",ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
  28.         addBtn2SelectModelPanel("单选",ListSelectionModel.SINGLE_SELECTION);
  29.         addBtn2SelectModelPanel("单范围",ListSelectionModel.SINGLE_INTERVAL_SELECTION);
  30.  
  31.         //对JList做设置
  32.         bookList.setVisibleRowCount(3);
  33.         bookList.setSelectionInterval(2,4);
  34.  
  35.         //处理条目选中事件
  36.         bookList.addListSelectionListener(new ListSelectionListener() {
  37.             @Override
  38.             public void valueChanged(ListSelectionEvent e) {
  39.                 //获取当前选中的条目
  40.                 java.util.List<String> selectedValuesList = bookList.getSelectedValuesList();
  41.                 //把当前条目的内容设置到文本域中。
  42.             }
  43.         });
  44.  
  45.         Box bookListVBox = Box.createVerticalBox();
  46.         bookListVBox.add(new JScrollPane(bookList));
  47.         bookListVBox.add(layoutPanel);
  48.         bookListVBox.add(selectModePanel);
  49.  
  50.         //组装JComboBox
  51.         Vector<String> vector = new Vector<>();
  52.         for (int i = 0; i < books.length; i++) {
  53.             vector.add(books[i]);
  54.         }
  55.  
  56.         bookSelector = new JComboBox<>(vector);
  57.         bookSelector.setEditable(true);
  58.         bookSelector.setMaximumRowCount(4);
  59.  
  60.         //组装顶部的左右两部分
  61.         Box topBox = Box.createHorizontalBox();
  62.         topBox.add(bookListVBox);
  63.         JPanel bookSelectPanel = new JPanel();
  64.         bookSelectPanel.add(bookSelector);
  65.         topBox.add(bookSelectPanel);
  66.  
  67.         //组装底部
  68.         JPanel bottomPanel = new JPanel();
  69.         bottomPanel.setLayout(new BorderLayout());
  70.  
  71.         //组装整体
  72.         Box holeBox = Box.createVerticalBox();
  73.         holeBox.add(topBox);
  74.         holeBox.add(bottomPanel);
  75.  
  76.         jf.add(holeBox);
  77.  
  78.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  79.         jf.pack();
  80.         jf.setVisible(true);
  81.     }
  82.  
  83.     //封装方法，往layoutPanel中添加单选按钮
  84.     public void addBtn2LayoutPanel(String name,int layoutType){
  85.         //设置标题边框
  86.         layoutPanel.setBorder(new TitledBorder(new EtchedBorder(),"确定选项布局"));
  87.         //创建单选按钮
  88.         JRadioButton button = new JRadioButton(name);
  89.         layoutPanel.add(button);
  90.  
  91.         //让第一个按钮默认选中
  92.         if (layoutGroup.getButtonCount()==0){
  93.             button.setSelected(true);
  94.         }
  95.  
  96.         layoutGroup.add(button);
  97.  
  98.         button.addActionListener(new ActionListener() {
  99.             @Override
  100.             public void actionPerformed(ActionEvent e) {
  101.                 bookList.setLayoutOrientation(layoutType);
  102.             }
  103.         });
  104.     }
  105.  
  106.     //封装方法，给selectModelPanel添加按钮
  107.     public void addBtn2SelectModelPanel(String name,int selectionModel){
  108.         //设置标题边框
  109.         selectModePanel.setBorder(new TitledBorder(new EtchedBorder(),"确定选择模式"));
  110.         //创建单选按钮
  111.         JRadioButton button = new JRadioButton(name);
  112.         selectModePanel.add(button);
  113.  
  114.         //让第一个按钮默认选中
  115.         if (selectModeGroup.getButtonCount()==0){
  116.             button.setSelected(true);
  117.         }
  118.  
  119.         selectModeGroup.add(button);
  120.         button.addActionListener(new ActionListener() {
  121.             @Override
  122.             public void actionPerformed(ActionEvent e) {
  123.                 bookList.setSelectionMode(selectionModel);
  124.             }
  125.         });
  126.     }
  127.     public static void main(String[] args) {
  128.         new ListTest().init();
  129.     }
  130. }

 2、固定值的列表

  1. public class NumberListModel extends AbstractListModel<BigDecimal> {
  2.     BigDecimal start;
  3.     BigDecimal end;
  4.     BigDecimal step;
  5.  
  6.     public NumberListModel(BigDecimal start, BigDecimal end, BigDecimal step) {
  7.         this.start = start;
  8.         this.end = end;
  9.         this.step = step;
  10.     }
  11.  
  12.  
  13.     @Override
  14.     public int getSize() {
  15.         int floor = (int) Math.floor(end.subtract(start).divide(step,2, RoundingMode.HALF_DOWN).doubleValue());
  16.         return floor+1;
  17.     }
  18.  
  19.     @Override
  20.     public BigDecimal getElementAt(int index) {
  21.         BigDecimal ele = new BigDecimal(index).multiply(step).add(start).setScale(2, RoundingMode.HALF_DOWN);
  22.         return ele;
  23.     }
  24. }
  1. public class NumberComboBoxListModel extends NumberListModel implements ComboBoxModel<BigDecimal> {
  2.     //当前选中条目的索引
  3.     private int selectedId;
  4.  
  5.  
  6.     public NumberComboBoxListModel(BigDecimal start, BigDecimal end, BigDecimal step) {
  7.         super(start, end, step);
  8.     }
  9.  
  10.     @Override
  11.     public void setSelectedItem(Object anItem) {
  12.  
  13.         if (anItem instanceof BigDecimal){
  14.             BigDecimal curr = (BigDecimal) anItem;
  15.             selectedId = curr.subtract(super.start).divide(super.step,2, RoundingMode.HALF_DOWN).intValue();
  16.         }
  17.     }
  18.  
  19.     @Override
  20.     public Object getSelectedItem() {
  21.  
  22.         BigDecimal item = new BigDecimal(selectedId).multiply(super.step).add(super.start).setScale(1, RoundingMode.HALF_DOWN);
  23.  
  24.         return item;
  25.     }
  26. }
  1. public class ListModelTest {
  2.     JFrame jf = new JFrame("测试ListModel");
  3.     JList<BigDecimal> jList = new JList<>(new NumberListModel(new BigDecimal(1),new BigDecimal(21),new BigDecimal(2)));
  4.  
  5.     JComboBox<BigDecimal> jComboBox = new JComboBox<>(new NumberComboBoxListModel(new BigDecimal(0.1),new BigDecimal(1.2),new BigDecimal(0.1)));
  6.  
  7.     JLabel label = new JLabel("您选择的值是：");
  8.  
  9.     JTextField jTextField = new JTextField(15);
  10.  
  11.     public void init(){
  12.         //组装视图
  13.  
  14.         //组装顶部
  15.         jList.setVisibleRowCount(4);
  16.         jList.setSelectionInterval(2,4);
  17.  
  18.         jList.setFixedCellWidth(90);
  19.         jList.setFixedCellHeight(30);
  20.  
  21.         jList.addListSelectionListener(new ListSelectionListener() {
  22.             @Override
  23.             public void valueChanged(ListSelectionEvent e) {
  24.                 java.util.List<BigDecimal> selectedValuesList = jList.getSelectedValuesList();
  25.                 jTextField.setText("");
  26.                 for (BigDecimal item : selectedValuesList) {
  27.                     jTextField.setText(jTextField.getText()+item.toString()+",");
  28.                 }
  29.             }
  30.         });
  31.  
  32.         jComboBox.setMaximumRowCount(4);
  33.         jComboBox.addItemListener(new ItemListener() {
  34.             @Override
  35.             public void itemStateChanged(ItemEvent e) {
  36.                 Object selectedItem = jComboBox.getSelectedItem();
  37.                 jTextField.setText(selectedItem.toString());
  38.             }
  39.         });
  40.  
  41.         Box hBox = Box.createHorizontalBox();
  42.         hBox.add(new JScrollPane(jList));
  43.  
  44.         JPanel tempPanel = new JPanel();
  45.         tempPanel.add(jComboBox);
  46.         hBox.add(tempPanel);
  47.         jf.add(hBox);
  48.  
  49.         //组装底部
  50.         JPanel bottomPanel = new JPanel();
  51.         bottomPanel.add(label);
  52.         bottomPanel.add(jTextField);
  53.  
  54.         jf.add(bottomPanel, BorderLayout.SOUTH);
  55.  
  56.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  57.         jf.pack();
  58.         jf.setVisible(true);
  59.  
  60.     }
  61.  
  62.     public static void main(String[] args) {
  63.         new ListModelTest().init();
  64.     }
  65. }

 3、动态改变列表的值

  1. public class DefaultListModelTest {
  2.  
  3.     JFrame jf = new JFrame("测试DefaultListModel");
  4.  
  5.     JTextField bookName = new JTextField(20);
  6.  
  7.     JButton removeBtn = new JButton("删除选中图书");
  8.  
  9.     JButton addBtn = new JButton("添加指定图书");
  10.  
  11.     //创建JList
  12.     JList<String> bookList;
  13.  
  14.     DefaultListModel<String> model = new DefaultListModel<>();
  15.  
  16.     public void init(){
  17.         //组装视图
  18.         model.addElement("java自学宝典");
  19.         model.addElement("轻量级JavaEE企业应用实战");
  20.         model.addElement("Android基础教程");
  21.         model.addElement("JQuery实战教程");
  22.  
  23.         bookList = new JList<>(model);
  24.  
  25.         //设置Jlist
  26.         bookList.setVisibleRowCount(4);
  27.         //设置单选
  28.         bookList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  29.  
  30.         jf.add(new JScrollPane(bookList));
  31.  
  32.         //组装底部
  33.         addBtn.addActionListener(new ActionListener() {
  34.             @Override
  35.             public void actionPerformed(ActionEvent e) {
  36.                 String name = bookName.getText();
  37.                 if (!name.trim().equals("")){//不是空字符串才添加
  38.                     model.addElement(name);
  39.                 }
  40.             }
  41.         });
  42.  
  43.         removeBtn.addActionListener(new ActionListener() {
  44.             @Override
  45.             public void actionPerformed(ActionEvent e) {
  46.                 int selectedIndex = bookList.getSelectedIndex();
  47.  
  48.                 if (selectedIndex>=0){
  49.                     model.remove(selectedIndex);
  50.                 }
  51.             }
  52.         });
  53.  
  54.  
  55.         JPanel bottomPanel = new JPanel();
  56.         bottomPanel.add(bookName);
  57.         bottomPanel.add(addBtn);
  58.         bottomPanel.add(removeBtn);
  59.  
  60.         jf.add(bottomPanel, BorderLayout.SOUTH);
  61.  
  62.  
  63.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  64.         jf.pack();
  65.         jf.setVisible(true);
  66.  
  67.     }
  68.  
  69.     public static void main(String[] args) {
  70.         new DefaultListModelTest().init();
  71.     }
  72.  
  73. }

 4、改变列表控件外观

  1. public class ListCellRendererTest {
  2.  
  3.     private JFrame mainWin = new JFrame("好友列表");
  4.  
  5.     private String[] friends = {
  6.             "李清照",
  7.             "苏格拉底",
  8.             "李白",
  9.             "弄玉",
  10.             "虎头"
  11.     };
  12.  
  13.     //定义一个JList对象
  14.     JList friendsList = new JList(friends);
  15.  
  16.     public void init() {
  17.         //组装视图
  18.         //给JList设置ListCellRenderer对象,指定列表项绘制的组件
  19.         friendsList.setCellRenderer(new MyRenderer());
  20.  
  21.         mainWin.add(friendsList);
  22.  
  23.         mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  24.         mainWin.pack();
  25.         mainWin.setVisible(true);
  26.  
  27.     }
  28.  
  29.     private class MyRenderer extends JPanel implements ListCellRenderer{
  30.         private String name;
  31.         private ImageIcon icon;
  32.  
  33.         //记录背景色
  34.         private Color backGround;
  35.         //记录前景色：文字的颜色
  36.         private Color forceGround;
  37.  
  38.  
  39.         @Override
  40.         public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
  41.             //重置成员变量的值
  42.             this.name = value.toString();
  43.             this.icon = new ImageIcon("E:\\GUISwing\\img\\tree\\"+name+".gif");
  44.  
  45.             this.backGround = isSelected? list.getSelectionBackground() : list.getBackground();
  46.             this.forceGround = isSelected? list.getSelectionForeground() : list.getForeground();
  47.  
  48.             return this;
  49.         }
  50.  
  51.         @Override
  52.         public Dimension getPreferredSize() {
  53.             return new Dimension(60,80);
  54.         }
  55.  
  56.         //绘制列表项的内容
  57.         @Override
  58.         public void paint(Graphics g) {
  59.             int imageWidth = icon.getImage().getWidth(null);
  60.             int imageHeight = icon.getImage().getHeight(null);
  61.  
  62.             //填充背景矩形
  63.             g.setColor(backGround);
  64.             g.fillRect(0,0,getWidth(),getHeight());
  65.  
  66.             //绘制头像
  67.             g.drawImage(icon.getImage(),this.getWidth()/2 -imageWidth/2 ,10,null);
  68.  
  69.             //绘制昵称
  70.             g.setColor(forceGround);
  71.             g.setFont(new Font("StSong",Font.BOLD,18));
  72.             g.drawString(this.name,this.getWidth()/2 - this.name.length()*20/2,imageHeight+30);
  73.  
  74.         }
  75.     }
  76.  
  77.  
  78.     public static void main(String[] args) {
  79.         new ListCellRendererTest().init();
  80.     }
  81.  
  82. }

七、Swing表格

1、简单表格

  1. public class SimpleTable {
  2.  
  3.     JFrame jf = new JFrame("简单表格");
  4.  
  5.     //创建一维数组，存储标题
  6.     Object[] titles = {"姓名","年龄","性别"};
  7.  
  8.     //创建二维数组，存储数据
  9.     Object[][] data = {
  10.             {"李清照",29,"女"},
  11.             {"苏格拉底",56,"男"},
  12.             {"李白",35,"男"},
  13.             {"弄玉",18,"女"},
  14.             {"虎头",2,"男"}
  15.  
  16.     };
  17.  
  18.     public void init(){
  19.         //组装视图
  20.         JTable jTable = new JTable(data,titles);
  21.  
  22.         jf.add(new JScrollPane(jTable));
  23.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  24.         jf.pack();
  25.         jf.setVisible(true);
  26.     }
  27.  
  28.     public static void main(String[] args) {
  29.         new SimpleTable().init();
  30.     }
  31. }

2、TableModel

  1. public class TableModelTest {
  2.     JFrame jf = new JFrame("TableModel演示");
  3.     //创建一维数组，存储标题
  4.     Object[] titles = {"姓名","年龄","性别"};
  5.  
  6.     //创建二维数组，存储数据
  7.     Object[][] data = {
  8.             {"李清照",29,"女"},
  9.             {"苏格拉底",56,"男"},
  10.             {"李白",35,"男"},
  11.             {"弄玉",18,"女"},
  12.             {"虎头",2,"男"}
  13.     };
  14.     private Vector titlesV = new Vector();//存储标题
  15.     private Vector<Vector> dataV = new Vector<>();//存储数据
  16.  
  17.     public void init(){
  18.         //组装视图
  19.         for (int i = 0; i < titles.length; i++) {
  20.             titlesV.add(titles[i]);
  21.         }
  22.  
  23.         for (int i = 0; i < data.length; i++) {
  24.             Vector t = new Vector<>();
  25.             for (int j = 0; j < data[i].length; j++) {
  26.                 t.add(data[i][j]);
  27.             }
  28.             dataV.add(t);
  29.         }
  30.         MyTableModel myTableModel = new MyTableModel();
  31.         //JTable jTable = new JTable(dataV,titlesV);
  32.         JTable jTable = new JTable(myTableModel);
  33.  
  34.         jf.add(new JScrollPane(jTable));
  35.  
  36.         JButton btn = new JButton("获取选中行数据");
  37.         btn.addActionListener(new ActionListener() {
  38.             @Override
  39.             public void actionPerformed(ActionEvent e) {
  40.                 int selectedColumn = jTable.getSelectedColumn();
  41.                 int selectedRow = jTable.getSelectedRow();
  42.                 System.out.println("当前选中行的索引："+selectedRow);
  43.                 System.out.println("当前选中列的索引："+selectedColumn);
  44.  
  45.                 Object value = myTableModel.getValueAt(selectedRow, selectedColumn);
  46.                 System.out.println("当前选中行第一个单元格的内容为："+value);
  47.             }
  48.         });
  49.         jf.add(btn, BorderLayout.SOUTH);
  50.  
  51.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  52.         jf.pack();
  53.         jf.setVisible(true);
  54.     }
  55.  
  56.     private class MyTableModel extends AbstractTableModel {
  57.  
  58.         @Override
  59.         public int getRowCount() {
  60.             return dataV.size();
  61.         }
  62.  
  63.         @Override
  64.         public int getColumnCount() {
  65.             return titlesV.size();
  66.         }
  67.  
  68.         @Override
  69.         public Object getValueAt(int rowIndex, int columnIndex) {
  70.             return dataV.get(rowIndex).get(columnIndex);
  71.         }
  72.  
  73.         @Override
  74.         public String getColumnName(int column) {
  75.             return (String) titlesV.get(column);
  76.         }
  77.  
  78.         @Override
  79.         public boolean isCellEditable(int rowIndex, int columnIndex) {
  80.             return false;
  81.         }
  82.     }
  83.  
  84.  
  85.     public static void main(String[] args) {
  86.         new TableModelTest().init();
  87.     }
  88.  
  89. }
  1. public class DefaultTableModelTest {
  2.     JFrame jf = new JFrame("TableModel演示");
  3.     //创建一维数组，存储标题
  4.     Object[] titles = {"姓名","年龄","性别"};
  5.  
  6.     //创建二维数组，存储数据
  7.     Object[][] data = {
  8.             {"李清照",29,"女"},
  9.             {"苏格拉底",56,"男"},
  10.             {"李白",35,"男"},
  11.             {"弄玉",18,"女"},
  12.             {"虎头",2,"男"}
  13.  
  14.     };
  15.  
  16.     private Vector titlesV = new Vector();//存储标题
  17.     private Vector<Vector> dataV = new Vector<>();//存储数据
  18.  
  19.  
  20.  
  21.     public void init(){
  22.         //组装视图
  23.         for (int i = 0; i < titles.length; i++) {
  24.             titlesV.add(titles[i]);
  25.         }
  26.  
  27.         for (int i = 0; i < data.length; i++) {
  28.             Vector t = new Vector<>();
  29.             for (int j = 0; j < data[i].length; j++) {
  30.                 t.add(data[i][j]);
  31.             }
  32.             dataV.add(t);
  33.         }
  34.  
  35.  
  36.         //通过DefaultTableModel创建JTable
  37.         DefaultTableModel model = new DefaultTableModel(dataV,titlesV);
  38.         JTable jTable = new JTable(model);
  39.  
  40.         //创建按钮
  41.         JButton addRow = new JButton("添加一行");
  42.         JButton addColum = new JButton("添加一列");
  43.         JButton deleteRow = new JButton("删除一行");
  44.  
  45.         addRow.addActionListener(new ActionListener() {
  46.             @Override
  47.             public void actionPerformed(ActionEvent e) {
  48.                 //需要给表格添加一行
  49.                 model.addRow(new Object[]{"胡歌",30,"男"});
  50.             }
  51.         });
  52.  
  53.         deleteRow.addActionListener(new ActionListener() {
  54.             @Override
  55.             public void actionPerformed(ActionEvent e) {
  56.                 int selectedRow = jTable.getSelectedRow();
  57.                 model.removeRow(selectedRow);
  58.             }
  59.         });
  60.  
  61.  
  62.  
  63.         addColum.addActionListener(new ActionListener() {
  64.             @Override
  65.             public void actionPerformed(ActionEvent e) {
  66.                 model.addColumn("职业");
  67.             }
  68.         });
  69.  
  70.         JPanel panel = new JPanel();
  71.         panel.add(addRow);
  72.         panel.add(addColum);
  73.         panel.add(deleteRow);
  74.  
  75.         jf.add(panel, BorderLayout.SOUTH);
  76.  
  77.         jf.add(new JScrollPane(jTable));
  78.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  79.         jf.pack();
  80.         jf.setVisible(true);
  81.     }
  82.  
  83.  
  84.     public static void main(String[] args) {
  85.         new DefaultTableModelTest().init();
  86.     }
  87.  
  88. }

 八、Swing树

1、创建树

  1. public class SimpleJTree {
  2.     JFrame jf = new JFrame("简单树");
  3.     public void init(){
  4.  
  5.         //创建DefaultMutableTreeNode对象代表结点
  6.         DefaultMutableTreeNode root = new DefaultMutableTreeNode("中国");
  7.         DefaultMutableTreeNode guangDong = new DefaultMutableTreeNode("广东");
  8.         DefaultMutableTreeNode guangXi = new DefaultMutableTreeNode("广西");
  9.         DefaultMutableTreeNode foShan = new DefaultMutableTreeNode("佛山");
  10.         DefaultMutableTreeNode shanTou = new DefaultMutableTreeNode("汕头");
  11.         DefaultMutableTreeNode guiLin = new DefaultMutableTreeNode("桂林");
  12.         DefaultMutableTreeNode nanNing = new DefaultMutableTreeNode("南宁");
  13.  
  14.         //组装结点之间的关系
  15.         root.add(guangDong);
  16.         root.add(guangXi);
  17.  
  18.         guangDong.add(foShan);
  19.         guangDong.add(shanTou);
  20.  
  21.         guangXi.add(guiLin);
  22.         guangXi.add(nanNing);
  23.  
  24.         //创建JTree对象
  25.         JTree tree = new JTree(root);
  26.  
  27.         //把JTree放入到窗口中进行展示
  28.         jf.add(tree);
  29.  
  30.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  31.         jf.pack();
  32.         jf.setVisible(true);
  33.  
  34.     }
  35.  
  36.     public static void main(String[] args) {
  37.         new SimpleJTree().init();
  38.     }
  39. }

2、编辑树

编辑树节点

  1. public class EditTree {
  2.  
  3.     JFrame jf = new JFrame("可编辑结点的树");
  4.  
  5.     //定义几个初始结点
  6.     DefaultMutableTreeNode root = new DefaultMutableTreeNode("中国");
  7.     DefaultMutableTreeNode guangdong = new DefaultMutableTreeNode("广东");
  8.     DefaultMutableTreeNode guangxi = new DefaultMutableTreeNode("广西");
  9.     DefaultMutableTreeNode foshan = new DefaultMutableTreeNode("佛山");
  10.     DefaultMutableTreeNode shantou = new DefaultMutableTreeNode("汕头");
  11.     DefaultMutableTreeNode guilin = new DefaultMutableTreeNode("桂林");
  12.     DefaultMutableTreeNode nanning = new DefaultMutableTreeNode("南宁");
  13.  
  14.  
  15.     //定义按钮，完成操作
  16.     JButton addSiblingBtn = new JButton("添加兄弟结点");
  17.     JButton addChildBtn = new JButton("添加子结点");
  18.     JButton deleteBtn = new JButton("删除结点");
  19.     JButton editBtn = new JButton("编辑当前结点");
  20.  
  21.     public void init() {
  22.  
  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);
  30.  
  31.         JTree tree = new JTree(root);
  32.  
  33.         //完成树的结点编辑的代码
  34.         tree.setEditable(true);
  35.         DefaultTreeModel model = (DefaultTreeModel) tree.getModel();
  36.  
  37.         //处理添加
  38.         addSiblingBtn.addActionListener(new ActionListener() {
  39.             @Override
  40.             public void actionPerformed(ActionEvent e) {
  41.                 //添加兄弟结点逻辑
  42.  
  43.                 //1.获取当前选中的结点
  44.                 DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
  45.                 if (selectedNode == null) {
  46.                     return;
  47.                 }
  48.  
  49.                 //2.获取当前结点的父结点
  50.                 DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode) selectedNode.getParent();
  51.                 if (parentNode == null) {
  52.                     return;
  53.                 }
  54.  
  55.                 //3.创建新结点
  56.                 DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("新结点");
  57.  
  58.                 //4.把新结点通过父结点进行添加
  59.                 int index = parentNode.getIndex(selectedNode);
  60.                 model.insertNodeInto(newNode, parentNode, index);
  61.  
  62.                 //5.显示新结点
  63.                 TreeNode[] pathToRoot = model.getPathToRoot(newNode);
  64.                 TreePath treePath = new TreePath(pathToRoot);
  65.                 tree.scrollPathToVisible(treePath);
  66.  
  67.                 //6.重绘tree
  68.                 tree.updateUI();
  69.  
  70.             }
  71.         });
  72.  
  73.         addChildBtn.addActionListener(new ActionListener() {
  74.             @Override
  75.             public void actionPerformed(ActionEvent e) {
  76.                 //为选中结点添加子节点
  77.  
  78.                 //1.获取选中结点
  79.                 DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
  80.                 if (selectedNode == null) {
  81.                     return;
  82.                 }
  83.                 //2.创建新结点
  84.                 DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("新结点");
  85.  
  86.                 //3.把新结点添加到当前结点中
  87.                 selectedNode.add(newNode);
  88.  
  89.                 //4.显示新结点
  90.                 TreeNode[] pathToRoot = model.getPathToRoot(newNode);
  91.                 TreePath treePath = new TreePath(pathToRoot);
  92.                 tree.scrollPathToVisible(treePath);
  93.  
  94.                 //5.重绘UI
  95.                 tree.updateUI();
  96.             }
  97.         });
  98.  
  99.         //处理删除
  100.         deleteBtn.addActionListener(new ActionListener() {
  101.             @Override
  102.             public void actionPerformed(ActionEvent e) {
  103.  
  104.                 DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
  105.  
  106.                 if (selectedNode != null && selectedNode.getParent() != null) {
  107.                     model.removeNodeFromParent(selectedNode);
  108.                 }
  109.  
  110.             }
  111.         });
  112.  
  113.         //处理编辑
  114.         editBtn.addActionListener(new ActionListener() {
  115.             @Override
  116.             public void actionPerformed(ActionEvent e) {
  117.                 //获取当前选中结点的路径
  118.                 TreePath selectionPath = tree.getSelectionPath();
  119.  
  120.                 //判断如果路径不为空，则设置该路径的最后一个结点可编辑
  121.                 if (selectionPath != null) {
  122.                     tree.startEditingAtPath(selectionPath);
  123.                 }
  124.             }
  125.         });
  126.         jf.add(new JScrollPane(tree));
  127.  
  128.         JPanel panel = new JPanel();
  129.         panel.add(addSiblingBtn);
  130.         panel.add(addChildBtn);
  131.         panel.add(deleteBtn);
  132.         panel.add(editBtn);
  133.  
  134.         jf.add(panel, BorderLayout.SOUTH);
  135.  
  136.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  137.         jf.pack();
  138.         jf.setVisible(true);
  139.  
  140.     }
  141.  
  142.     public static void main(String[] args) {
  143.         new EditTree().init();
  144.     }
  145. }

 监听节点事件

  1. public class ListenerJTree {
  2.     JFrame jf = new JFrame("监听树的选择事件");
  3.  
  4.     JTree tree;
  5.  
  6.     DefaultMutableTreeNode root = new DefaultMutableTreeNode("中国");
  7.     DefaultMutableTreeNode guangdong = new DefaultMutableTreeNode("广东");
  8.     DefaultMutableTreeNode guangxi = new DefaultMutableTreeNode("广西");
  9.     DefaultMutableTreeNode foshan = new DefaultMutableTreeNode("佛山");
  10.     DefaultMutableTreeNode shantou = new DefaultMutableTreeNode("汕头");
  11.     DefaultMutableTreeNode guilin = new DefaultMutableTreeNode("桂林");
  12.     DefaultMutableTreeNode nanning = new DefaultMutableTreeNode("南宁");
  13.  
  14.     JTextArea eventTxt = new JTextArea(5, 20);
  15.  
  16.     public void init() {
  17.  
  18.         //通过add()方法建立父子层级关系
  19.         guangdong.add(foshan);
  20.         guangdong.add(shantou);
  21.         guangxi.add(guilin);
  22.         guangxi.add(nanning);
  23.         root.add(guangdong);
  24.         root.add(guangxi);
  25.  
  26.         tree = new JTree(root);
  27.  
  28.         //TODO 设置选择模式
  29.         TreeSelectionModel selectionModel = tree.getSelectionModel();
  30.         selectionModel.setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
  31.  
  32.         //TODO 设置监听器
  33.         tree.addTreeSelectionListener(new TreeSelectionListener() {
  34.             @Override
  35.             public void valueChanged(TreeSelectionEvent e) {
  36.                 //把当前选中结点的路径显示到文本域中
  37.                 TreePath newLeadSelectionPath = e.getNewLeadSelectionPath();
  38.  
  39.                 eventTxt.append(newLeadSelectionPath.toString()+"\n");
  40.             }
  41.         });
  42.  
  43.         Box box = Box.createHorizontalBox();
  44.         box.add(new JScrollPane(tree));
  45.         box.add(new JScrollPane(eventTxt));
  46.  
  47.         jf.add(box);
  48.         jf.pack();
  49.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  50.         jf.setVisible(true);
  51.     }
  52.  
  53.     public static void main(String[] args) {
  54.         new ListenerJTree().init();
  55.     }
  56. }

3、改变树外观

  1. public class ChangeAllCellRender {
  2.  
  3.     JFrame jf = new JFrame("改变所有结点外观");
  4.  
  5.     JTree tree;
  6.  
  7.     DefaultMutableTreeNode root = new DefaultMutableTreeNode("中国");
  8.     DefaultMutableTreeNode guangdong = new DefaultMutableTreeNode("广东");
  9.     DefaultMutableTreeNode guangxi = new DefaultMutableTreeNode("广西");
  10.     DefaultMutableTreeNode foshan = new DefaultMutableTreeNode("佛山");
  11.     DefaultMutableTreeNode shantou = new DefaultMutableTreeNode("汕头");
  12.     DefaultMutableTreeNode guilin = new DefaultMutableTreeNode("桂林");
  13.     DefaultMutableTreeNode nanning = new DefaultMutableTreeNode("南宁");
  14.  
  15.     public void init(){
  16.         //通过add()方法建立父子层级关系
  17.         guangdong.add(foshan);
  18.         guangdong.add(shantou);
  19.         guangxi.add(guilin);
  20.         guangxi.add(nanning);
  21.         root.add(guangdong);
  22.         root.add(guangxi);
  23.  
  24.         tree = new JTree(root);
  25.  
  26.         DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();
  27.         //设置非选定结点的背景颜色
  28.         renderer.setBackgroundNonSelectionColor(new Color(220,220,220));
  29.         //设置选中结点的背景色
  30.         renderer.setBackgroundSelectionColor(new Color(140,140,140));
  31.         //设置选中状态下结点的边框颜色
  32.         renderer.setBorderSelectionColor(Color.BLACK);
  33.         //设置处于折叠状态下非叶子结点的图标
  34.         renderer.setClosedIcon(new ImageIcon("E:\\GUISwing\\img\\tree\\close.gif"));
  35.         //设置结点文本的字体
  36.         renderer.setFont(new Font("StSong", Font.BOLD,16));
  37.         //设置叶子结点图标
  38.         renderer.setLeafIcon(new ImageIcon("E:\\GUISwing\\img\\tree\\leaf.png"));
  39.         //设置处于展开状态下非叶子结点图标
  40.         renderer.setOpenIcon(new ImageIcon("E:\\GUISwing\\img\\tree\\open.gif"));
  41.         //设置绘制非选中状态下结点文本颜色
  42.         renderer.setTextNonSelectionColor(new Color(255,0,0));
  43.         //设置选中状态下结点的文本颜色
  44.         renderer.setTextSelectionColor(new Color(0,0,255));
  45.  
  46.         //把结点绘制器设置给树对象
  47.         tree.setCellRenderer(renderer);
  48.  
  49.         jf.add(new JScrollPane(tree));
  50.         jf.pack();
  51.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  52.         jf.setVisible(true);
  53.  
  54.     }
  55.     public static void main(String[] args) {
  56.         new ChangeAllCellRender().init();
  57.     }
  58. }
  1. public class ExtendsDefaultCellTreeRenderer {
  2.  
  3.     JFrame jf = new JFrame("根据结点类型定义图标");
  4.  
  5.     JTree tree;
  6.  
  7.     //初始化5个图标
  8.     ImageIcon rootIcon = new ImageIcon("E:\\GUISwing\\img\\tree\\root.gif");
  9.     ImageIcon databaseIcon = new ImageIcon("E:\\GUISwing\\img\\tree\\database.gif");
  10.     ImageIcon tableIcon = new ImageIcon("E:\\GUISwing\\img\\tree\\table.gif");
  11.     ImageIcon columnIcon = new ImageIcon("E:\\GUISwing\\img\\tree\\column.gif");
  12.     ImageIcon indexIcon = new ImageIcon("E:\\GUISwing\\img\\tree\\index.gif");
  13.  
  14.     //定义一个NodeData类，用于封装结点数据
  15.     class NodeData{
  16.         public ImageIcon icon;
  17.         public String name;
  18.  
  19.         public NodeData(ImageIcon icon, String name) {
  20.             this.icon = icon;
  21.             this.name = name;
  22.         }
  23.  
  24.  
  25.     }
  26.  
  27.     //定义几个初始结点
  28.     DefaultMutableTreeNode root = new DefaultMutableTreeNode(new NodeData(rootIcon,"数据库导航"));
  29.     DefaultMutableTreeNode salaryDb = new DefaultMutableTreeNode(new NodeData(databaseIcon,"公司工资数据库"));
  30.     DefaultMutableTreeNode customerDb = new DefaultMutableTreeNode(new NodeData(databaseIcon,"公司客户数据库"));
  31.     DefaultMutableTreeNode employee = new DefaultMutableTreeNode(new NodeData(tableIcon,"员工表"));
  32.     DefaultMutableTreeNode attend = new DefaultMutableTreeNode(new NodeData(tableIcon,"考勤表"));
  33.     DefaultMutableTreeNode concat = new DefaultMutableTreeNode(new NodeData(tableIcon,"联系方式表"));
  34.     DefaultMutableTreeNode id = new DefaultMutableTreeNode(new NodeData(indexIcon,"员工ID"));
  35.     DefaultMutableTreeNode name = new DefaultMutableTreeNode(new NodeData(columnIcon,"姓名"));
  36.     DefaultMutableTreeNode gender = new DefaultMutableTreeNode(new NodeData(columnIcon,"性别"));
  37.  
  38.     public void init(){
  39.         //通过结点的add方法，建立结点的父子关系
  40.  
  41.         root.add(salaryDb);
  42.         root.add(customerDb);
  43.  
  44.         salaryDb.add(employee);
  45.         salaryDb.add(attend);
  46.  
  47.         customerDb.add(concat);
  48.  
  49.         concat.add(id);
  50.         concat.add(name);
  51.         concat.add(gender);
  52.  
  53.         //创建树
  54.         tree = new JTree(root);
  55.  
  56.         //TODO 通过扩展DefaultTreeCellRenderer修改外观
  57.         tree.setCellRenderer(new MyRenderer());
  58.  
  59.  
  60.         jf.add(new JScrollPane(tree));
  61.         jf.pack();
  62.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  63.         jf.setVisible(true);
  64.  
  65.     }
  66.  
  67.  
  68.     //自定义类，继承DefaultTreeCellRenderer，完成结点的绘制
  69.     private class MyRenderer extends DefaultTreeCellRenderer {
  70.  
  71.         //重写方法
  72.  
  73.  
  74.         @Override
  75.         public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) {
  76.             //当前类间接的继承了JLabel这个组件类，展示一张图片和一些配套的文字
  77.             //Object value这个参数，代表的就是即将要绘制的结点
  78.  
  79.             //获取当前结点
  80.             DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
  81.  
  82.             //获取到当前即将绘制的结点的名称和图标
  83.             NodeData nodeData = (NodeData) node.getUserObject();
  84.  
  85.             //通过setText方法和setIcon方法完成设置
  86.             this.setText(nodeData.name);
  87.             this.setIcon(nodeData.icon);
  88.             return this;
  89.         }
  90.     }
  91.  
  92.     public static void main(String[] args) {
  93.         new ExtendsDefaultCellTreeRenderer().init();
  94.     }
  95.  
  96. }
  1. public class CustomerTreeNode {
  2.  
  3.     JFrame jf = new JFrame("定制树的结点");
  4.  
  5.     JTree tree;
  6.  
  7.     //定义几个初始结点
  8.  
  9.     DefaultMutableTreeNode friends = new DefaultMutableTreeNode("我的好友");
  10.     DefaultMutableTreeNode qingzhao = new DefaultMutableTreeNode("李清照");
  11.     DefaultMutableTreeNode suge = new DefaultMutableTreeNode("苏格拉底");
  12.     DefaultMutableTreeNode libai = new DefaultMutableTreeNode("李白");
  13.     DefaultMutableTreeNode nongyu = new DefaultMutableTreeNode("弄玉");
  14.     DefaultMutableTreeNode hutou = new DefaultMutableTreeNode("虎头");
  15.  
  16.     public void init() {
  17.         //组装视图
  18.         friends.add(qingzhao);
  19.         friends.add(suge);
  20.         friends.add(libai);
  21.         friends.add(nongyu);
  22.         friends.add(hutou);
  23.  
  24.         tree = new JTree(friends);
  25.  
  26.         //TODO 设置结点绘制器
  27.         MyRenderer renderer = new MyRenderer();
  28.         tree.setCellRenderer(renderer);
  29.  
  30.         jf.add(new JScrollPane(tree));
  31.         jf.pack();
  32.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  33.         jf.setVisible(true);
  34.  
  35.     }
  36.  
  37.     //自定义类，实现TreeCellRenderer接口，绘制组件
  38.     private class MyRenderer extends JPanel implements TreeCellRenderer {
  39.         private ImageIcon icon;
  40.         private String name;
  41.         private Color background;
  42.         private Color foreground;
  43.  
  44.         @Override
  45.         public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
  46.             //给成员变量设置值
  47.             this.icon = new ImageIcon("E:\\GUISwing\\img\\tree\\"+value.toString()+".gif");
  48.             this.name = value.toString();
  49.  
  50.             this.background = hasFocus? new Color(144,200,225) : new Color(255,255,255);
  51.             this.foreground = hasFocus? new Color(255,255,3) : new Color(0,0,0);
  52.  
  53.             return this;
  54.         }
  55.  
  56.         //通过重写getPreferenceSize方法，指定当前Jpanel组件的大小
  57.  
  58.         @Override
  59.         public Dimension getPreferredSize() {
  60.             return new Dimension(80,80);
  61.         }
  62.  
  63.         @Override
  64.         public void paint(Graphics g) {
  65.             //绘制组件内容
  66.  
  67.             int iconWidth = this.icon.getIconWidth();
  68.             int iconHeight = this.icon.getIconHeight();
  69.  
  70.             //填充背景
  71.             g.setColor(background);
  72.             g.fillRect(0,0,getWidth(),getHeight());
  73.  
  74.             //绘制头像
  75.             g.drawImage(this.icon.getImage(),getWidth()/2 - iconWidth/2,10,null);
  76.  
  77.             //绘制昵称
  78.             g.setColor(foreground);
  79.  
  80.             g.setFont(new Font("StSong",Font.BOLD,18));
  81.             g.drawString(this.name,getWidth()/2-this.name.length()*20/2,iconHeight+30);
  82.  
  83.         }
  84.     }
  85.  
  86.     public static void main(String[] args) {
  87.         new CustomerTreeNode().init();
  88.     }
  89. }

九、Swing控件修饰

1、控件边框

  1. public class BorderTest {
  2.  
  3.     JFrame jf  = new JFrame("测试边框");
  4.  
  5.     public void init(){
  6.         //组装视图
  7.         //1.JFrame的布局修改为GridLayout
  8.         jf.setLayout(new GridLayout(2,4));
  9.  
  10.         //2.往网格中填充不同的JPanel组件，并且设置边框和内容
  11.  
  12.         //创建BevelBorder
  13.         Border bevelBorder = BorderFactory.createBevelBorder(BevelBorder.RAISED, Color.RED, Color.GREEN, Color.BLUE, Color.GRAY);
  14.         jf.add(getJPanelWithBorder(bevelBorder,"BevelBorder"));
  15.  
  16.         //创建LineBorder
  17.         Border lineBorder = BorderFactory.createLineBorder(Color.ORANGE, 10);
  18.         jf.add(getJPanelWithBorder(lineBorder,"LineBorder"));
  19.  
  20.         //创建EmptyBorder
  21.         Border emptyBorder = BorderFactory.createEmptyBorder(10, 5, 20, 10);
  22.         jf.add(getJPanelWithBorder(emptyBorder,"EmptyBorder"));
  23.  
  24.         //创建EchtedBorder
  25.         Border etchedBorder = BorderFactory.createEtchedBorder(EtchedBorder.RAISED, Color.RED, Color.GREEN);
  26.         jf.add(getJPanelWithBorder(etchedBorder,"EtchedBorder"));
  27.  
  28.         //创建TitledBorder
  29.         TitledBorder titledBorder = new TitledBorder(new LineBorder(Color.ORANGE,10),"测试标题",TitledBorder.LEFT,TitledBorder.BOTTOM,new Font("StSong", Font.BOLD,18),Color.BLUE);
  30.         jf.add(getJPanelWithBorder(titledBorder,"TitledBorder"));
  31.  
  32.         //创建MatteBorder
  33.         MatteBorder matteBorder = new MatteBorder(10, 5, 20, 10, Color.GREEN);
  34.         jf.add(getJPanelWithBorder(matteBorder,"MatteBorder"));
  35.  
  36.         //创建CompoundBorder
  37.         CompoundBorder compoundBorder = new CompoundBorder( new LineBorder(Color.RED, 10),titledBorder);
  38.         jf.add(getJPanelWithBorder(compoundBorder,"CompoundBorder"));
  39.  
  40.         //3.设置窗口最佳大小、设置窗口可见，处理关闭操作
  41.         jf.pack();
  42.         jf.setVisible(true);
  43.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  44.  
  45.     }
  46.  
  47.     public JPanel getJPanelWithBorder(Border border,String content){
  48.         JPanel jPanel = new JPanel();
  49.         jPanel.add(new JLabel(content));
  50.  
  51.         //设置边框
  52.         jPanel.setBorder(border);
  53.  
  54.         return jPanel;
  55.     }
  56.  
  57.     public static void main(String[] args) {
  58.         new BorderTest().init();
  59.     }
  60. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/112056
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号