Java Swing中的JButton、JComboBox、JList和JColorChooser组件使用案例

swing 的组件与awt 组件相似，但又为每一个组件增添了新的方法，并提供了更多的高级组件.

swing 的基本组件:

1.按钮(jbutton):

swing 中的按钮可以显示图像，并且可以将按钮设置为窗口的默认图标，而且还可以将多个图像指定给一个按钮。

(1).jbutton 常用的构造方法。

jbutton(string text)：按钮上显示字符。
jbutton(icon icon) ：按钮上显示图标。
jbutton(string text, icon icon)：按钮上既显示图标又显示字符。

(2).常用方法:

b1.setenabled(false);  //使按钮当前不可用
b1.settooltiptext("..."): //设置按钮提示文本
b1.setmnemonic(keyevent.vk_d);// 将b1邦定alt+d键

(3).案例代码:

public class jbuttonexample3 extends jpanel implements actionlistener { 
 
    protected jbutton b1, b2, b3; 
 
    public jbuttonexample3() { 
         
        imageicon leftbuttonicon = createimageicon("right.gif"); 
        imageicon middlebuttonicon = createimageicon("middle.gif"); 
        imageicon rightbuttonicon = createimageicon("left.gif"); 
         
        b1 = new jbutton("失效中间按钮(d)", leftbuttonicon); 
        b1.setverticaltextposition(abstractbutton.center);// 水平中间对齐 
        b1.sethorizontaltextposition(abstractbutton.leading);// 相当于left 
        b1.setmnemonic(keyevent.vk_d);// 将b1邦定alt+d键 
        b1.setactioncommand("disable"); 
         
        b2 = new jbutton("m中间按钮", middlebuttonicon); 
        b2.setverticaltextposition(abstractbutton.bottom); 
        b2.sethorizontaltextposition(abstractbutton.center); 
        b2.setmnemonic(keyevent.vk_m);// 将b2邦定alt+m键 
         
        b3 = new jbutton("e激活中间按钮", rightbuttonicon); 
        b3.setmnemonic(keyevent.vk_e);// 将b3邦定alt+e键 
        b3.setactioncommand("enable"); 
        b3.setenabled(false); 
         
        // 给1和3添加事件监听 
        b1.addactionlistener(this); 
        b3.addactionlistener(this); 
         
        // 设置按钮提示文本 
        b1.settooltiptext("点击这个按钮，将使中间的按钮失效！"); 
        b2.settooltiptext("点击这个按钮，没有任何的事件发生！"); 
        b3.settooltiptext("点击这个按钮，将使中间的按钮有效"); 
         
        // 将按钮添加到jpanel中 
        add(b1); 
        add(b2); 
        add(b3); 
    } 
 
    public void actionperformed(actionevent e) { 
        if ("disable".equals(e.getactioncommand())) { 
            b2.setenabled(false); 
            b1.setenabled(false); 
            b3.setenabled(true); 
        } else { 
            b2.setenabled(true); 
            b1.setenabled(true); 
            b3.setenabled(false); 
        } 
    } 
 
    protected static imageicon createimageicon(string path) { 
        java.net.url imgurl = jbuttonexample3.class.getresource(path); 
        if (imgurl != null) { 
            return new imageicon(imgurl); 
        } else { 
            system.err.println("couldn′t find file: " + path); 
            return null; 
        } 
    } 
 
    public static void main(string[] args) { 
        // 设置使用新的swing界面 
        //提供一个关于新创建的 jframe 是否应该具有当前外观为其提供的 window 装饰（如边框、关闭窗口的小部件、标题等等）的提示。 
        jframe.setdefaultlookandfeeldecorated(true); 
        // 创建一个窗体 
        jframe frame = new jframe("小龙按钮"); 
        frame.setdefaultcloseoperation(jframe.exit_on_close); 
        // 创建一个面板 
        jbuttonexample3 newcontentpane = new jbuttonexample3(); 
        newcontentpane.setopaque(true); 
        frame.setcontentpane(newcontentpane); 
        // 显示窗体 
        frame.pack(); 
        frame.setlocation(300, 200); 
        frame.setvisible(true); 
    } 
} 

运行截图:

2.组合框(jcombobox):

组合框(下拉列表jcombobox)使用方法及示例详解:

构造方法:
* jcombobox() 建立一个jcombobox组件.
* jcombobox(comboboxmodel model) 根据model建立一个jcombobox组件.
* jcombobox(objext[] items) 利用数组对象建立一个jcombobox组件.
* jcombobox(vector items) 利用vector对象建立一个jcombobox组件.

常用方法:

....

综合示例:

import java.awt.*; /* 包含用于创建用户界面和绘制图形图像的所有类。 */ 
import javax.swing.*; /* 提供一组"轻量级"组件，尽量让这些组件在所有平台上的工作方式都相同 */ 
 
 
public class jcomboboxdemo extends jframe { 
     
    public jcomboboxdemo() { 
        /*
         * container是所有容器的父类,又是java语言的组件类component的子类. 容器是一种具有容纳其他组件和容器的功能的组件
         * 一个java的图形用户界面的最基本元素是组件,组件是可以以图形化的方式显示在屏幕上并能与用户进行交互的对象,如一个按钮,一个文本框等.
         * 在java中,通常将组件放在一定的容器内使用 this.getcontentpane()方法返回此窗体的 contentpane 对象
         */ 
        container contentpane = this.getcontentpane(); 
         
        /* 创建一个面板对象,指定布局管理器为gridlayout,1行2列.jpanel的默认版面管理为flowlayout */ 
        jpanel jpanel1 = new jpanel(new gridlayout(1, 2)); 
         
        // 利用string数组建立jcombobox 
        string[] fruit = { "苹果", "香蕉", "桔子", "梨", "芒果" }; 
        jcombobox jcombobox1 = new jcombobox(fruit); 
        jcombobox1.additem("其他"); // 在列表框选项的最后再添加一个"其他"选项 
         
        // 设置jlist1对象的带标题边框 
        jcombobox1.setborder(borderfactory.createtitledborder("您最喜欢的水果:")); 
        // 添加列表框jcombobox1至面板 
        jpanel1.add(jcombobox1); 
         
        // 利用comboboxmodel建立jcombobox 
        comboboxmodel mymodel = new mymodel(); 
        jcombobox jcombobox2 = new jcombobox(mymodel); 
        // 设置jlist1对象的带标题边框 
        jcombobox2.setborder(borderfactory.createtitledborder("您最喜欢的水果:")); 
        // 添加列表框jcombobox2至面板 
        jpanel1.add(jcombobox2); 
         
        // 添加面板至父容器 
        contentpane.add(jpanel1); 
        // 设置本窗体的标题 
        this.settitle("jcomboboxdemo"); 
        // 设置本窗体显示的初始大小 
        this.setsize(350, 90); 
        this.setlocation(300, 200); 
        // 设置本窗体初始可见 
        this.setvisible(true); 
    } 
 
    class mymodel extends defaultcomboboxmodel { 
        string[] fruit = { "苹果", "香蕉", "桔子", "梨", "芒果" }; 
 
        mymodel() { 
            for (int i = 0; i < fruit.length; i++) { 
                /* addelement()方法用于向列表框添加选项元素 */ 
                this.addelement(fruit[i]); 
            } 
        } 
    } 
 
    public static void main(string args[]) { 
        jcomboboxdemo test = new jcomboboxdemo(); 
    } 
}

截图:

3.列表框(jlist):

列表框的功能与下拉列表框相似，也是让用户在几个条目中做出选择，但又有一些区别，它提供给用户的选择模式更为多样，分别是单一选择、连续选择、多项选择，对应于 listselectionmodel 中的3个常量：

(1) static int single_selection 只能选择一条。

(2) static int single_interval_selection 按住[shift]键可选择联系的区间。

(3) static int multiple_interval_selection 按住[ctrl]键可选择多条。

构造函数如下：

(1) jlist() 建立一个 jlist 组件。

(2) jlist(listmodel model) 根据 model 建立一个 jlist 组件。

(3) jlist(object[] items) 利用数组对象建立一个 jlist 组件。

(4) jlist(vector items) 利用 vector 对象建立一个 jlist 组件。

将列表框jlist添加到jscrollpane中可以实现列表框的滚动.

列表(jlist)组件使用示例1如下：

public class jlistdemo1 extends jframe{ 
     
    container contentpane; 
    jpanel jp; 
    jlist jlist1,jlist2,jlist3; 
     
   public jlistdemo1(){ 
        
      contentpane = this.getcontentpane(); 
       
      jp = new jpanel(new gridlayout(1,3)); 
 
      //利用string数组建立jlist对象 
      string[] fruit={"苹果","香蕉","桔子","梨","芒果"}; 
      jlist1=new jlist(fruit); 
      //设置jlist1对象的带标题边框 
      jlist1.setborder(borderfactory.createtitledborder("您最喜欢的水果: ")); 
      //设置jlist1对象的选择模式为单一选择 
      jlist1.setselectionmode(listselectionmodel.single_selection); 
      jp.add(jlist1); 
 
      //利用listmodel建立jlist对象,可实现列表内容的动态 
      listmodel mymodel=new mymodel(); //创建一个列表模型对象       
      jlist2=new jlist(mymodel); //根据列表模型对象创建列表 
      jlist2.setborder(borderfactory.createtitledborder("您最喜欢的水果: ")); 
 
      //设置jlist2对象的选择模式为按住[ctrl]可多项选择 
      jlist2.setselectionmode(listselectionmodel.multiple_interval_selection); 
      jp.add(jlist2); 
       
      jlist3=new jlist(fruit); 
      jlist3.setborder(borderfactory.createtitledborder("您最喜欢的水果: ")); 
      jlist3.setselectionmode(listselectionmodel.multiple_interval_selection); 
      jlist3.setvisiblerowcount(3); 
      jlist3.setfixedcellwidth(120); 
      jlist3.setfixedcellheight(30); 
      jscrollpane jscrollpane = new jscrollpane(jlist3); 
      jp.add(jscrollpane); 
       
      contentpane.add(jp); 
       
      this.settitle("jlistdemo"); 
      this.setsize(340,200); 
      //pack(); 
      this.setlocation(400, 300); 
      this.setvisible(true); 
   } 
 
   //通过继承defaultlistmodel类可实现动态内容的列表选择 
   class mymodel extends defaultlistmodel{ 
        
      string[] fruit={"苹果","香蕉","桔子","梨","芒果"}; 
       
      mymodel(){ 
         for(int i=0;i<fruit.length;i++){ 
            /* void addelement(object obj) 
             * 将指定组件添加到此类表的末尾。*/ 
            this.addelement(fruit[i]); 
         } 
      } 
   } 
 
   public static void main(string[] args){ 
      jlistdemo1 test=new jlistdemo1(); 
   } 
} 

运行结果如下图所示：

列表框示例2代码:

public class jlistdemo2 extends jframe { 
 
    container contentpane; 
    jpanel jp; 
    jlist jlistfont, jlistsize; 
 
    // 构造函数 
    public jlistdemo2() { 
 
        contentpane = this.getcontentpane(); 
        jp = new jpanel(new gridlayout()); 
 
        setjlistfont(); 
        setjlistfontsize(); 
 
        contentpane.add(jp); 
 
        this.settitle("jlistdemo"); 
        this.setsize(240, 200); 
        this.setlocation(400, 300); 
        this.setvisible(true); 
 
    } // end of jlistdemo2 
 
    public void setjlistfont() { 
        graphicsenvironment ge = graphicsenvironment 
                .getlocalgraphicsenvironment(); 
        final string fontname[] = ge.getavailablefontfamilynames(); // 获取系统的本地字体 
 
        jlistfont = new jlist(fontname); 
 
        // 设置jlist1对象的带标题边框 
        jlistfont.setborder(borderfactory.createtitledborder("系统字体: ")); 
        // 设置jlist1对象的选择模式为单一选择 
        jlistfont.setselectionmode(listselectionmodel.single_selection); 
        jlistfont.setvisiblerowcount(3); 
        jlistfont.setfixedcellwidth(120); 
        jlistfont.setfixedcellheight(20); 
 
        jscrollpane jscrollpane1 = new jscrollpane(jlistfont); 
        jp.add(jscrollpane1); 
    } 
    public void setjlistfontsize() { 
        final string fontsize[] = { "8", "9", "10", "12", "14", "15", "16", 
                "18", "20", "21", "22", "24", "26", "28", "30", "36", "48", 
                "54", "72", "89" }; 
        // 创建字号的列表框listsize 
        jlistsize = new jlist(fontsize); 
        jlistsize.setborder(borderfactory.createtitledborder("字体大小: ")); 
        // 设置jlist2对象的选择模式为按住[ctrl]可多项选择 
        jlistsize 
                .setselectionmode(listselectionmodel.multiple_interval_selection); 
        jlistsize.setvisiblerowcount(3); 
        jlistsize.setfixedcellwidth(120); 
        jlistsize.setfixedcellheight(20); 
 
        jscrollpane jscrollpane2 = new jscrollpane(jlistsize); 
        jp.add(jscrollpane2); 
    } 
 
    public static void main(string[] args) { 
        jlistdemo2 test = new jlistdemo2(); 
    } 
}

程序运行示意图:

4.javax.swing

类 jcolorchooser:
jcolorchooser (颜色选择对话框)提供一个用于允许用户操作和选择颜色的控制器窗格。

jcolorchooser构造函数:
jcolorchooser():建立一个jcolorchooer对象,默认颜色为白色.
jcolorchooser(color initialcolor):建立一个jcolorchooer对象,并设置初始颜色.
jcolorchooser(colorselectionmodel modal):以colorselectionmodel构造jcolorchooser对象.

最常使用jcolorchooser的方式是使用jcolorchooser的静态方法showdialog().也就是说在大部份的情况下,我们不会new一个jcolorchooser对象,而是直接使用jcolorchooser的静态方法(showdialog())来输出颜色选择对话框.利用这个方法我们亦可以得到用户所选择的颜色,若用户没有选择则返回null值.

颜色选择对话框的简单案例1代码:

public class jcolorchooserdemo { 
 
    public static void main(string[] args) { 
 
        jframe frame = new jframe("jcolorchooserdemo"); 
         
        mypanel panel = new mypanel(); 
        frame.getcontentpane().add(panel); 
         
        frame.pack(); 
        frame.setlocation(300, 200); 
        frame.setvisible(true); 
        frame.setdefaultcloseoperation(jframe.exit_on_close); 
    } 
} 
 
class mypanel extends jpanel implements actionlistener { 
 
    private static final long serialversionuid = 1l; 
    private jbutton button,rgb,red,green,blue; 
    private color color = new color(255, 51, 150); 
 
    public mypanel() { 
 
        button = new jbutton("get color"); 
        rgb = new jbutton("rgb: "); 
        red = new jbutton("red: "); 
        green = new jbutton("green: "); 
        blue = new jbutton("blue: "); 
        button.addactionlistener(this); 
 
        setpreferredsize(new dimension(550, 250)); 
        setlayout(new flowlayout(flowlayout.center, 5, 5)); 
        setbackground(color); 
        add(button); 
        add(rgb); 
        add(red); 
        add(green); 
        add(blue); 
    } 
 
    public void actionperformed(actionevent e) { 
 
        color = jcolorchooser.showdialog(this, "choose color", color); 
 
        if (color != null) { 
            setbackground(color); 
            button.settext("get again"); 
            rgb.settext("rgb: " + color.getrgb()); 
            red.settext("red: " + color.getred()); 
            green.settext("green: " + color.getgreen()); 
            blue.settext("blue: " + color.getblue()); 
        } 
    } 
}

运行结果示意图如下:

另外还有一个使用jcolorchooser常用的方式,那就是使用createdialog()静态方法.使用这个静态方法后会得到一个jdialog对象,我们可以利用这个jdialog对象对颜色选择对话框做更多的设置.不过利用这个方法必须配合jcolorchooser对象才行,也就是必须new出一个jcolorchooser对象来.下面范例介绍最简单的也是最实用jcolorchooser,选择颜色完毕后就能更改jlabel上的背景颜色.

颜色选择对话框的简单案例2代码:

import java.awt.*; 
import java.awt.event.*; 
import javax.swing.*; 
 
public class colorchooserdemo1 extends mouseadapter { 
     
    jframe f = null; 
    jlabel label = null; 
    jlabel label1 = null; 
    jlabel label2 = null; 
    rectangle rec1 = null; 
    rectangle rec2 = null; 
 
    public colorchooserdemo1() { 
     
        f = new jframe("colorchooser example"); 
        container contentpane = f.getcontentpane(); 
        contentpane.addmouselistener(this); 
 
        label = new jlabel(" ", jlabel.center); 
        label.setpreferredsize(new dimension(300, 20)); 
 
        jpanel panel = new jpanel(); 
        panel.setlayout(new gridlayout(1, 2)); 
 
        label1 = new jlabel("左label", jlabel.center); 
        label1.setbackground(color.red); 
        label1.setforeground(color.black); 
        label1.setopaque(true); 
        label1.setbounds(0, 0, 150, 150); 
        panel.add(label1); 
 
        label2 = new jlabel("右label", jlabel.center); 
        label2.setbackground(color.green); 
        label2.setforeground(color.black); 
        label2.setopaque(true); 
        label2.setbounds(150, 0, 150, 150); 
        panel.add(label2); 
 
        rec1 = label1.getbounds(); 
        rec2 = label2.getbounds(); 
 
        contentpane.add(panel, borderlayout.center); 
        contentpane.add(label, borderlayout.south); 
 
        f.setsize(new dimension(300, 150)); 
        f.setvisible(true); 
 
        f.addwindowlistener(new windowadapter() { 
            public void windowclosing(windowevent e) { 
                system.exit(0); 
            } 
        }); 
    } 
 
    // 实现mouseadapter中的mousepressed()与mouseclicked()方法.当按下鼠标时,就能知道鼠标光标目前的位置.当连续键击鼠标 
    // 两次时,若光标所在位置在label中,就会出现颜色选择对话框,用户可选择任一颜色更改label的颜色. 
    public void mousepressed(mouseevent e) { 
        label.settext("目前鼠标坐标（x,y）为：（" + e.getx() + "," + e.gety() + ")"); 
    } 
 
    public void mouseclicked(mouseevent e) { 
        point point = e.getpoint(); 
 
        if (e.getclickcount() == 2) { 
            if (rec1.contains(point)) { 
                /*
                 * 利用jcolorchooser的showdialog()静态方法输出颜色选择对话框
                 * ,showdialog()中的3个参数依次是: 对话框的父组件,颜色选择对话框标题
                 * ,与对话框默认颜色.当用户选择完颜色之后,按下"ok"按钮则返回
                 * color对象,若按下"cancel"按钮则返回null值.
                 */ 
                color color = jcolorchooser.showdialog(f, 
                        "change label1 color", color.white); 
                if (color != null) // 若为null值表示用户按下cancel按钮 
                    label1.setbackground(color); 
            } 
            if (rec2.contains(point)) { 
                color color = jcolorchooser.showdialog(f, 
                        "change label2 color", color.yellow); 
                if (color != null) // 若为null值表示用户按下cancel按钮 
                    label2.setbackground(color); 
            } 
        } 
    } 
     
    public static void main(string[] arg) { 
        new colorchooserdemo1(); 
    } 
}

程序运行示意图: