图形化操作——Swing(二）

JSplitPane

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

public class Book {
    
    

    private String name;

    private Icon icon;

    private String desc;

    public Book(String name, Icon icon, String desc) {
    
    
        this.name = name;
        this.icon = icon;
        this.desc = desc;
    }

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public Icon getIcon() {
    
    
        return icon;
    }

    public void setIcon(Icon icon) {
    
    
        this.icon = icon;
    }

    public String getDesc() {
    
    
        return desc;
    }

    public void setDesc(String desc) {
    
    
        this.desc = desc;
    }

    @Override
    public String toString() {
    
    
        return name;
    }
}

import cn.itcast.swing.util.ImagePathUtil;
import javax.swing.*;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import java.awt.*;

public class SplitPaneTest {
    
    

    Book[] books = {
    
    new Book("java自学宝典", new ImageIcon(ImagePathUtil.getRealPath("3\\java.png")), "国内关于 Java 编程最全面的图书 \n 看得懂 ， 学得会"),

            new Book("轻量级的JAVAEE企业应用实战", new ImageIcon(ImagePathUtil.getRealPath("3\\ee.png")), "SSM整合开发的经典图书，值的拥有"),

            new Book("Android基础教程", new ImageIcon(ImagePathUtil.getRealPath("3\\android.png")), "全面介绍Android平台应用程序\n 开发的各方面知识")

    };

    JFrame jf = new JFrame("测试JSplitPane");

    //列表展示图书
    JList<Book> bookList = new JList<>(books);
    JLabel bookCover = new JLabel();
    JTextArea bookDesc = new JTextArea();
    public void init(){
    
    

        //为三个组件设置最佳大小
        bookList.setPreferredSize(new Dimension(150,400));
        bookCover.setPreferredSize(new Dimension(220,330));
        bookDesc.setPreferredSize(new Dimension(220,70));

        //为列表添加事件监听器
        bookList.addListSelectionListener(new ListSelectionListener() {
    
    
            @Override
            public void valueChanged(ListSelectionEvent e) {
    
    
                Book book = bookList.getSelectedValue();
                bookCover.setIcon(book.getIcon());
                bookDesc.setText(book.getDesc());
            }
        });

        //创建一个垂直的分割面板
        JSplitPane left = new JSplitPane(JSplitPane.VERTICAL_SPLIT,bookCover,new JScrollPane(bookDesc));

        //打开"一触即展"特性
        left.setOneTouchExpandable(true);
        //设置分隔条的大小
        left.setDividerSize(10);
        //设置分割面板根据组件的大小调整最佳布局
        left.resetToPreferredSizes();

        //创建一个水平分隔面板
        JSplitPane content = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, left, bookList);
        //设置支持连续布局
        content.setContinuousLayout(true);

        jf.add(content);

        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.pack();
        jf.setVisible(true);


    }

    public static void main(String[] args) {
    
    
        new SplitPaneTest().init();
    }

}

JTablePane

可以很方便地在窗口上放置多个标签页，每个标签页相当于获得了一个与外部容器具有相同大小的组件摆放区域。通过这种方式， 就可以在一个容器里放置更多的组件.

import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class JTabbedPaneTest {
    
    
    JFrame jf = new JFrame("测试JTabbedPane");
    JTabbedPane tabbedPane = new JTabbedPane(SwingConstants.TOP,JTabbedPane.WRAP_TAB_LAYOUT);

    public void init(){
    
    

        //设置jf大小
        jf.setBounds(400,400,400,400);
        //设置jf大小不能变化
        jf.setResizable(false);

        ImageIcon icon = new ImageIcon(ImagePathUtil.getRealPath("3\\open.gif"));
        //添加标签
        tabbedPane.addTab("用户管理",icon,new JList<String>(new String[]{
    
    "用户一","用户二","用户三"}));
        tabbedPane.addTab("商品管理",new JList<String>(new String[]{
    
    "商品一","商品二","商品三"}));
        tabbedPane.addTab("订单管理",icon,new JList<String>(new String[]{
    
    "订单一","订单二","订单三"}));

        //设置第二个标签默认选中
        tabbedPane.setSelectedIndex(1);
        //设置第一个标签不能用
        tabbedPane.setEnabledAt(0,false);

        tabbedPane.addChangeListener(new ChangeListener() {
    
    
            @Override
            public void stateChanged(ChangeEvent e) {
    
    
                int selectedIndex = tabbedPane.getSelectedIndex();
                JOptionPane.showMessageDialog(jf,"选中了第"+(selectedIndex+1)+"个标签");
            }
        });


        jf.add(tabbedPane);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.setVisible(true);

    }


    public static void main(String[] args) {
    
    
        new JTabbedPaneTest().init();
    }
}

JLayeredPane、JDesktopPane、JInternalFrame

JLayeredPane是一个代表有层次深度的容器 ， 它允许组件在需要时互相重叠。当向JLayeredPane容器中添加组件时， 需要为该组件指定一个深度索引 ， 其中层次索引较高的层里的组件位于其他层的组件之上。
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中添加组件，如果要显示，则必须手动设置该组件在容器中显示的位置以及大小。

import cn.itcast.swing.util.ImagePathUtil;

import javax.swing.*;
import java.awt.*;

public class JLayeredPaneTest {
    
    
    JFrame jf = new JFrame("测试JLayeredPane");
    JLayeredPane layeredPane = new JLayeredPane();

    //自定义组件，继承JPanel
    private class ContentPanel extends JPanel{
    
    

        public ContentPanel(int xPos,int yPos,String title,String ico){
    
    
            //设置边框
            setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(),title));
            JLabel label = new JLabel(new ImageIcon(ImagePathUtil.getRealPath("3\\"+ico)));
            add(label);
            setBounds(xPos,yPos,160,220);

        }

    }

    public void init(){
    
    
        //向LayeredPane中添加三个组件，往JLayeredPane中添加组件，都必须手动的设置组件显示的位置和大小，才能显示出来

        layeredPane.add(new ContentPanel(10,20,"java自学宝典","java.png"),JLayeredPane.MODAL_LAYER);
        layeredPane.add(new ContentPanel(100,60,"Android基础教程","android.png"),JLayeredPane.DEFAULT_LAYER);
        layeredPane.add(new ContentPanel(80,100,"轻量级javaEE企业应用","ee.png"),JLayeredPane.DRAG_LAYER);

        layeredPane.setPreferredSize(new Dimension(300,400));


        jf.add(layeredPane);
        jf.pack();
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.setVisible(true);


    }

    public static void main(String[] args) {
    
    
        new JLayeredPaneTest().init();
    }
}

JDesktopPane是JLayeredPane的子类，这种容器在开发中会更常用很多应用程序都需要启动多个内部窗口来显示信息（典型的比如IDEA、NotePad++），这些内部窗口都属于同一个外部窗口，当外部窗口最小化时， 这些内部窗口都被隐藏起来。在 Windows 环境中，这种用户界面被称为多文档界面 C Multiple Document Interface, MDI) 。

使用 Swing 可以非常简单地创建出这种 MDI 界面 ， 内部窗口有自己的标题栏、标题、图标、三个窗口按钮，并允许拖动改变内部窗口 的大小和位置，但内部窗口不能拖出外部窗口。JDesktopPane 需要和 JIntemalFrame 结合使用，其中JDesktopPane 代表一 个虚拟桌面 ，而JIntemalFrame则用于创建内部窗口。

import cn.itcast.swing.util.ImagePathUtil;

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

public class JInternalFrameTest {
    
    
    final int DESKTOP_WIDTH = 480;
    final int DESKTOP_HEIGHT = 360;
    final int FRAME_DISTANCE = 20;

    //创建外部窗口
    JFrame jf = new JFrame("测试JInternalFrame");

    //创建虚拟桌面
    JDesktopPane desktop = new JDesktopPane();

    //定义内部窗口为的大小
    private int width = 230;
    private int height = DESKTOP_HEIGHT;

    //定义下一个内部窗口的横轴坐标
    private int nextFrameX = 0;

    //为外部窗口定义两个菜单
    JMenu fileMenu = new JMenu("文件");


    //定义Action，用于快捷创建菜单项和工具按钮
    Action newAction = new AbstractAction("新建",new ImageIcon(ImagePathUtil.getRealPath("3\\new.png"))) {
    
    
        @Override
        public void actionPerformed(ActionEvent e) {
    
    
            //创建内部窗口
            JInternalFrame iframe = new JInternalFrame("新文档",true,true,true,true);
            //往内部窗口中添加一个8行40列的文本框
            iframe.add(new JScrollPane(new JTextArea(8,40)));
            //将内部窗口添加到虚拟桌面中
            desktop.add(iframe);
            //设置内部窗口的原始位置
            iframe.reshape(nextFrameX,0,width,height);
            //使该窗口可见
            iframe.show();

            //计算下一个内部窗口的位置
            nextFrameX+=FRAME_DISTANCE;


            if (nextFrameX>DESKTOP_WIDTH-width){
    
    
                nextFrameX=0;
            }
        }
    };

    Action exitAction = new AbstractAction("退出",new ImageIcon(ImagePathUtil.getRealPath("3\\exit.png"))) {
    
    
        @Override
        public void actionPerformed(ActionEvent e) {
    
    
            //结束当前程序
            System.exit(0);
        }
    };


    public void init(){
    
    

        //为窗口安装菜单条
        JMenuBar menuBar = new JMenuBar();

        jf.setJMenuBar(menuBar);
        menuBar.add(fileMenu);
        fileMenu.add(newAction);
        fileMenu.add(exitAction);



        //设置虚拟桌面的最佳大小
        desktop.setPreferredSize(new Dimension(DESKTOP_WIDTH,DESKTOP_HEIGHT));

        //将虚拟桌面添加到外部窗口中
        jf.add(desktop);

        jf.pack();
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.setVisible(true);

    }


    public static void main(String[] args) {
    
    
        new JInternalFrameTest().init();
    }

}

JProcessBar、ProcessMonitor、BoundedRangeModel实现进度条

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

扫描二维码关注公众号，回复： 14315587 查看本文章

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

public class JProgressTest {
    
    

    JFrame jf = new JFrame("测试进度条");
    //创建一个垂直进度条
    JProgressBar bar = new JProgressBar(JProgressBar.HORIZONTAL);

    JCheckBox indeterminate = new JCheckBox("不确定进度");
    JCheckBox noBorder = new JCheckBox("不绘制边框");

    public void init(){
    
    

        Box box = new Box(BoxLayout.Y_AXIS);
        box.add(indeterminate);
        box.add(noBorder);

        jf.setLayout(new FlowLayout());
        jf.add(box);

        //把进度条添加到jf窗口中
        jf.add(bar);

        //设置进度条的最大值和最小值
        bar.setMinimum(0);
        bar.setMaximum(100);

        //设置进度条中绘制完成百分比
        bar.setStringPainted(true);

        //根据选择决定是否绘制进度条边框
        noBorder.addActionListener(new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                boolean flag = noBorder.isSelected();
                bar.setBorderPainted(!flag);
            }
        });

        //根据选择决定是否是不确定进度条
        indeterminate.addActionListener(new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                boolean flag = indeterminate.isSelected();
                bar.setIndeterminate(flag);
                //不绘制百分比，因为之前设置了绘制百分比
                bar.setStringPainted(!flag);
            }
        });

        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.pack();
        jf.setVisible(true);


        //通过循环不断改变进度条的完成进度
        for (int i = 0; i <= 100; i++) {
    
    
            //改变进度条的完成进度
            bar.setValue(i);

            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }

    }

    public static void main(String[] args) {
    
    
        new JProgressTest().init();
    }
}

通过for循环来不断的更新进度条的进度，不断的检测一个耗时任务的完成情况，然后才去更新进度条的进度。下面的代码通过Timer定时器和Runnable接口。

import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class JProgressTest2 {
    
    

    JFrame jf = new JFrame("测试进度条");
    //创建一个垂直进度条
    JProgressBar bar = new JProgressBar(JProgressBar.HORIZONTAL);

    JCheckBox indeterminate = new JCheckBox("不确定进度");
    JCheckBox noBorder = new JCheckBox("不绘制边框");

    public void init(){
    
    

        Box box = new Box(BoxLayout.Y_AXIS);
        box.add(indeterminate);
        box.add(noBorder);

        jf.setLayout(new FlowLayout());
        jf.add(box);

        //把进度条添加到jf窗口中
        jf.add(bar);

        //开启耗时任务
        SimulatedActivity simulatedActivity = new SimulatedActivity(100);
        new Thread(simulatedActivity).start();


        //设置进度条的最大值和最小值
        bar.setMinimum(0);
        bar.setMaximum(simulatedActivity.getAmount());

        //设置进度条中绘制完成百分比
        bar.setStringPainted(true);

        //根据选择决定是否绘制进度条边框
        noBorder.addActionListener(new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                boolean flag = noBorder.isSelected();
                bar.setBorderPainted(!flag);
            }
        });

        //根据选择决定是否是不确定进度条
        indeterminate.addActionListener(new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                boolean flag = indeterminate.isSelected();
                bar.setIndeterminate(flag);
                //不绘制百分比，因为之前设置了绘制百分比
                bar.setStringPainted(!flag);
            }
        });

        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.pack();
        jf.setVisible(true);




        //通过定时器，不断的读取simulatedActivity中的current值，更新进度条的进度
        Timer timer = new Timer(300, new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                bar.setValue(simulatedActivity.getCurrent());
            }
        });
        timer.start();
        //监听进度条的变化，如果进度完成为100%，那么停止定时器
        bar.addChangeListener(new ChangeListener() {
    
    
            @Override
            public void stateChanged(ChangeEvent e) {
    
    
                if (   bar.getValue()==bar.getMaximum()){
    
    
                    timer.stop();
                }
            }
        });


    }

    public static void main(String[] args) {
    
    
        new JProgressTest2().init();
    }

    //定义一个线程任务，模拟耗时操作
    private class SimulatedActivity implements Runnable{
    
    
        //内存可见
        private volatile int current = 0;
        private int amount;

        public SimulatedActivity(int amount) {
    
    
            this.amount = amount;
        }

        public int getCurrent() {
    
    
            return current;
        }

        public void setCurrent(int current) {
    
    
            this.current = current;
        }


        public int getAmount() {
    
    
            return amount;
        }

        public void setAmount(int amount) {
    
    
            this.amount = amount;
        }

        @Override
        public void run() {
    
    
            //通过循环，不断的修改current的值，模拟任务完成量
            while(current<amount){
    
    
                try {
    
    
                    Thread.sleep(50);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                current++;
            }
        }
    }
}

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

下面的代码是对之前代码的改进，通过BoundedRangeModel完成数据的设置，获取与监听。

import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class JProgressTest3 {
    
    

    JFrame jf = new JFrame("测试进度条");
    //创建一个垂直进度条
    JProgressBar bar = new JProgressBar(JProgressBar.HORIZONTAL);
    JCheckBox indeterminate = new JCheckBox("不确定进度");
    JCheckBox noBorder = new JCheckBox("不绘制边框");

    public void init(){
    
    

        Box box = new Box(BoxLayout.Y_AXIS);
        box.add(indeterminate);
        box.add(noBorder);

        jf.setLayout(new FlowLayout());
        jf.add(box);

        //把进度条添加到jf窗口中
        jf.add(bar);

        //开启耗时任务
        SimulatedActivity simulatedActivity = new SimulatedActivity(100);
        new Thread(simulatedActivity).start();


        //设置进度条的最大值和最小值
        bar.getModel().setMinimum(0);
        bar.getModel().setMaximum(simulatedActivity.getAmount());

        //设置进度条中绘制完成百分比
        bar.setStringPainted(true);

        //根据选择决定是否绘制进度条边框
        noBorder.addActionListener(new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                boolean flag = noBorder.isSelected();
                bar.setBorderPainted(!flag);
            }
        });

        //根据选择决定是否是不确定进度条
        indeterminate.addActionListener(new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                boolean flag = indeterminate.isSelected();
                bar.setIndeterminate(flag);
                //不绘制百分比，因为之前设置了绘制百分比
                bar.setStringPainted(!flag);
            }
        });

        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.pack();
        jf.setVisible(true);

        //通过定时器，不断的读取simulatedActivity中的current值，更新进度条的进度
        Timer timer = new Timer(300, new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                bar.getModel().setValue(simulatedActivity.getCurrent());
            }
        });
        timer.start();
        //监听进度条的变化，如果进度完成为100%，那么停止定时器
        bar.getModel().addChangeListener(new ChangeListener() {
    
    
            @Override
            public void stateChanged(ChangeEvent e) {
    
    
                if (   bar.getModel().getValue()==bar.getModel().getMaximum()){
    
    
                    timer.stop();
                }
            }
        });


    }

    public static void main(String[] args) {
    
    
        new JProgressTest3().init();
    }

    //定义一个线程任务，模拟耗时操作
    private class SimulatedActivity implements Runnable{
    
    
        //内存可见
        private volatile int current = 0;
        private int amount;

        public SimulatedActivity(int amount) {
    
    
            this.amount = amount;
        }

        public int getCurrent() {
    
    
            return current;
        }

        public void setCurrent(int current) {
    
    
            this.current = current;
        }


        public int getAmount() {
    
    
            return amount;
        }

        public void setAmount(int amount) {
    
    
            this.amount = amount;
        }

        @Override
        public void run() {
    
    
            //通过循环，不断的修改current的值，模拟任务完成量
            while(current<amount){
    
    
                try {
    
    
                    Thread.sleep(50);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                current++;
            }
        }
    }
}

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

public class ProgressMonitorTest {
    
    

    Timer timer;
    public void init(){
    
    
        final SimulatedActivity simulatedActivity = new SimulatedActivity(100);
        final Thread targetThread= new Thread(simulatedActivity);
        targetThread.start();


        ProgressMonitor dialog = new ProgressMonitor(null, "等待任务完成", "已完成：", 0, simulatedActivity.getAmount());

        timer = new Timer(300, new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                dialog.setProgress(simulatedActivity.getCurrent());
                if (dialog.isCanceled()){
    
    
                    timer.stop();
                    targetThread.interrupt();
                    System.exit(0);
                }
            }
        });
        timer.start();


        System.out.println("aaa");
    }

    public static void main(String[] args) {
    
    
        new ProgressMonitorTest().init();
    }

    //定义一个线程任务，模拟耗时操作
    private class SimulatedActivity implements Runnable{
    
    
        //内存可见
        private volatile int current = 0;
        private int amount;

        public SimulatedActivity(int amount) {
    
    
            this.amount = amount;
        }

        public int getCurrent() {
    
    
            return current;
        }

        public void setCurrent(int current) {
    
    
            this.current = current;
        }


        public int getAmount() {
    
    
            return amount;
        }

        public void setAmount(int amount) {
    
    
            this.amount = amount;
        }

        @Override
        public void run() {
    
    
            //通过循环，不断的修改current的值，模拟任务完成量
            while(current<amount){
    
    
                try {
    
    
                    Thread.sleep(50);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                current++;
            }
        }
    }

}

JList JComboBox实现列表框

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

简单列表框

(1)创建JList或者JComboBox对象

JList(final E[] listData):创建JList对象，把listData数组中的每项内容转换成一个列表项展示
JList(final Vector<? extends E> listData):创建JList对象，把listData数组中的每项内容转换成一个列表项展示
JComboBox(E[] items):
JComboBox(Vector<E> items):

（2）设置JList或者JComboBox外观行为

addSelectionInterval(int anchor, int lead):在已经选中列表项的基础上，增加选中从anchor到lead索引范围内的所有列表项
setFixedCellHeight(int height)/setFixedCellWidth(int width):设置列表项的高度和宽度
setLayoutOrientation(int layoutOrientation)：设置列表框的布局方向
setSelectedIndex(int index)：设置默认选中项
setSelectedIndices(int[] indices)：设置默认选中的多个列表项
setSelectedValue(Object anObject,boolean shouldScroll)：设置默认选中项，并滚动到该项显示
setSelectionBackground(Color selectionBackground)：设置选中项的背景颜色
setSelectionForeground(Color selectionForeground)：设置选中项的前景色
setSelectionInterval(int anchor, int lead):设置从anchor到lead范围内的所有列表项被选中
setSelectionMode(int selectionMode)：设置选中模式，默认没有限制，也可以设置为单选或者区域选中
setVisibleRowCount(int visibleRowCount)：设置列表框的可是高度足以显示多少行列表项
---------------------------JComboBox---------------------------------------------- 
setEditable(boolean aFlag)：设置是否可以直接修改列表文本框的值，默认为不可以
setMaximumRowCount(int count)：设置列表框的可是高度足以显示多少行列表项
setSelectedIndex(int anIndex)：设置默认选中项
setSelectedItem(Object anObject)：根据列表项的值，设置默认选中项

（3）设置监听器，监听列表项的变化，JList通过addListSelectionListener完成，JComboBox通过addItemListener完成。