7－1：使用JCheckBox元件：
類層次結構圖：
java.lang.Object
--java.awt.Component
--java.awt.Container
--javax.swing.JComponent
--javax.swing.AbstractButton
--javax.swing.JToggleButton
--javax.swing.JCheckBox
JCheckBox與JRadioButton為JToggleButton的子類，是以它們可以使用AbstractButton抽象類裡面許多好用的方法,如addItemLi
stener()、setText()、isSelected()等等。
構造函數：
JCheckBox():建立一個新的JChcekBox.
JCheckBox(Icon icon):建立一個有圖像但沒有文字的JCheckBox.
JCheckBox(Icon icon,boolean selected):建立一個有圖像但沒有文字的JCheckBox,且設定其初始狀态（有無被選取）。
JCheckBox(String text):建立一個有文字的JCheckBox.
JCheckBox(String text,boolean selected):建立一個有文字的JCheckBox,且設定其初始狀态（有無被選取）。
JCheckBox(String text,Icon icon):建立一個有文字且有圖像的JCheckBox,初始狀态為無被選取。
JCheckBox(String text,Icon icon,boolean selected):建立一個有文字且有圖像的JCheckBox,且設定其初始狀态(有無被選取
)。
7-1-1:構造JCheckBox元件:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JCheckBox1{
public static void main(String[] args){
JFrame f=new JFrame("JCheckBox1");
Container contentPane=f.getContentPane();
contentPane.setLayout(new GridLayout(2,1));
JPanel p1=new JPanel();
p1.setLayout(new GridLayout(1,3));
p1.setBorder(BorderFactory.createTitledBorder("你最喜歡哪一家快餐店呢？"));
JCheckBox c1=new JCheckBox("麥當勞");
JCheckBox c2=new JCheckBox("肯德基");
JCheckBox c3=new JCheckBox("21世紀");
p1.add(c1);
p1.add(c2);
p1.add(c3);
JPanel p2=new JPanel();
p2.setLayout(new GridLayout(2,1));
p2.setBorder(BorderFactory.createTitledBorder("以下為JCheckBox的圖形示範:"));
JCheckBox c4=new JCheckBox("圖形1",new ImageIcon(".//icons//x.jpg"));
JCheckBox c5=new JCheckBox("圖形2",new ImageIcon(".//icons//x.jpg"));
p2.add(c4);
p2.add(c5);
contentPane.add(p1);
contentPane.add(p2);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
}
}
7-1-2:JCheckBox事件處理:
你可以在上面的選項中勾選你喜歡吃的快餐店，在勾選的過程中，你可以發現它是可以複選的。但在圖形選項中，我們并無法
清楚使用者是否選擇此項目，因為選或不選圖形都一樣。為解決這個問題，我們要使用到事件處理方法。當JCheckBox中的選項被選取
或取消時，它會觸發ItemEvent的事件，ItemEvent這個類共提供了4種方法可以使用，分别是getItem()、getItemSelectable()、
getStateChange()、paramString()。getItem()與paramString()方法會傳回一些這個JCheckBox的狀态值。一般我們較少用到這兩
個方法。
getItemSelectable()相當于getSource()方法，一樣都是傳回觸發事件的元件，用來判斷是那個元件産生事件。在上一章中我
們曾經說過，getSource()方法是EventObject類所提供，而所有事件類都會繼承這個類，是以所有的事件我們均能用getSource()
方法來判斷到底是哪個元件觸發了事件。
最後getStateChange()方法會傳回此元件到底有沒有被選取。這個方法會傳回一個整數值。而我們可以用ItemEvent所提供的類
變量;若被選取則傳回SELECTED,若沒有被選取則傳回DESELECTED.
下面這個範例我們即利用ItemListener來選取圖形産生變化，ItemListener這個inteface隻有定義一個方法，那就是
itemStateChange(ItemEvent e),是以我們隻需實作這個方法.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JCheckBox2 implements ItemListener
{
JFrame f = null;
JCheckBox c4 = null;
JCheckBox c5 = null;
JCheckBox2(){
f = new JFrame("JCheckBox");
Container contentPane = f.getContentPane();
contentPane.setLayout(new GridLayout(2,1));
JPanel p1 = new JPanel();
p1.setLayout(new GridLayout(1,3));
p1.setBorder(BorderFactory.createTitledBorder("您最喜歡哪一家速食店呢？"));
JCheckBox c1 = new JCheckBox("麥當勞");
JCheckBox c2 = new JCheckBox("肯德雞");
JCheckBox c3 = new JCheckBox("21世紀");
p1.add(c1);
p1.add(c2);
p1.add(c3);
JPanel p2 = new JPanel();
p2.setLayout(new GridLayout(2,1));
p2.setBorder(BorderFactory.createTitledBorder("您喜歡哪種程式語言，喜歡的請打勾："));
c4 = new JCheckBox("JAVA",new ImageIcon(".//icons//x.jpg"));
c5 = new JCheckBox("C++",new ImageIcon(".//icons//x.jpg"));
c4.addItemListener(this);
c5.addItemListener(this);
p2.add(c4);
p2.add(c5);
contentPane.add(p1);
contentPane.add(p2);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public void itemStateChanged(ItemEvent e)
{
if (e.getStateChange() == e.SELECTED)
{
if(e.getSource() == c4)
c4.setIcon(new ImageIcon(".//icons//r.jpg"));
if(e.getSource() == c5)
c5.setIcon(new ImageIcon(".//icons//r.jpg"));
}
else
{
if(e.getSource() == c4)
c4.setIcon(new ImageIcon(".//icons//x.jpg"));
if(e.getSource() == c5)
c5.setIcon(new ImageIcon(".//icons//x.jpg"));
}
}
public static void main(String args[])
{
new JCheckBox2();
}
}
7-2:JRadioButton的使用:
java.lang.Object
--java.awt.Component
--java.awt.Container
--javax.swing.JComponent
--javax.swing.Abstractbutton
--javax.swing.JToggleButton
--javax.swing.JRadioButton
JRadioButtonBN J JToggleButton的一個了類，是以它也可以使用AbstractButton抽象類裡的方法。如同前面所述，JChexkBox
主要用在多重選擇時機，而JRadioButton則是運用在單一選擇時機。
JRadioButton構造函數：
JRadioButton():建立一個新的JRadioButton.
JRadioButton(Icon icon):建立一個有圖像但沒有文字的JRadioButton.
JRadioButton(Icon icon,boolean selected):建立一個有圖像但沒有文字的JRadioButton,且設定其初始狀态(有無被選取).
JRadioButton(String text):建立一個有文字的JRadioButton.
JRadioButton(String text,boolean selected):建立一個有文字的JRadioButton,且設定其初始狀态（有無被選取）。
JRadioButton(String text,Icon icon):建立一個有文字且有圖像的JRadioButton,初始狀态為無被選取。
JRadioButton(String text,Icon icon,boolean selected):建立一個有文字且有圖像的JRadioButton,且設定其初始狀态(有無
被選取。
7-2-1:構造JRadioButton元件與事件處理:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JRadioButton1 implements ItemListener
{
JFrame f = null;
JRadioButton r4 = null;
JRadioButton r5 = null;
JRadioButton1(){
f = new JFrame("JRadioButton");
Container contentPane = f.getContentPane();
contentPane.setLayout(new GridLayout(2,1));
JPanel p1 = new JPanel();
p1.setLayout(new GridLayout(1,3));
p1.setBorder(BorderFactory.createTitledBorder("您最喜歡哪一家速食店呢？"));
JRadioButton r1 = new JRadioButton("麥當勞");
JRadioButton r2 = new JRadioButton("肯德雞");
JRadioButton r3 = new JRadioButton("21世紀");
p1.add(r1);
p1.add(r2);
p1.add(r3);
JPanel p2 = new JPanel();
p2.setLayout(new GridLayout(2,1));
p2.setBorder(BorderFactory.createTitledBorder("您喜歡哪種程式語言? 喜歡的請打勾"));
r4 = new JRadioButton("JAVA",new ImageIcon(".//icons//x.jpg"));
r5 = new JRadioButton("C++",new ImageIcon(".//icons//x.jpg"));
r4.addItemListener(this);
r5.addItemListener(this);
p2.add(r4);
p2.add(r5);
contentPane.add(p1);
contentPane.add(p2);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public void itemStateChanged(ItemEvent e)
{
if (e.getStateChange() == e.SELECTED)
{
if(e.getSource() == r4)
r4.setIcon(new ImageIcon(".//icons//r.jpg"));
if(e.getSource() == r5)
r5.setIcon(new ImageIcon(".//icons//r.jpg"));
}
else
{
if(e.getSource() == r4)
r4.setIcon(new ImageIcon(".//icons//x.jpg"));
if(e.getSource() == r5)
r5.setIcon(new ImageIcon(".//icons//x.jpg"));
}
}
public static void main(String args[])
{
new JRadioButton1();
}
}
要将RadioButton改成單選，我們必須用到ButtonGroup這個類。這個類位于javax.swing這個package下面，ButtonGroup類的主
要功能是:同一時間内隻會有一個元件的狀态為"on",其他皆為"off",也就是同一時間隻有一個元件會被選取。而ButtonGroup類可
被AbstractButton下面的子類所使用，最常被使用的就是JRadioButton、JradioButtonMenu、Item與JToggleButton這些元件。
下面是ButtonGroup的類層次結構圖:
ButtonGroup的類層次結構圖：
java.lang.Object
--javax.swing.ButtonGroup
我們更改上例，使RadioButton變成單選吧!
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JRadioButton2 implements ItemListener{
JFrame f=null;
JRadioButton r4=null;
JRadioButton r5=null;
JRadioButton2(){
f=new JFrame("JRadioButton2");
Container contentPane=f.getContentPane();
contentPane.setLayout(new GridLayout(2,1));
JPanel p1=new JPanel();
p1.setLayout(new GridLayout(1,3));
p1.setBorder(BorderFactory.createTitledBorder("你最喜歡哪一家快餐店呢?"));
JRadioButton r1=new JRadioButton("麥當勞");
JRadioButton r2=new JRadioButton("肯德基");
JRadioButton r3=new JRadioButton("21世紀");
p1.add(r1);
p1.add(r2);
p1.add(r3);
ButtonGroup bgroup1=new ButtonGroup();
bgroup1.add(r1);
bgroup1.add(r2);
bgroup1.add(r3);
JPanel p2=new JPanel();
p2.setLayout(new GridLayout(2,1));
p2.setBorder(BorderFactory.createTitledBorder("你最喜歡哪種程式語言，喜歡的請打勾:"));
r4=new JRadioButton("java",new ImageIcon(".//icons//x.jpg"));
r5=new JRadioButton("c++",new ImageIcon(".//icons//x.jpg"));
r4.addItemListener(this);
r5.addItemListener(this);
p2.add(r4);
p2.add(r5);
ButtonGroup bgroup2=new ButtonGroup();
bgroup2.add(r4);
bgroup2.add(r5);
contentPane.add(p1);
contentPane.add(p2);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
}
public void itemStateChanged(ItemEvent e){
if (e.getStateChange()==e.SELECTED){
if (e.getSource()==r4)
r4.setIcon(new ImageIcon(".//icons//r.jpg"));
if (e.getSource()==r5)
r5.setIcon(new ImageIcon(".//icons//r.jpg"));
}else{
if (e.getSource()==r4)
r4.setIcon(new ImageIcon(".//icons//x.jpg"));
if (e.getSource()==r5)
r5.setIcon(new ImageIcon(".//icons//x.jpg"));
}
}
public static void main(String[] args){
new JRadioButton2();
}
}
7-3:JList的使用:
類層次結構圖：
java.lang.Object
--java.awt.Component
--java.awt.Container
--javax.swing.JComponent
--javax.swing.JList
JList與JCheckBox有點相似，都可以讓你選擇一到多個選項，較不同的是，JList的選項方式是整列選取。我們先來看看JList
所提供的構造函數，友善迅速建立JList對象,如下所示:
JList構造函數:
JList():建立一個新的JList元件。
JList(ListModel dataModel):利用ListModel建立一個新的JList元件.
JList(Object[] listData):利用Array對象建立一個新的JList元件。
JList(Vector listData):利用Vector對象建立一個新的JList元件。
7-3-1:建立一般的JList:
一般我們若不需要在JList中加入Icon圖像，通常會用第3或第4個構造函數建立JList對象。而這兩個最大的不同在于使用Array對
象建立JList元件就無法改變項目的數量。對于項目數量經常改變的環境來說，以Vector對象來建立JList元件當然比較适合。例如
一個賣手機的店家，可能動不動就會有新手機上市，此時若用Array對象就不是很适當了!
我們來看個範例看怎麼構造一個簡單的JList吧！
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Vector;
public class JList1
{
public static void main(String args[])
{
JFrame f = new JFrame("JList");
Container contentPane = f.getContentPane();
contentPane.setLayout(new GridLayout(1,2));
String[] s = {"美國","日本","大陸","英國","法國"};
Vector v = new Vector();
v.addElement("Nokia 8850");
v.addElement("Nokia 8250");
v.addElement("Motorola V8088");
v.addElement("Motorola V3688x");
v.addElement("Panasonic GD92");
v.addElement("其他");
JList list1 = new JList(s);
list1.setBorder(BorderFactory.createTitledBorder("您最喜歡到哪個國家玩呢？"));
JList list2 = new JList(v);
list2.setBorder(BorderFactory.createTitledBorder("您最喜歡哪一種手機？"));
contentPane.add(new JScrollPane(list1));
contentPane.add(new JScrollPane(list2));
f.pack();
f.show();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
}
在這個範例中，當視窗變小時，JList并不會有滾動(ScrollBar)的效果，是以可能無法看到比較下面的選項。若我們要有滾動的
效果，必須将JList放入滾動面版中(JScrollPane),如我們在程式改為:
contentPane.add(new JScrollPane(list1));
contentPane.add(new JScrollPane(list2));
如此就有滾動的效果了，若我們要有多個選項呢？在JList中有3種選擇模式(Selection Mode)可供我們使用，分别是單一選擇、
連續區間選擇、與多重選擇。我們可以在ListSelectionModel這個interface中找到這3個常數值，如下:
static int SINGLE_SELECTION:一次隻能選擇一個項目。
static int SINGLE_INTERVAL_SELECTION:按住[shift]鍵，可以對某一邊續的項目作選取。
static int MULTIPLE_INTERVAL_SELECTION:沒有任何限制。可作單一選擇，連續區間選擇,或對不連續的項目作多重選擇(按
住[Ctrl]鍵)。多得選擇是java對JList的預設值，是以在上例中你可以在JList中作這3種模式的選擇方式。
設定選擇模式可以利用JList所提供的setSelectionMode(int selectionMode)方法。例如，若我們将上例改成如下:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Vector;
public class JList2
{
public static void main(String args[])
{
JFrame f = new JFrame("JList");
Container contentPane = f.getContentPane();
contentPane.setLayout(new GridLayout(1,3));
String[] s1 = {"美國","日本","大陸","英國","法國","意大利","澳洲","南韓"};
String[] s2 = {"範志毅","符兵","周甯","楊晨","高鋒","南方","其他"};
Vector v = new Vector();
v.addElement("Nokia 3310");
v.addElement("Nokia 8850");
v.addElement("Nokia 8250");
v.addElement("Motorola V8088");
v.addElement("Motorola V3688x");
v.addElement("Panasonic GD92");
v.addElement("Panasonic GD93");
v.addElement("NEC DB2100");
v.addElement("Alcatel OT500");
v.addElement("Philips Xenium [email protected] ");
v.addElement("Ericsson T29sc");
v.addElement("其他");
JList list1 = new JList(s1);
list1.setBorder(BorderFactory.createTitledBorder("您最喜歡到哪個國家玩呢？"));
JList list2 = new JList(s2);
list2.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
list2.setBorder(BorderFactory.createTitledBorder("您最喜歡哪個運動員呢？"));
JList list3 = new JList(v);
list3.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
list3.setBorder(BorderFactory.createTitledBorder("您最喜歡哪一種手機？"));
contentPane.add(new JScrollPane(list1));
contentPane.add(new JScrollPane(list2));
contentPane.add(new JScrollPane(list3));
f.pack();
f.show();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
}
7-3-2:利用ListModel構造JList:
ListModel是一個interface,主要的功能是定義一些方法，讓JList或JComboBox這些元件取得每個項目的值，并可限定項目的顯示
時機與方式，下面為ListModel這個interface所定義的方法:
ListModel interface定義的方法:
void addListDataListener(ListDataListener l):當data model的長度或内容值有任何改變時，利用此
方法就可以處理ListDataListener的事件。data model是vector或array的資料類型，裡面存放List
中的值。
Object getElementAt(int index):傳回在index位置的Item值。
int getSize():傳回List的長度。
void removeListDataListener(ListDataListener l):删除ListDataListener.
還記得我們一開始在介紹JList時所提到的構造函數嗎？其中有一個JList的構造函數是這樣的：
JList(ListModel dataModel)
是以我們必須實作ListModel所有的方法，才能利用上面這個構造函數建立JList.不過要實作ListModel所有的方法有點麻煩，因
為一般我們不會用到addListDataListener()與removeListDataListener()這兩個方法。是以java提供了AbstractListModel這個抽
象類，此抽象類實作了addListDataListener()與removeListDataListener()這兩個方法。若我們繼承AbstractListModel,就不需
實作這兩個方法，隻需要實作getElementAt()與getSize()方法即可，我們來看下面的範例:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JList3{
public JList3(){
JFrame f=new JFrame("JList");
Container contentPane=f.getContentPane();
ListModel mode=new DataModel();
JList list=new JList(mode);//利用ListModel建立一個JList.
list.setVisibleRowCount(5);//設定程式一打開時所能看到的資料項個數。
list.setBorder(BorderFactory.createTitledBorder("你最喜歡到哪個國家玩呢?"));
contentPane.add(new JScrollPane(list));
f.pack();
f.show();
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
}
public static void main(String[] args){
new JList3();
}
}
class DataModel extends AbstractListModel{
String[] s={"美國","越南","大陸","英國","法國","大陸","意大利","澳洲"};
public Object getElementAt(int index){//getxElementAt()方法中的參數index,系統會自動由0開始計算,不過要自己作累加
//的操作.
return (index+1)+"."+s[index++];
}
public int getSize(){
return s.length;
}
}
事實上,java本身還提供另一個類，DefaultListModel實體類。此類繼承了AbstractListModel抽象類，并實作裡面所有的抽象方
法，是以你不需要再自行實作任何的方法，可以說是相當的友善。不過既然所有的抽象都已經被實作，是以在設計的彈性上就會有
有所降低。若你是喜歡自行管理JList項目的設計者，你可以不要使用DefaultListModel這個類，隻需要在AbstractListModel上多
下功夫即可。
下面的例子我們改寫上面的例子，直接使用DefaultListModel類：
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Vector;
public class JList4
{
public JList4()
{
JFrame f = new JFrame("JList");
Container contentPane = f.getContentPane();
ListModel mode = new DataModel();
JList list = new JList(mode);
list.setVisibleRowCount(5);
list.setBorder(BorderFactory.createTitledBorder("您最喜歡到哪個國家玩呢？"));
contentPane.add(new JScrollPane(list));
f.pack();
f.show();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String args[])
{
new JList4();
}
}
class DataModel extends DefaultListModel
{
String[] s = {"美國"," 日本","大陸","英國","法國","意大利","澳洲","南韓"};
DataModel()
{
for(int i=0; i < s.length; i++)
addElement((i+1)+"."+s[i]);
}
}
程式運作結果與上個範例相同。
好奇怪，這不是跟我們使用Vector方式，利用JList(Vector v)構造函數來建立新的JList一樣嗎?如同JList1.java中的例子，為
什麼還要多此一舉呢?其實若讀者去檢視DefaultListModel類，可發現此類提供不少好用的方法，例如你可以随意的增加一個項目(
addElement())、或是删除一個項目(removeElement)、甚至你可以很友善地做到查詢(getElementAt())與彙出(copyInto())項目的
操作。你可以發現，利用DefaultListModel可以直接動态地更改JList的項目值，而不需要自行産生一個Vecotr對象;相對于JList(
Vector v)這個構造函數，可說更友善且實用許多.
至于利用ListModel或AbstractListModel來構造JList有什麼好處？讀者隻要這麼想，ListModel中文就是“列出模式”，那麼每
個老師都會有自己開課的學生成績，老師應該可以看到每個同學的成績，而深長應該隻能看到自己的成績，是以我們就會有兩種不
同的“列出模式”。我們隻需要去改寫getElementAt()方法，就會有不同的列出模式産生，如下面的範例：
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Vector;
public class JList5
{
public JList5()
{
JFrame f = new JFrame("JList");
Container contentPane = f.getContentPane();
contentPane.setLayout(new GridLayout(1,2));
ListModel mode = new DataModel(1);
JList list1 = new JList(mode);
list1.setVisibleRowCount(5);
list1.setBorder(BorderFactory.createTitledBorder("您玩過哪些軟體？"));
mode = new DataModel(2);
JList list2 = new JList(mode);
list2.setBorder(BorderFactory.createTitledBorder("您玩過哪些資料庫軟體？"));
contentPane.add(new JScrollPane(list1));
contentPane.add(new JScrollPane(list2));
f.pack();
f.show();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String args[])
{
new JList5();
}
}
class DataModel extends AbstractListModel
{
String[] s = {"MS SQL","MySQL","IBM DB2","ORACLE","Windows 2000","Linux","UNix","OS2"};
int flag;
DataModel(int flag)
{
this.flag = flag;
}
public Object getElementAt(int index)
{
String tmp = null;
if (flag == 1)
tmp = (index+1)+"."+s[index++];
if (flag == 2)
{
if(index < 4)
tmp = (index+1)+"."+s[index++];
}
return tmp;
}
public int getSize()
{
return s.length;
}
}
7-3-3:建立有圖像的JList:
我們也可以在JList中加入Icon圖像，不過JList加入圖像比較麻煩一點，不像JLabel或JButton那樣簡單。要在JList上加入Icon,
要先了解ListCellRenderer interface.我們必須由這個interface所定義的方法，将圖像畫在JList中的每個項目。
ListCellRenderer interface裡隻定義了一個方法，那就是getListCellRendererComponent,不過這個參數有點多，我們把它列出來
看看:
public Component getListCellRendererComponent(JList list,
Object value,
int index,
boolean isSelected,
boolean cellHasFocus)
list:即所要畫上的圖像的JList元件。
value:JList項目值，如list.getModel().getElementAt(index)所傳回的值。
index:為JList項目的索引值，由0開始。
isSelected與cellHasFocus:判斷JList中的項目是否有被選取或是有焦點置入。
上面這4個參數會在你設定JList的繪圖樣式(setCellRenderer())時自動的由JList元件提供，你隻要關心怎麼控制
getListCellRendererComponent()方法中的4個參數，而無需擔心怎麼參數傳入。
要在JList中加入Icon圖像的技巧就是将JList中的每一個項目當作是JLabel,因為JLabel在使用文字與圖像上非常的友善，要設定
JList的圖像，必須使用setCellRenderer(ListCellRenderer cellRenderer)這個方法。我們來看下面這個範例，你就能明白了!
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Vector;
public class JList6
{
public JList6()
{
String[] s = {"西瓜","蘋果","草莓","香蕉","葡萄"};
JFrame f = new JFrame("JList");
Container contentPane = f.getContentPane();
JList list1 = new JList(s);
list1.setBorder(BorderFactory.createTitledBorder("您喜歡吃哪些水果？"));
list1.setCellRenderer(new CellRenderer());
contentPane.add(new JScrollPane(list1));
f.pack();
f.show();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String args[])
{
new JList6();
}
}
class CellRenderer extends JLabel implements ListCellRenderer
{
CellRenderer()
{
setOpaque(true);
}
public Component getListCellRendererComponent(JList list,
Object value,
int index,
boolean isSelected,
boolean cellHasFocus)
{
if (value != null)
{
setText(value.toString());
setIcon(new ImageIcon(".//icons//fruit"+(index+1)+".jpg"));
}
if (isSelected) {
setBackground(list.getSelectionBackground());
setForeground(list.getSelectionForeground());
}
else {
//設定選取與取消選取的前景與背景顔色.
setBackground(list.getBackground());
setForeground(list.getForeground());
}
return this;
}
}
7-3-4:JList的事件處理:
JList的事件處理一般可分為兩種:一種是取得使用者選取的項目;另一種是在JList的項目上輕按兩下滑鼠兩次，運作相對應的工作。我
們先來看第一種事件處理方式:
在JList類中有addListSelectionListener()方法,可以檢測使用者是否對JList的選取有任何的改變。ListSelectionListener
interface中隻有定義一個方法，那就是valueChanged(ListSelectionEvent e),我們必須實作這個方法，才能在使用者改變選取值時
取得使用者最後的選取狀态。我們來看一下的例子: 這個例子勻們抓取使用者所選取的項目，并将所選的項目顯示在JLabel上。
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;//由于ListSelectionEvent是swing的事件，不是awt的事件，是以我們必須import
//javax.swing.event.*。
public class JList7 implements ListSelectionListener
{
JList list = null;
JLabel label = null;
String[] s = {"美國","日本","大陸","英國","法國","意大利","澳洲","南韓"};
public JList7()
{
JFrame f = new JFrame("JList");
Container contentPane = f.getContentPane();
contentPane.setLayout(new BorderLayout());
label = new JLabel();
list = new JList(s);
list.setVisibleRowCount(5);
list.setBorder(BorderFactory.createTitledBorder("您最喜歡到哪個國家玩呢？"));
list.addListSelectionListener(this);
contentPane.add(label,BorderLayout.NORTH);
contentPane.add(new JScrollPane(list),BorderLayout.CENTER);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String args[])
{
new JList7();
}
public void valueChanged(ListSelectionEvent e)
{
int tmp = 0;
String stmp = "您目前選取：";
int[] index = list.getSelectedIndices();//利用JList類所提供的getSelectedIndices()方法可得到使用者所選取的所有
for(int i=0; i < index.length ; i++)//index值，這些index值由一個int array傳回.
{
tmp = index[i];
stmp = stmp+s[tmp]+" ";
}
label.setText(stmp);
}
}
接下來，我們來看如何處理在JList上輕按兩下滑鼠的操作。由于JList本身并無提供這樣的EventListener,是以我們必須利用
MouseListener來達到捕獲輕按兩下滑鼠的事件。至于要怎麼知道我們到底在哪個項目上輕按兩下滑鼠呢？我們可以利用JList類所提供的
LocatToindex()方法得知。以下為我們所舉的範例:
這個例子一開始左邊列有國這名稱，當你在某個國家名稱上輕按兩下滑鼠，這個國家名稱就會移到右邊去，反之亦同。
1.這個範例我們應用DefaultListModel類，因主DefaultListModel類實作了Vector中的方法，使我們在處理動态的JList項目值
比較容易.
2.由于我們要處理滑鼠事件，為了編寫友善，在程式中我們繼承MouseAdapte抽象類.
3.在程式中，我們建立兩個DataModel，第一個JList,也就是list1一開始時會将String Array s中的所有值依次放入list1的項
目中，而list2一開始為空白。
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
public class JList8 extends MouseAdapter{
JList list1=null;
JList list2=null;
DefaultListModel mode1=null;
DefaultListModel mode2=null;
String[] s = {"美國","日本","大陸","英國","法國","意大利","澳洲","南韓"};
public JList8(){
JFrame f=new JFrame("JList");
Container contentPane=f.getContentPane();
contentPane.setLayout(new GridLayout(1,2));
mode1=new DataModel(1);
list1=new JList(mode1);
list1.setBorder(BorderFactory.createTitledBorder("國家名稱!"));
list1.addMouseListener(this);//一遇到滑鼠事件立即執行.
mode2=new DataModel(2);
list2=new JList(mode2);
list2.setBorder(BorderFactory.createTitledBorder("你最喜歡到哪個國家玩呢!"));
list2.addMouseListener(this);//一遇到滑鼠事件立即執行.
contentPane.add(new JScrollPane(list1));
contentPane.add(new JScrollPane(list2));
f.pack();
f.show();
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
}
public static void main(String[] args){
new JList8();
}
//處理滑鼠鍵擊事件.
public void mouseClicked(MouseEvent e){
int index;
if (e.getSource()==list1){
if (e.getClickCount()==2){
index=list1.locationToIndex(e.getPoint());
String tmp=(String)mode1.getElementAt(index);
mode2 .addElement(tmp);
list2.setModel(mode2);
mode1.removeElementAt(index);
list1.setModel(mode1);
}
}
if (e.getSource()==list2){
if (e.getClickCount()==2){
index=list2.locationToIndex(e.getPoint());
String tmp=(String)mode2.getElementAt(index);
mode1 .addElement(tmp);
list1.setModel(mode1);
mode2.removeElementAt(index);
list2.setModel(mode2);
}
}
}
class DataModel extends DefaultListModel{
DataModel(int flag){
if (flag==1){
for (int i=0;i<s.length;i++) addElement(s[i]);
}
}
}
}
7-4:JComboBox的使用：
類層次結構圖：
java.lang.Object
--java.awt.Component
--java.awt.Container
--javax.swing.JComponent
--javax.swing.JComboBox
構造函數：
JComboBox():建立一個新的JComboBox元件。
JComboBox(ComboBoxModel aModel):用ListModel建立一個新的JComboBox元件。
JComboBox(Object[] items):利用Array對象建立一個新的JComboBox元件。
JComboBox(Vector items):利用Vector對象建立一個新的JComboBox元件。
7-4-1:建立一般的JComboBox:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Vector;
public class JComboBox1{
public static void main(String[] args){
JFrame f=new JFrame("JComboBox1");
Container contentPane=f.getContentPane();
contentPane.setLayout(new GridLayout(1,2));
String[] s = {"美國","日本","大陸","英國","法國","意大利","澳洲","南韓"};
Vector v=new Vector();
v.addElement("Nokia 8850");
v.addElement("Nokia 8250");
v.addElement("Motorola v8088");
v.addElement("Motorola v3850");
v.addElement("Panasonic 8850");
v.addElement("其它");
JComboBox combo1=new JComboBox(s);
combo1.addItem("中國");//利用JComboBox類所提供的addItem()方法，加入一個項目到此JComboBox中。
combo1.setBorder(BorderFactory.createTitledBorder("你最喜歡到哪個國家玩呢?"));
JComboBox combo2=new JComboBox(v);
combo2.setBorder(BorderFactory.createTitledBorder("你最喜歡哪一種手機呢？"));
contentPane.add(combo1);
contentPane.add(combo2);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
}
}
7-4-2:利用ComboModel構造JComboBox:
如同JList一般，在JComboBox中也有一個構造函數是利用某種Model來構造。如下所示:
JComboBox(COmboBoxModel aModel)
ComboBoxModel是一個interface,裡面定義了兩個方法，分别是setSelectedItem()與getSelectedItem().這兩個方法目的是讓用
戶選取某個項目後，可正确地顯示出使用者所選取的項目。下面是這兩個方法的詳細定義:
ComboBoxModel interface定義的方法：
Object getSelectedItem():傳回所選取的項目值。
Void setSelectedItem(Object anItem):設定所選取的項目值.
與JList不同的是，JComboBox是利用ComboBoxModel,而不是ListModel.不過ComboBoxModel interface是繼承ListModel interface
,是以若我們要利用ComboBoxModel來構造JComboBox,除了要實作ComboBoxModel的兩個方法外，還必須實作ListModel的所定義的4個
方法，這樣的做法可說相當麻煩。
在介紹JList時我們曾經提到AbstractListModel這個抽象類。這個抽象類實作了ListModel interface中的addListDataListener
()、removeListDataListener()這兩個方法。是以若我們繼承AbstractListModel,則可少掉實作這兩個方法，隻需要實作
getElementAt()、getSize()、setSelectedItem()與getSelectedItem()這4個方法。這樣的作法就顯得比較簡單一點.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JComboBox2{
String[] s= {"美國","日本","大陸","英國","法國","意大利","澳洲","南韓"};
public JComboBox2(){
JFrame f=new JFrame("JComboBox2");
Container contentPane=f.getContentPane();
ComboBoxModel mode=new UserDefineComboBoxModel();
JComboBox combo=new JComboBox(mode);
combo.setBorder(BorderFactory.createTitledBorder("你最喜歡到哪個國家去玩?"));
contentPane.add(combo);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
}
public static void main(String[] args){
new JComboBox2();
}
class UserDefineComboBoxModel extends AbstractListModel implements ComboBoxModel{
String item=null;
public Object getElementAt(int index){
return s[index++];
}
//由于繼承AbstractListModel抽象類。是以我們分别在程式中實作了getElementAt()與getSize()方法。
public int getSize(){
return s.length;
}
//由于我們實作了ComboBoxModel interface.是以我們必須在程式中實作setSelectedItem()與getSelectedItem()方法.
public void setSelectedItem(Object anItem){
item=(String)anItem;
}
public Object getSelectedItem(){
return item;
}
}
}
當程式要show出JComboBox時，系統會先自動調用getSize()方法，看看這個JComboBox長度有多少，然後再調用getElementAt()
方法，将String Array s中的值填入JComboBox中。當使用者選擇項目時，系統會調用getSelectedItem()方法，傳回所選取的項目，并
利用setSelectedItem()方法，将選取項目放在JComboBox最前端。
getElementAt()方法中的“index”參數，系統會自動由0計算，不過要自己作累加的操作，如程式中:
return s[index++];
如同JList一般，java對于JComboBox也提供了另一個類，DefaultComboBoxModel實體類。此類繼承了AbstractListModel抽象類，也
實作了ComboBoxModel interface.是以你不需要再實作getSize()、getElementAt()、setSelectedItem()與getSelectedItem()方法。
利用DefaultComboBoxModel這個類我們可以很友善地做到動态更改JComboBox的項目值。當你沒有必要自己定義特殊的ComboBoxModel
時，使用DefaultComboBoxModel就顯得非常的友善，我們來看下面的例子:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JComboBox3{
String[] s = {"美國","日本","大陸","英國","法國","意大利","澳洲","南韓"};
public JComboBox3(){
JFrame f=new JFrame("JComboBox3");
Container contentPane=f.getContentPane();
ComboBoxModel mode=new AModel();
JComboBox combo=new JComboBox(mode);
combo.setBorder(BorderFactory.createTitledBorder("您最喜歡到哪個國家玩呢？"));
contentPane.add(combo);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
}
public static void main(String[] args){
new JComboBox3();
}
class AModel extends DefaultComboBoxModel{
AModel(){
for (int i=0;i<s.length;i++)
addElement(s[i]);
}
}
}
1.由于AModel繼承DefaultComboBoxModel實體類，由AModel可得到一個ComboBoxModel實體對象。
2.我們使AModel繼承DefaultComboBoxModel實體類，是以就不需要再實作getElementAt()、getSize()、setSelectedItem()與
getSelectedItem()這4個方法，直接将所要的項目用addElement()方法加入即可。系統會自動将所加入的項目放進一個Vector
中，并在輸出JComboBox時自動調用getSize()與getElementAt()方法。
7-4-3:建立有圖像的JComboBox:
在上一節中我們利用ListCellRenderer interface在JList中加入Icon圖像，而要在JComboBox中加入圖像的方法也是一樣的。
我們必須實作ListCellRenderer interface所定義的方法getListCellRendererComponent.以下為這個方法的定義：
要先了解ListCellRenderer interface.我們必須由這個interface所定義的方法，将圖像畫在JComboBox中的每個項目。
ListCellRenderer interface裡隻定義了一個方法，那就是getListCellRendererComponent,不過這個參數有點多，我們把它列出來
看看:
public Component getListCellRendererComponent(JList list,
Object value,
int index,
boolean isSelected,
boolean cellHasFocus)
list:即所要畫上的圖像的JComboBox元件。
value:JComboBox項目值，如JComboBox.getModel().getElementAt(index)所傳回的值。
index:為JComboBox項目的索引值，由0開始。
isSelected與cellHasFocus:判斷JComboBox中的項目是否有被選取或是有焦點置入。
上面這4個參數會在你設定JComboBox的繪圖樣式(setCellRenderer())時自動的由JComboBox元件提供，你隻要關心怎麼控制
getListCellRendererComponent()方法中的4個參數，而無需擔心怎麼參數傳入。
要在JList中加入Icon圖像的技巧就是将JComboBox中的每一個項目當作是JLabel,因為JLabel在使用文字與圖像上非常的友善，要設定JComboBox的圖像，
必須使用setRenderer(ListCellRenderer cellRenderer){注:我們在JList中畫上圖像是利用JList所提供的setCellRenderer(ListCellRenderer
cellRenderer)方法,讀者請小心}這個方法。我們來看下面這個範例，你就能明白了!
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JComboBox4{
String[] s={"西瓜","蘋果","草莓","香蕉","葡萄"};
public JComboBox4(){
JFrame f=new JFrame("JComboBox");
Container contentPane=f.getContentPane();
JComboBox combo=new JComboBox(s);
combo.setBorder(BorderFactory.createTitledBorder("你最喜歡吃哪些水果?"));
combo.setRenderer(new ACellRenderer());
combo.setMaximumRowCount(3);
contentPane.add(combo);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
}
public static void main(String[] args){
new JComboBox4();
}
}
class ACellRenderer extends JLabel implements ListCellRenderer{
ACellRenderer(){
setOpaque(true);
}
public Component getListCellRendererComponent(JList list,
Object value,
int index,
boolean isSelected,
boolean cellHasFocus){
if (value!=null){
setText(value.toString());
setIcon(new ImageIcon(".//icons//fruit"+(index+1)+".jpg"));
}
if (isSelected){
setBackground(list.getSelectionBackground());
setForeground(list.getSelectionForeground());
}else{
setBackground(list.getBackground());
setForeground(list.getForeground());
}
return this;
}
}
各們讀者在運作這個程式時會發現，即使JComboBox的選項中有圖示，但在選後圖示卻不會顯示在顯示列中，原因是在上面程式中
我們以String Array s建立JComboBox:
JComboBox combo=new JComboBox(s);
String Array s裡面放的隻是水果名稱，而并沒有圖示。當我們使用setRenderer()方法來JComboBox時，隻會繪制JComboBox的
選項部份，而最後顯示在JComboBox上的值還是以String Array s為依據。是以JComboBox顯示列就隻會顯示文字而已，而不會顯示出
圖形。要解決這個問題，我們必須改變JComboBox所傳入的參數内容，也就是将原來的String Array s更改成具有圖形的資料項。在
此我們是利用JComboBox(Object[] items)來建立有圖像的JComboBox,我們所傳進去的Object Array不應該隻有文字，而必須連圖示一
并傳入。我們修改上個範例修改如下:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JComboBox5
{
String[] s = {"西瓜","蘋果","草莓","香蕉","葡萄"};
ImageIcon[] icons = new ImageIcon[5];;
public JComboBox5()
{
JFrame f = new JFrame("JComboBox");
Container contentPane = f.getContentPane();
ItemObj[] obj = new ItemObj[5];
for(int i=0; i < 5; i++)
{
icons[i] = new ImageIcon(".//icons//fruit"+(i+1)+".jpg");
obj[i] = new ItemObj(s[i],icons[i]);
}
JComboBox combo = new JComboBox(obj);//利用ItemObj Array obj當作是JComboBox的參數傳入，構造出JComboBox.
combo.setBorder(BorderFactory.createTitledBorder("您喜歡吃哪些水果？"));
combo.setRenderer(new ACellRenderer());
combo.setMaximumRowCount(3);
contentPane.add(combo);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String args[])
{
new JComboBox5();
}
}
class ItemObj
{
String name;
ImageIcon icon;
public ItemObj(String name, ImageIcon icon){
this.name = name;
this.icon = icon;
}
}
class ACellRenderer extends JLabel implements ListCellRenderer
{
ACellRenderer()
{
setOpaque(true);
}
public Component getListCellRendererComponent(JList list,
Object value,
int index,
boolean isSelected,
boolean cellHasFocus)
{
if (value != null)
{
setText(((ItemObj)value).name);
setIcon(((ItemObj)value).icon);
}
if (isSelected) {
setBackground(list.getSelectionBackground());
setForeground(list.getSelectionForeground());
}
else {
setBackground(list.getBackground());
setForeground(list.getForeground());
}
return this;
}
}
你可以發現，第一欄顯示有圖示顯示出來了。當然你也可以利用ComboBoxModel方式來構造出有圖示的JComboBox.我們來看下面
的例子:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JComboBox6{
String[] s={"西瓜","蘋果","草莓","香蕉","葡萄"};
ImageIcon[] icons=new ImageIcon[5];
public JComboBox6(){
JFrame f=new JFrame("JComboBox");
Container contentPane=f.getContentPane();
for(int i=0; i < 5; i++)
{
icons[i] = new ImageIcon(".//icons//fruit"+(i+1)+".jpg");
}
ComboBoxModel mode=new AModel();
JComboBox combo=new JComboBox(mode);
combo.setBorder(BorderFactory.createTitledBorder("您喜歡吃哪些水果？"));
combo.setRenderer(new ACellRenderer());
combo.setMaximumRowCount(3);
contentPane.add(combo);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String[] args){
new JComboBox6();
}
class AModel extends DefaultComboBoxModel{
AModel(){
for (int i=0;i<s.length;i++){
ItemObj obj=new ItemObj(s[i],icons[i]);
addElement(obj);
}
}
}
}
class ItemObj
{
String name;
ImageIcon icon;
public ItemObj(String name, ImageIcon icon){
this.name = name;
this.icon = icon;
}
}
class ACellRenderer extends JLabel implements ListCellRenderer
{
ACellRenderer()
{
setOpaque(true);
}
public Component getListCellRendererComponent(JList list,
Object value,
int index,
boolean isSelected,
boolean cellHasFocus)
{
if (value != null)
{
setText(((ItemObj)value).name);
setIcon(((ItemObj)value).icon);
}
if (isSelected) {
setBackground(list.getSelectionBackground());
setForeground(list.getSelectionForeground());
}
else {
setBackground(list.getBackground());
setForeground(list.getForeground());
}
return this;
}
}
我們用JComboBox(ComboBoxModel aModel)來構造圖示的JComboBox,是以我們在程式中編寫一個繼承DefaultComboBoxModel的
ComboBoxModel.
7-4-4:建立可自行輸入的JComboBox:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JComboBox7
{
String[] fontsize = {"12","14","16","18","20","22","24","26","28"};
String defaultMessage = "請選擇或直接輸入文字大小！";
public JComboBox7()
{
JFrame f = new JFrame("JComboBox");
Container contentPane = f.getContentPane();
JComboBox combo = new JComboBox(fontsize);
combo.setBorder(BorderFactory.createTitledBorder("請選擇你要的文字大小"));
combo.setEditable(true);//将JComboBox設成是可編輯的.
ComboBoxEditor editor = combo.getEditor();//getEditor()方法傳回ComboBoxEditor對象,如果你檢視手冊，你就會發
//現ComboBoxEditor是個接口(interface),是以你可以自行實作這個接口，制作自己想要的ComboBoxEditor元件。但通常
//我們不需要這麼做，因為預設的ComboBoxEditor是使用JTextField,這已經足夠應付大部份的情況了。
//configureEditor()方法會初始化JComboBox的顯示項目。例如例子中一開始就出現:"請選擇或直接輸入文字大小！"這個
//字元串。
combo.configureEditor(editor, defaultMessage);
contentPane.add(combo);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String args[])
{
new JComboBox7();
}
}
7-4-5:JComboBox的事件處理:
JComboBox的事件處理亦可分為兩種，一種是取得使用者選取的項目;另一種是使用者在JComboBox上自行輸入完畢後按下[Enter]鍵,
運作相對應的工作。對于第一種事件的處理，我們使用ItemListener.對于第二種事件的處理，我們使用ActionListener.
這個範例使用者可以選取所要的字号，字号的變化會呈現在JLabel上，并可讓使用者自行輸入字型的大小。當使用者按下[Enter]鍵後
，若使用者輸入的值不在選項上時，此輸入值會增加至JComboBox中，并将輸入字型的大小顯示在JLabel上。
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JComboBox8 implements ItemListener,ActionListener{
String[] fontsize={"12","14","16","18","20","22","24","26","28"};
String defaultMessage="請選擇或直接輸入文字大小!";
Font font=null;
JComboBox combo=null;
JLabel label=null;
public JComboBox8(){
JFrame f=new JFrame("JComboBox");
Container contentPane=f.getContentPane();
contentPane.setLayout(new GridLayout(2,1));
label=new JLabel("Swing",JLabel.CENTER);
font=new Font("SansSerif",Font.PLAIN,12);
label.setFont(font);
combo=new JComboBox(fontsize);
combo.setBorder(BorderFactory.createTitledBorder("請選擇你要的文字大小:"));
combo.setEditable(true);
ComboBoxEditor editor=combo.getEditor();
combo.configureEditor(editor,defaultMessage);
combo.addItemListener(this);0
combo.addActionListener(this);
contentPane.add(label);
contentPane.add(combo);
f.pack();
f.show();
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
}
public static void main(String[] args){
new JComboBox8();
}
public void actionPerformed(ActionEvent e){
boolean isaddItem=true;
int fontsize=0;
String tmp=(String)combo.getSelectedItem();
//判斷使用者所輸入的項目是否有重複，若有重複則不增加到JComboBox中。
try{
fontsize=Integer.parseInt(tmp);
for(int i=0;i<combo.getItemCount();i++){
if (combo.getItemAt(i).equals(tmp)){
isaddItem=false;
break;
}
}
if (isaddItem){
combo.insertItemAt(tmp,0);//插入項目tmp到0索引位置(第一列中).
}
font=new Font("SansSerif",Font.PLAIN,fontsize);
label.setFont(font);
}catch(NumberFormatException ne){
combo.getEditor().setItem("你輸入的值不是整數值，請重新輸入!");
}
}
public void itemStateChanged(ItemEvent e){//ItemListener界面隻有itemStateChanged()一個方法，在此實作它。
if (e.getStateChange()==ItemEvent.SELECTED){//當使用者的選擇改變時，則在JLabel上會顯示出Swing目前字形大小資訊.
int fontsize=0;
try{
fontsize=Integer.parseInt((String)e.getItem());
label.setText("Swing 目前字形大小:"+fontsize);
}catch(NumberFormatException ne){//若所輸入的值不是整數，則不作任何的操作.
}
}
}
}
![Java String.format方法的簡單使用[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)