首页 > java > Swing > > 正文

Java Swing控件属性归纳_及示例

发布人:zhoulujun@live.cn    点击:

了解各种用户界面组件:JButton、JLabel、JTextField、JTextArea、JComboBox、 Jlist、JCheckBox、JRadioButton、JMenuBar、JMenu、JMen

了解各种用户界面组件:

JButton、JLabel、JTextField、JTextArea、JComboBox、    Jlist、JCheckBox、JRadioButton、JMenuBar、JMenu、JMenuItem、JCheckBoxMenuItem、JRadioButtonMenuItem、JScrollBar、JScrollPane、JTabbedPane等

一、JButton

¨         按钮是一种点击时触发行为事件的组件。

¨      按钮的四个构造方法:

"          public Jbutton()

                               创建一个空按钮

"          public    JButton(String text)

                               创建一个标有指定文字的按钮

"          public    JButton(Icon icon)

                               创建一个标有指定图标的按钮

"          public    JButton(String text,Icon icon)

                               创建一个标有指定文字和图标的按钮

¨         图标:是一个固定大小的图片,典型的图标体形较小,用于装饰组件。利用类ImageIcon可以从图像文件中得到图标,如:Icon icon=new ImageIcon(“photo.gif”);

JButton 的属性

¨      text:按钮上的标签,例如可用jbt.setText(“OK”)给按钮jbt设置标签。

¨      icon:按钮上的图标,例如可用jbt.setTextIcon(new    ImageIcon(“a.gif”))。

¨         mnemonic:指定热键。同时按下ALT键和指定热键相当于按下该按钮。例如使用jbt.setMnemonic(‘O’)可将O设置为按钮jbt的热键。

¨         horizontalAlignment:此属性只有三个值SwingConstants.LEFT,SwingConstants.CENTER,    SwingConstants.RIGHT。它指定按钮上标签的水平对齐方式。默认值为居中。

¨         verticalAlignment:此属性也取三个值SwingConstants.TOP,    SwingConstants.CENTER和SwingConstants.BOTTOM。它指定按钮上标签的垂直对齐方式。默认值为居中。

¨         horizontalTextPosition:此属性有三个值SwingConstants.LEFT, SwingConstants.CENTER,    SwingConstants.RIGHT。它指定文本相对于图标的水平位置,默认为SwingConstants.RIGHT。对应方法setHorizontalTextPosition。

¨      verticalTextPosition:此属性有三个值SwingConstants.TOP,    SwingConstants.CENTER,    SwingConstants.BOTTOM。它指定文字相对图标的垂直位置,默认值为SwingConstants.CENTER。对应方法setVerticalTextPosition。

 

二、JLabel

¨      标签是显示一小段文字、一幅图片或者二者皆有的区域。

¨      它的六个构造方法如下:

"             public JLabel()       

                                  创建一个空标签。

"          public    JLabel(String text,int horizontalAlignment)

                           创建一个指定内容字符串和水平对齐方式的标签。其中水平对齐方式可取值SwingConstants.LEFT, SwingConstants.CENTER, SwingConstants.RIGHT。

"          public JLabel(String    text)

                               创建一个指定文字的标签。

"          public    JLabel(Icon icon)

                               创建一个指定图标的标签。

"          public    JLabel(Icon icon,int horizontalAlignment)

                                  创建一个指定图标和水平对齐方式的标签。

"             public JLabel(String text,Icon icon,int horizontalAlignment)

                                  创建一个指定文本、图标和水平对齐方式的标签。

¨      例如,下面语句创建一个文本内容为“Interest    Rate”的标签:

JLabel myLabel = new JLabel(“Interest Rate”);

下面的语句创建一个标签,它使用文件“images/map.gif”中的图像作图标:

JLabel    mapLabel = new JLabel(new ImageIcon(“images/map.gif”);

JLabel 的属性

¨      JLabel继承了类Jcomponent的所有属性,并具有JButton类的许多属性,如:

"        text

"        icon

"        horizontalAlignment

"        verticalAlignment

 

三、JTextField

¨      文本域是一个用户可以输入字符的输入区。允许用户输入各种数据,如姓名和描述文字。

¨      JTextField的四个构造方法:

"          public JTextField()

                               创建一个空文本域。

"          public    JTextField(int columns)

                               创建一个指定列数的空文本域。

"          public    JTextField(String text)

                               用指定初始文字创建一个文本域。

"          public    JTextField(String text,int columns)

                               创建一个文本域,并用指定文字和列数初始化。

JTextField 属性

¨         除了text、horizontalAlignment等属性外,JTextField还有如下属性:

"           editable

                               布尔型属性,表明用户能否修改文本域。

"        columns

                               文本域的宽度。

JTextField 方法

¨      getText()

                 从文本域返回字符串。

¨         setText(String text)

                 将给定字符串写入文本域当中

¨      setEditable(boolean editable)

                 使文本域变为可编辑的,默认为true。

¨      setColumns(int)

                 设置文本与的列数,文本域的长度可变。

 

四、JTextArea

¨         如想让用户输入多行文本,只能通过创建多个JTextField实例来实现,解决问题的更好办法是使用JTextField,它允许用户输入多行文字。

¨         JTextArea的三个构造方法:

"          public    JTextArea()

                               创建一个空的文本区。

"        JTextArea(int rows, int    columns)

                               创建一个指定行数和列数的文本区。

"        JTextArea(String s,    int rows, int columns)

                               创建一个指定文本、行数和列数的文本区。

JTextArea 属性

¨      除了text、editable、columns外,JTextArea还有以下属性:

"        lineWrap

"        wrapStyleWord

"        rows

"        lineCount

"        tabSize

JTextArea 的方法

¨      以下方法用于插入、追加和替换文本:

"          public void inser(String    s,int pos)

                               将字符串s插入到文本区的指定位置pos。

"             public void append(String s)

                               将字符串s添加到文本的末尾。

"          public    void replaceRange(String s,int start,int end)

                                  用字符串s替换文本中从位置start到end的文字。

 

五、JComboBox

¨      组和框是一些项目的简单列表,用户能够从中进行选择。

¨      JComboBox的两个构造方法:

"        public JComboBox()

                               默认构造方法。

"          public    JComboBox(Object[] stringItems)

                               带有字符串列表的构造方法,其中stringItems是一个字符串数祖。

JComboBox的属性

¨         JComboBox的有用的属性:

"             selectedIndex

                               int值,表示组合框中选定项的序号。

"             selectedItem

                               Object类型,表示选定项。

 

JComboBox 的方法

¨         有用的方法:

"          public void    addItem(Object item)

                               在组和框中添加一个选项,它可以是任何对象。

"             public Object getItemAt(int index)

                               得到组合框中指定序号的项。

"          public void    removeItem(Object anObject)

                               删除指定的项。

"          public void    removeAllItems()

                               删除列表中所有项。

 

六、JList

¨      列表框的作用和组合框的作用基本相同,但它允许用户同时选择多项。

¨      JList的两个构造方法:

"           JList()

       创建一个空的列表框

"        JList(Object[] stringItems)

       创建一个有初始项的列表框

¨         JList不会自动滚动。给列表框加滚动条的方法与文本区相同,只需创建一个滚动窗格并将列表框加入其中即可。

Jlist的 属性

¨         selectedIndexd

¨      selectedIndices

¨      selectedValue

¨         selectedValues

¨      selectionMode

¨      visibleRowCount

 

 

七、JCheckBox

¨      复选框是一种用户能够打开、关闭选项的组件,如同电灯开关一般。

¨      JCheckBox的七个构造方法:

"        JCheckBox()

"        JCheckBox(String text)

"        JCheckBox(String text, boolean    selected)

"        JCheckBox(Icon icon)

"        JCheckBox(Icon icon, boolean    selected)

"        JCheckBox(String text, Icon    icon)

"        JCheckBox(String text, Icon    icon, boolean selected)

JCheckBox 的属性

¨      JCheckBox    除了具有JButton的所有属性如text、icon、mnemonic、verticalAlignment、horizontalAlignment、horizontalTextPosition和verticalTextPosition    外,还有selected属性,该属性指明复选框是否被选中。

 

 

八、JRadioButton

¨         单选按钮,或叫选择按钮,让用户从一组组件中选择唯一的一个选项。

¨         JRadioButton的七个构造方法:

"           JRadioButton()

"        JRadioButton(String    text)

"        JRadioButton(String text,    boolean selected)

"        JRadioButton(Icon    icon)

"        JRadioButton(Icon icon, boolean    selected)

"        JRadioButton(String text,    Icon icon)

"        JRadioButton(String text,    Icon icon, boolean selected)

JRadioButton 的属性

¨         JRadioButton 除具有JButton的所有属性如text、icon、mnemonic、verticalAlignment、    horizontalAlignment、horizontalTextPosition、verticalTextPosition外,还具有 selected属性,该属性指明单选按钮是否被选中。

将单选钮组合成组

¨         单选按钮可以象按钮一样添加到容器中。要将单选按钮分组,需要创建java.swing.ButtonGroup的一个实例,并用add方法把单选按钮添加到该实例中,如:

ButtonGroup btg = new ButtonGroup();

btg.add(jrb1);

btg.add(jrb2);

上述代码创建了一个单选按钮组,这样就不能同时选择jrb1和jrb2。

 

九、消息对话框

¨         对话框通常用作临时窗口,用来接受用户的附加信息或提示用户发生了某事件。

¨         消息对话框是一种简单却频繁使用的对话框,用来显示消息提醒用户。

¨         消息对话框是模式的,即消息对话框消失前其他窗口均不可用。

创建消息对话框

¨      使用 JOptionPane类中的静态方法:

"          showMessageDialog(Component    parentComponent, Object message, String title, int messageType)

                    parentComponet是对话框的父组件,对话框都是由它派生而来的。message是要显示的对象,它通常是一个字符串。title是对话框的标题。messageType决定了所显示消息的类型。

"        showMessageDialog(Component    parentComponent, Object message, String title, int messageType, Icon icon)

                 除PLAIN_MESSAGE外,每种消息都有相应的图标,以上方法可支持自制图标。



下面是参考代码

public class SwingComponent
{
    JFrame f = new JFrame("测试");
    //定义一个按钮,并为之指定图标  
    Icon okIcon = new ImageIcon("ico/ok.png");
    JButton ok = new JButton("确认" , okIcon);
    //定义一个单选按钮,初始处于选中状态  
    JRadioButton male = new JRadioButton("男" , true);
    //定义一个单按钮,初始处于没有选中状态  
    JRadioButton female = new JRadioButton("女" , false);
    //定义一个ButtonGroup,用于将上面两个JRadioButton组合在一起  
    ButtonGroup bg = new ButtonGroup();
    //定义一个复选框,初始处于没有选中状态  。  
    JCheckBox married = new JCheckBox("是否已婚?" , false);
    String[] colors = new String[]{"红色" , "绿色"  , "蓝色"};
    //定义一个下拉选择框  
    JComboBox colorChooser = new JComboBox(colors);
    //定义一个列表选择框  
    JList colorList = new JList(colors);
    //定义一个8行、20列的多行文本域  
    JTextArea ta = new JTextArea(8, 20);
    //定义一个40列的单行文本域  
    JTextField name = new JTextField(40);
    JMenuBar mb = new JMenuBar();
    JMenu file = new JMenu("文件");
    JMenu edit = new JMenu("编辑");
    //创建“新建”菜单项,并为之指定图标  
    Icon newIcon = new ImageIcon("ico/new.png");
    JMenuItem newItem = new JMenuItem("新建" , newIcon);
    //创建“保存”菜单项,并为之指定图标  
    Icon saveIcon = new ImageIcon("ico/save.png");
    JMenuItem saveItem = new JMenuItem("保存" , saveIcon);
    //创建“退出”菜单项,并为之指定图标  
    Icon exitIcon = new ImageIcon("ico/exit.png");
    JMenuItem exitItem = new JMenuItem("退出" , exitIcon);
    JCheckBoxMenuItem autoWrap = new JCheckBoxMenuItem("自动换行");
    //创建“复制”菜单项,并为之指定图标  
    JMenuItem copyItem = new JMenuItem("复制" , new ImageIcon("ico/copy.png"));
    //创建“粘贴”菜单项,并为之指定图标  
    JMenuItem pasteItem = new JMenuItem("粘贴" , new ImageIcon("ico/paste.png"));
    JMenu format = new JMenu("格式");
    JMenuItem commentItem = new JMenuItem("注释");
    JMenuItem cancelItem = new JMenuItem("取消注释");

    //定义一个右键菜单用于设置程序风格  
    JPopupMenu pop = new JPopupMenu();
    //用于组合三个风格菜单项的ButtonGroup  
    ButtonGroup flavorGroup = new ButtonGroup();
    //创建三个单选框按钮,用于设定程序的外观风格  
    JRadioButtonMenuItem metalItem = new JRadioButtonMenuItem("Metal风格" , true);
    JRadioButtonMenuItem windowsItem = new JRadioButtonMenuItem("Windows风格");
    JRadioButtonMenuItem motifItem = new JRadioButtonMenuItem("Motif风格");

    public void init()
    {
        //创建一个装载了文本框、按钮的JPanel  
        JPanel bottom = new JPanel();
        bottom.add(name);
        bottom.add(ok);
        f.add(bottom , BorderLayout.SOUTH);
        //创建一个装载了下拉选择框、三个JCheckBox的JPanel  
        JPanel checkPanel = new JPanel();
        checkPanel.add(colorChooser);
        bg.add(male);
        bg.add(female);
        checkPanel.add(male);
        checkPanel.add(female);
        checkPanel.add(married);
        //创建一个垂直排列组件的Box,盛装多行文本域JPanel  
        Box topLeft = Box.createVerticalBox();
        //使用JScrollPane作为普通组件的JViewPort  
        JScrollPane taJsp = new JScrollPane(ta);
        topLeft.add(taJsp);
        topLeft.add(checkPanel);
        //创建一个垂直排列组件的Box,盛装topLeft、colorList  
        Box top = Box.createHorizontalBox();
        top.add(topLeft);
        top.add(colorList);
        //将top Box容器添加到窗口的中间  
        f.add(top);
        //-----------下面开始组合菜单、并为菜单添加事件监听器----------  
        //为newItem设置快捷键,设置快捷键时要使用大写字母  
        newItem.setAccelerator(KeyStroke.getKeyStroke(N , InputEvent.CTRL_MASK));
        newItem.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                ta.append("用户单击了“新建”菜单/n");
            }
        });
        //为file菜单添加菜单项  
        file.add(newItem);
        file.add(saveItem);
        file.add(exitItem);
        //为edit菜单添加菜单项  
        edit.add(autoWrap);
        //使用addSeparator方法来添加菜单分隔线  
        edit.addSeparator();
        edit.add(copyItem);
        edit.add(pasteItem);
        commentItem.setToolTipText("将程序代码注释起来!");
        //为format菜单添加菜单项  
        format.add(commentItem);
        format.add(cancelItem);
        //使用添加new JMenuItem("-")的方式不能添加菜单分隔符  
        edit.add(new JMenuItem("-"));
        //将format菜单组合到edit菜单中,从而形成二级菜单  
        edit.add(format);
        //将file、edit菜单添加到mb菜单条中  
        mb.add(file);
        mb.add(edit);
        //为f窗口设置菜单条  
        f.setJMenuBar(mb);
        //-----------下面开始组合右键菜单、并安装右键菜单----------  
        flavorGroup.add(metalItem);
        flavorGroup.add(windowsItem);
        flavorGroup.add(motifItem);
        pop.add(metalItem);
        pop.add(windowsItem);
        pop.add(motifItem);
        //为三个菜单创建事件监听器  
        ActionListener flavorListener = new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                try
                {
                    if (e.getActionCommand().equals("Metal风格"))
                    {
                        changeFlavor(1);
                    }
                    else if (e.getActionCommand().equals("Windows风格"))
                    {
                        changeFlavor(2);
                    }
                    else if (e.getActionCommand().equals("Motif风格"))
                    {
                        changeFlavor(3);
                    }
                }
                catch (Exception ee)
                {
                    ee.printStackTrace();
                }
            }
        };
        //为三个菜单添加事件监听器  
        metalItem.addActionListener(flavorListener);
        windowsItem.addActionListener(flavorListener);
        motifItem.addActionListener(flavorListener);
        //调用该方法即可设置右键菜单,无需使用事件机制  
        ta.setComponentPopupMenu(pop);
        //设置关闭窗口时,退出程序  
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.pack();
        f.setVisible(true);
    }

    //定义一个方法,用于改变界面风格  
    private void changeFlavor(int flavor)throws Exception
    {
        switch (flavor)
        {
            //设置Metal风格  
            case 1:
                UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
                break;
            //设置Windows风格  
            case 2:
                UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
                break;
            //设置Motif风格  
            case 3:
                UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");
                break;
        }
        //更新f窗口内顶级容器以及内部所有组件的UI  
        SwingUtilities.updateComponentTreeUI(f.getContentPane());
        //更新mb菜单条以及内部所有组件的UI  
        SwingUtilities.updateComponentTreeUI(mb);
        //更新pop右键菜单以及内部所有组件的UI  
        SwingUtilities.updateComponentTreeUI(pop);

    }
    public static void main(String[] args)
    {
        //设置Swing窗口使用Java风格  
        JFrame.setDefaultLookAndFeelDecorated(true);
        new SwingComponent().init();
    }
}


 下面Swing的特殊组件,我将以举例的形式,这样最能主观理解,大家一定要动手试试

public class TestJToolBar
{
    JFrame jf = new JFrame("测试工具条");
    JTextArea jta = new JTextArea(6, 35);
    JToolBar jtb = new JToolBar();
    JMenuBar jmb = new JMenuBar();
    JMenu edit = new JMenu("编辑");
    Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
    //创建"粘贴"Action,该Action用于创建菜单项、工具按钮和普通按钮  
    Action pasteAction = new AbstractAction("粘贴", new ImageIcon("ico/paste.png"))
    {
        public void actionPerformed(ActionEvent e)
        {
            //如果剪贴板中包含stringFlavor内容  
            if (clipboard.isDataFlavorAvailable(DataFlavor.stringFlavor))
            {
                try
                {
                    //取出剪贴板中stringFlavor内容  
                    String content = (String)clipboard.getData(DataFlavor.stringFlavor);
                    //将选中内容替换成剪贴板中的内容  
                    jta.replaceRange(content , jta.getSelectionStart() , jta.getSelectionEnd());
                }
                catch (Exception ee)
                {
                    ee.printStackTrace();
                }
            }
        }
    };
    //创建"复制"Action  
    Action copyAction = new AbstractAction("复制", new ImageIcon("ico/copy.png"))
    {
        public void actionPerformed(ActionEvent e)
        {
            StringSelection contents = new StringSelection(jta.getSelectedText());
            //将StringSelection对象放入剪贴板  
            clipboard.setContents(contents, null);
            //如果剪贴板中包含stringFlavor内容  
            if (clipboard.isDataFlavorAvailable(DataFlavor.stringFlavor))
            {
                //将pasteAction激活  
                pasteAction.setEnabled(true);
            }
        }
    };
    public void init()
    {
        //pasteAction默认处于不激活状态  
        pasteAction.setEnabled(false);
        jf.add(new JScrollPane(jta));
        //以Action创建按钮,并将该按钮添加到Panel中  
        JButton copyBn = new JButton(copyAction);
        JButton pasteBn = new JButton(pasteAction);
        JPanel jp = new JPanel();
        jp.add(copyBn);
        jp.add(pasteBn);
        jf.add(jp , BorderLayout.SOUTH);
        //向工具条中添加Action对象,该对象将会转换成工具按钮  
        jtb.add(copyAction);
        jtb.addSeparator();
        jtb.add(pasteAction);
        //向菜单中添加Action对象,该对象将会转换成菜单项  
        edit.add(copyAction);
        edit.add(pasteAction);
        //将edit菜单添加到菜单条中  
        jmb.add(edit);
        jf.setJMenuBar(jmb);
        //设置工具条和工具按钮之间的距离  
        jtb.setMargin(new Insets(20 ,10 , 5 , 30));
        //向窗口中添加工具条  
        jf.add(jtb , BorderLayout.NORTH);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.pack();
        jf.setVisible(true);
    }
    public static void main(String[] args)
    {
        new TestJToolBar().init();
    }
}

继续讲Swing的特殊组件,JColorChooser和JFileChooser这两个东西在awt中都是利用系统的控件,这样导致不同操作系统有不同的界面,用Swing就避免了这些问题  。下面就先看JColorChooser的例子,eg(一个简单画图程序)

public class HandDraw
{
    //画图区的宽度   
    private final int AREA_WIDTH = 500;
    //画图区的高度  
    private final int AREA_HEIGHT = 400;
    //下面的preX、preY保存了上一次鼠标拖动事件的鼠标座标  
    private int preX = -1;
    private int preY = -1;
    //定义一个右键菜单用于设置画笔颜色  
    JPopupMenu pop = new JPopupMenu();
    JMenuItem chooseColor = new JMenuItem("选择颜色");
    //定义一个BufferedImage对象  
    BufferedImage image = new BufferedImage(AREA_WIDTH , AREA_HEIGHT ,
            BufferedImage.TYPE_INT_RGB);
    //获取image对象的Graphics  
    Graphics g = image.getGraphics();
    private JFrame f = new JFrame("简单手绘程序");
    private DrawCanvas drawArea = new DrawCanvas();
    //用于保存需要绘制什么图形的字符串属性  
    private String shape = "";
    //用于保存画笔颜色  
    private Color foreColor = new Color(255, 0 ,0);
    public void init()
    {
        chooseColor.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent ae)
            {
                //下面代码直接弹出一个模式的颜色选择器对话框,并返回用户选择的颜色  
                //foreColor = JColorChooser.showDialog(f , "选择画笔颜色" , foreColor);  
                //下面代码则可以弹出一个非模式的颜色选择对话框,  
                //并可以分别为“确定”按钮、“取消”按钮指定事件监听器  
                final JColorChooser colorPane = new JColorChooser(foreColor);
                JDialog jd = JColorChooser.createDialog(f ,"选择画笔颜色",false,
                        colorPane, new ActionListener()
                        {
                            public void actionPerformed(ActionEvent ae)
                            {
                                foreColor = colorPane.getColor();
                            }
                        }, null);
                jd.setVisible(true);
            }
        });
        //将菜单项组合成右键菜单  
        pop.add(chooseColor);
        //将右键菜单添加到drawArea对象中  
        drawArea.setComponentPopupMenu(pop);
        //将image对象的背景色填充成白色  
        g.fillRect(0 , 0 ,AREA_WIDTH , AREA_HEIGHT);
        drawArea.setPreferredSize(new Dimension(AREA_WIDTH , AREA_HEIGHT));
        //监听鼠标移动动作  
        drawArea.addMouseMotionListener(new MouseMotionAdapter()
        {
            //实现按下鼠标键并拖动的事件处理器  
            public void mouseDragged(MouseEvent e)
            {
                //如果preX和preY大于0  
                if (preX > 0 && preY > 0)
                {
                    //设置当前颜色  
                    g.setColor(foreColor);
                    //绘制从上一次鼠标拖动事件点到本次鼠标拖动事件点的线段  
                    g.drawLine(preX , preY , e.getX() , e.getY());
                }
                //将当前鼠标事件点的X、Y座标保存起来  
                preX = e.getX();
                preY = e.getY();
                //重绘drawArea对象  
                drawArea.repaint();
            }
        });
        //监听鼠标事件  
        drawArea.addMouseListener(new MouseAdapter()
        {
            //实现鼠标松开的事件处理器  
            public void mouseReleased(MouseEvent e)
            {
                //松开鼠标键时,把上一次鼠标拖动事件的X、Y座标设为-1  。  
                preX = -1;
                preY = -1;
            }
        });
        f.add(drawArea);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.pack();
        f.setVisible(true);
    }
    public static void main(String[] args)
    {
        new HandDraw().init();
    }
    //让画图区域继承JPanel类  
    class DrawCanvas extends JPanel
    {
        //重写JPanel的paint方法,实现绘画  
        public void paint(Graphics g)
        {
            //将image绘制到该组件上  
            g.drawImage(image , 0 , 0 , null);
        }
    }
}

下面举个JFileChooser,这些东西组件不是很常用,大家可以收藏着,到用的时候翻出来看,eg


public class ImageViewer
{
    final int PREVIEW_SIZE = 100;
    JFrame jf = new JFrame("简单图片查看器");
    JMenuBar menuBar = new JMenuBar();
    //该label用于显示图片  
    JLabel label = new JLabel();
    //以当前路径创建文件选择器  
    JFileChooser chooser = new JFileChooser(".");
    JLabel accessory = new JLabel();
    ExtensionFileFilter filter = new ExtensionFileFilter();
    public void init()
    {
        //-------------------下面开始初始化JFileChooser的相关属性-----------------  
        // 创建一个FileFilter  
        filter.addExtension("jpg");
        filter.addExtension("jpeg");
        filter.addExtension("gif");
        filter.addExtension("png");
        filter.setDescription("图片文件(*.jpg,*.jpeg,*.gif,*.png)");
        chooser.addChoosableFileFilter(filter);
        //禁止“文件类型”下拉列表中显示“所有文件”选项  。  
        chooser.setAcceptAllFileFilterUsed(false);
        //为文件选择器指定自定义的FileView对象  
        chooser.setFileView(new FileIconView(filter));
        //为文件选择器指定一个预览图片的附件组件  
        chooser.setAccessory(accessory);
        //设置预览图片组件的大小和边框  
        accessory.setPreferredSize(new Dimension(PREVIEW_SIZE, PREVIEW_SIZE));
        accessory.setBorder(BorderFactory.createEtchedBorder());
        //用于检测被选择文件的改变事件  
        chooser.addPropertyChangeListener(new PropertyChangeListener()
        {
            public void propertyChange(PropertyChangeEvent event)
            {
                //JFileChooser的被选文件已经发生了改变  
                if (event.getPropertyName() == JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)
                {
                    //获取用户选择的新文件   
                    File f = (File) event.getNewValue();
                    if (f == null)
                    {
                        accessory.setIcon(null);
                        return;
                    }
                    //将所文件读入ImageIcon对象中  
                    ImageIcon icon = new ImageIcon(f.getPath());
                    //如果图像太大,则缩小它  
                    if(icon.getIconWidth() > PREVIEW_SIZE)
                    {
                        icon = new ImageIcon(icon.getImage()
                                .getScaledInstance(PREVIEW_SIZE, -1, Image.SCALE_DEFAULT));
                    }
                    //改变accessory Label的图标  
                    accessory.setIcon(icon);
                }
            }
        });

        //----------下面代码开始为该窗口安装菜单------------  
        JMenu menu = new JMenu("文件");
        menuBar.add(menu);
        JMenuItem openItem = new JMenuItem("打开");
        menu.add(openItem);
        //单击openItem菜单项显示“打开文件”的对话框  
        openItem.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent event)
            {
                //设置文件对话框的当前路径  
                //chooser.setCurrentDirectory(new File("."));  
                //显示文件对话框  
                int result = chooser.showDialog(jf , "打开图片文件");
                //如果用户选择了APPROVE(赞同)按钮,即打开,保存及其等效按钮  
                if(result == JFileChooser.APPROVE_OPTION)
                {
                    String name = chooser.getSelectedFile().getPath();
                    //显示指定图片  
                    label.setIcon(new ImageIcon(name));
                }
            }
        });
        JMenuItem exitItem = new JMenuItem("退出");
        menu.add(exitItem);
        exitItem.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent event)
            {
                System.exit(0);
            }
        });
        jf.setJMenuBar(menuBar);
        //添加用于显示图片的JLabel组件  。  
        jf.add(new JScrollPane(label));
        jf.setSize(500, 400);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.setVisible(true);
    }

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

//创建FileFilter的子类,用以实现文件过滤功能  
class ExtensionFileFilter extends FileFilter
{

    private String description = "";
    private ArrayList extensions = new ArrayList();
    //自定义方法,用于添加文件扩展名  
    public void addExtension(String extension)
    {
        if (!extension.startsWith("."))
        {
            extension = "." + extension;
            extensions.add(extension.toLowerCase());
        }
    }
    //用于设置该文件过滤器的描述文本  
    public void setDescription(String aDescription)
    {
        description = aDescription;
    }
    //继承FileFilter类必须实现的抽象方法,返回该文件过滤器的描述文本  
    public String getDescription()
    {
        return description;
    }
    //继承FileFilter类必须实现的抽象方法,判断该文件过滤器是否接受该文件  
    public boolean accept(File f)
    {
        //如果该文件是路径,接受该文件  
        if (f.isDirectory()) return true;
        //将文件名转为小写(全部转为小写后比较,用于忽略文件名大小写)  
        String name = f.getName().toLowerCase();
        //遍历所有可接受的扩展名,如果扩展名相同,该文件就可接受  。  
        for (String extension : extensions)
        {
            if (name.endsWith(extension))
            {
                return true;
            }
        }
        return false;
    }
}
//自定义一个FileView类,用于为指定类型的指定图标  
class FileIconView extends FileView
{
    private FileFilter filter;
    public FileIconView(FileFilter filter)
    {
        this.filter = filter;
    }
    //如果文件不是目录,并且不是  
    public Icon getIcon(File f)
    {
        if (!f.isDirectory() && filter.accept(f))
        {
            return new ImageIcon("ico/pict.png");
        }
        else if (f.isDirectory())
        {
            //获取所有根路径  
            File[] fList = File.listRoots();
            for (File tmp : fList)
            {
                //如果该路径是根路径  
                if (tmp.equals(f))
                {
                    return  new ImageIcon("ico/dsk.png");
                }
            }
            return new ImageIcon("ico/folder.png");
        }
        //使用默认图标  
        else
        {
            return null;
        }
    }
}

注意:以上图片我都没给,自己随便弄几张看看效果


  JOptionPane是一种特殊的JFrame,他的出现是为了方便我们创建一些简单的对话框,你也可以用JFrame搞一个,但很繁琐,但如果你用UI的拖拽工具那就没什么了  。eg(各种对话框)

public class TestJOptionPane  
{  
    JFrame jf = new JFrame("测试JOptionPane");  
    //分别定义6个面板用于定义对话框的几种选项  
    private ButtonPanel messagePanel;  
    private ButtonPanel messageTypePanel;  
    private ButtonPanel msgPanel;  
    private ButtonPanel confirmPanel;  
    private ButtonPanel optionsPanel;  
    private ButtonPanel inputPanel;  
    private String messageString = "消息区内容";  
    private Icon messageIcon = new ImageIcon("ico/heart.png");  
    private Object messageObject = new Date();  
    private Component messageComponent = new JButton("组件消息");  
    private JButton msgBn = new JButton("消息对话框");  
    private JButton confrimBn = new JButton("确认对话框");  
    private JButton inputBn = new JButton("输入对话框");  
    private JButton optionBn = new JButton("选项对话框");  
 
    public void init()  
    {  
        JPanel top = new JPanel();  
        top.setBorder(new TitledBorder(new EtchedBorder(), "对话框的通用选项" ,   
            TitledBorder.CENTER ,TitledBorder.TOP ));  
        top.setLayout(new GridLayout(1 , 2));  
        //消息类型Panel,该Panel中的选项决定对话框的图标  
        messageTypePanel = new ButtonPanel("选择消息的类型",   
            new String[]{"ERROR_MESSAGE", "INFORMATION_MESSAGE", "WARNING_MESSAGE",   
            "QUESTION_MESSAGE", "PLAIN_MESSAGE" });  
        //消息内容类型的Panel,该Panel中的选项决定对话框的消息区的内容  
        messagePanel = new ButtonPanel("选择消息内容的类型",   
            new String[]{"字符串消息", "图标消息", "组件消息",   "普通对象消息" , "Object[]消息"});  
        top.add(messageTypePanel);  
        top.add(messagePanel);  
        JPanel bottom = new JPanel();  
        bottom.setBorder(new TitledBorder(new EtchedBorder(), "弹出不同的对话框" ,   
            TitledBorder.CENTER ,TitledBorder.TOP));  
        bottom.setLayout(new GridLayout(1 , 4));  
        //创建用于弹出消息对话框的Panel  
        msgPanel = new ButtonPanel("消息对话框", null);  
        msgBn.addActionListener(new ShowAction());  
        msgPanel.add(msgBn);  
        //创建用于弹出确认对话框的Panel  
        confirmPanel = new ButtonPanel("确认对话框",   
            new String[]{"DEFAULT_OPTION", "YES_NO_OPTION", "YES_NO_CANCEL_OPTION",  
            "OK_CANCEL_OPTION"});  
        confrimBn.addActionListener(new ShowAction());  
        confirmPanel.add(confrimBn);  
        //创建用于弹出输入对话框的Panel  
        inputPanel = new ButtonPanel("输入对话框",  
            new String[]{"单行文本框","下拉列表选择框"});  
        inputBn.addActionListener(new ShowAction());  
        inputPanel.add(inputBn);  
        //创建用于弹出选项对话框的Panel  
        optionsPanel = new ButtonPanel("选项对话框",   
            new String[]{"字符串选项", "图标选项", "对象选项"});  
        optionBn.addActionListener(new ShowAction());  
        optionsPanel.add(optionBn);  
        bottom.add(msgPanel);  
        bottom.add(confirmPanel);  
        bottom.add(inputPanel);  
        bottom.add(optionsPanel);  
        Box box = new Box(BoxLayout.Y_AXIS);  
        box.add(top);  
        box.add(bottom);  
        jf.add(box);  
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
        jf.pack();  
        jf.setVisible(true);  
    }  
    //根据用户选择返回选项类型  
    private int getOptionType()  
    {  
        if (confirmPanel.getSelection().equals("DEFAULT_OPTION"))  
            return JOptionPane.DEFAULT_OPTION;  
        else if (confirmPanel.getSelection().equals("YES_NO_OPTION"))  
            return JOptionPane.YES_NO_OPTION;  
        else if (confirmPanel.getSelection().equals("YES_NO_CANCEL_OPTION"))  
            return JOptionPane.YES_NO_CANCEL_OPTION;  
        else 
            return JOptionPane.OK_CANCEL_OPTION;  
    }  
    //根据用户选择返回消息  
    private Object getMessage()  
    {  
        if (messagePanel.getSelection().equals("字符串消息"))  
            return messageString;  
        else if (messagePanel.getSelection().equals("图标消息"))  
            return messageIcon;  
        else if (messagePanel.getSelection().equals("组件消息"))  
            return messageComponent;  
        else if(messagePanel.getSelection().equals("普通对象消息"))  
            return messageObject;  
        else 
            return  new Object[]{messageString , messageIcon ,   
                messageObject , messageComponent};  
    }  
    //根据用户选择返回消息类型(决定图标区的图标)  
    private int getDialogType()  
    {  
        if (messageTypePanel.getSelection().equals("ERROR_MESSAGE"))  
            return JOptionPane.ERROR_MESSAGE;  
        else if (messageTypePanel.getSelection().equals("INFORMATION_MESSAGE"))  
            return JOptionPane.INFORMATION_MESSAGE;  
        else if (messageTypePanel.getSelection().equals("WARNING_MESSAGE"))  
            return JOptionPane.WARNING_MESSAGE;  
        else if(messageTypePanel.getSelection().equals("QUESTION_MESSAGE"))  
            return JOptionPane.QUESTION_MESSAGE;  
        else 
            return JOptionPane.PLAIN_MESSAGE;  
    }  
    private Object[] getOptions()  
    {  
        if (optionsPanel.getSelection().equals("字符串选项"))  
            return new String[]{"a" , "b" , "c" , "d"};  
        else if (optionsPanel.getSelection().equals("图标选项"))  
            return new Icon[]{new ImageIcon("ico/1.gif") , new ImageIcon("ico/2.gif"),  
            new ImageIcon("ico/3.gif"),new ImageIcon("ico/4.gif")};  
        else 
            return new Object[]{new Date() ,new Date() , new Date()};  
    }  
 
    //为各按钮定义事件监听器  
    private class ShowAction implements ActionListener  
    {  
        public void actionPerformed(ActionEvent event)  
        {    
            if (event.getActionCommand().equals("确认对话框"))  
            {  
                JOptionPane.showConfirmDialog(jf , getMessage(),"确认对话框",   
                    getOptionType(), getDialogType());  
            }  
            else if (event.getActionCommand().equals("输入对话框"))  
            {    
                if (inputPanel.getSelection().equals("单行文本框"))  
                {  
                    JOptionPane.showInputDialog(jf, getMessage(), "输入对话框", getDialogType());  
                }  
                else 
                {  
                    JOptionPane.showInputDialog(jf, getMessage(), "输入对话框", getDialogType(),  
                    null,   new String[] {"轻量级J2EE企业应用实战", "Struts2权威指南"},   
                    "Struts2权威指南");  
                }  
            }  
            else if (event.getActionCommand().equals("消息对话框"))  
            {  
                JOptionPane.showMessageDialog(jf,getMessage(),"消息对话框",getDialogType());  
            }  
            else if (event.getActionCommand().equals("选项对话框"))  
            {  
                JOptionPane.showOptionDialog(jf , getMessage() , "选项对话框", getOptionType(),  
                    getDialogType(), null,  getOptions(), "a");  
            }  
        }  
    }  
 
    public static void main(String[] args)  
    {    
        new TestJOptionPane().init();  
    }  
}  
 
//定义一个JPanel类扩展类,该类的对象包含多个纵向排列的JRadioButton控件  
//且Panel扩展类可以指定一个字符串作为TitledBorder  
class ButtonPanel extends JPanel  
{    
    private ButtonGroup group;  
    public ButtonPanel(String title, String[] options)  
    {    
        setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), title));  
        setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));  
        group = new ButtonGroup();  
        for (int i = 0; options!= null && i < options.length; i++)  
        {    
            JRadioButton b = new JRadioButton(options[i]);  
            b.setActionCommand(options[i]);  
            add(b);  
            group.add(b);  
            b.setSelected(i == 0);  
        }  
    }  
    //定义一个方法,用于返回用户选择的选项  
    public String getSelection()  
    {    
        return group.getSelection().getActionCommand();  
    }     
}