16.Swing程序設計
1.Swing概述--Swing主要用來開發GUI程序，GUI即圖形圖像界面，他是應用程序提供給用戶操作的圖形界面，包括窗口、菜單、按鈕等元素。
1.1Swing的特點--允許開發人員跨平臺時指定統一的外觀和風格，Swing不依賴操作系統，可以在多平臺上使用，將Swing組件稱爲‘輕量級組件’AWT組件則相反比較依賴本地操作系統，所以被稱爲‘重量級組件’
1.2Swing包
1.3常用Swing組件
2常用窗體
2.1JFrame窗體--是一個容器，是Swing程序中各組件的載體
JFrame類的常用構造方法：
1）public JFrame():創建一個不可見、沒有標題的新窗體。
2）public JFrame(String title):創建一個不可見但有標題的窗體
jJFrame常用方法
代碼實現：
public classJFreamTest extends JFrame {
publicvoid CreateJFrame(String title) { // 定義一個CreateJFrame()方法
JFramejf = new JFrame(title); // 創建一個JFrame對象
Containercontainer = jf.getContentPane(); // 獲取一個容器
JLabeljl = new JLabel("這是一個JFrame窗體"); // 創建一個JLabel標籤
//使標籤上的文字居中
jl.setHorizontalAlignment(SwingConstants.CENTER);
container.add(jl);// 將標籤添加到容器中
container.setBackground(Color.white);// 設置容器的背景顏色
jf.setVisible(true);// 使窗體可視
jf.setSize(200,150); // 設置窗體大小
//設置窗體關閉方式
jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
publicstatic void main(String args[]) { // 在主方法中調用CreateJFrame()方法
newJFreamTest().CreateJFrame("創建一個JFrame窗體");
}
}
運行結果：
2.2JDialog對話框窗體--是Swing組件中的對話框，功能是從一個窗體中實例化。
常用Jdialog構造類
代碼實現：
class MyJDialog extends JDialog { // 創建新類繼承JDialog類
privatestatic final long serialVersionUID = 1L;
publicMyJDialog(MyFrame frame) {
//實例化一個JDialog類對象，指定對話框的父窗體、窗體標題和類型
super(frame,"第一個JDialog窗體", true);
Containercontainer = getContentPane(); // 創建一個容器
container.add(newJLabel("這是一個對話框")); // 在容器中添加標籤
setBounds(120,120, 100, 100); // 設置對話框窗體大小
}
}
public class MyFrame extends JFrame { //創建新類
privatestatic final long serialVersionUID = 1L;
publicstatic void main(String args[]) {
newMyFrame(); // 實例化MyJDialog類對象
}
publicMyFrame() {
Containercontainer = getContentPane(); // 創建一個容器
container.setLayout(null);
JLabeljl = new JLabel("這是一個JFrame窗體"); // 在窗體中設置標籤
//將標籤的文字置於標籤中間位置
jl.setHorizontalAlignment(SwingConstants.CENTER);
container.add(jl);
JButtonbl = new JButton("彈出對話框"); // 定義一個按鈕
bl.setBounds(10,10, 100, 21);
bl.addActionListener(newActionListener() { // 爲按鈕添加鼠標單擊事件
publicvoid actionPerformed(ActionEvent e) {
//使MyJDialog窗體可見
newMyJDialog(MyFrame.this).setVisible(true);
}
});
container.add(bl);// 將按鈕添加到容器中
container.add(bl);
container.setBackground(Color.white);
setSize(200,200);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
setVisible(true);
}
}
運行結果：
3常用佈局管理器：
3.1絕對佈局--硬性指定組件在容器中的位置和大小，可以使用絕對座標來指定組件的位置。
代碼實現：
public classAbsolutePosition extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicAbsolutePosition() {
setTitle("本窗體使用絕對佈局");// 設置該窗體的標題
setLayout(null);// 使該窗體取消佈局管理器設置
setBounds(0,0, 200, 150); // 絕對定位窗體的位置與大小
Containerc = getContentPane(); // 創建容器對象
JButtonb1 = new JButton("按鈕1"); // 創建按鈕
JButtonb2 = new JButton("按鈕2"); // 創建按鈕
b1.setBounds(10,30, 80, 30); // 設置按鈕的位置與大小
b2.setBounds(60,70, 100, 20);
c.add(b1);// 將按鈕添加到容器中
c.add(b2);
setVisible(true);// 使窗體可見
//設置窗體關閉方式
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
publicstatic void main(String[] args) {
newAbsolutePosition();
}
}
運行結果：
3.2流佈局--最基本的佈局管理器，在整個容器中的佈局正如其名，像‘流’一樣從左到右擺放組件，知道佔據這一行的所有空間，在向下移動一行。
代碼實現：
public classFlowLayoutPosition extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicFlowLayoutPosition() {
setTitle("本窗體使用流佈局管理器");// 設置窗體標題
Containerc = getContentPane();
//設置窗體使用流佈局管理器，使組件右對齊，並且設置組件之間的水平間隔與垂直間隔
setLayout(newFlowLayout(2, 10, 10));
for(int i = 0; i < 10; i++) { // 在容器中循環添加10個按鈕
c.add(newJButton("button" + i));
}
setSize(300,200); // 設置窗體大小
setVisible(true);// 設置窗體可見
//設置窗體關閉方式
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
publicstatic void main(String[] args) {
newFlowLayoutPosition();
}
}
運行結果：
3.3邊界佈局--默認不指定窗體佈局時，Swing指定的佈局模式是邊界佈局
代碼實現：
public classBorderLayoutPosition extends JFrame {
publicBorderLayoutPosition() {
setTitle("這個窗體使用邊界佈局管理器");
Containerc = getContentPane(); // 定義一個容器
setLayout(newBorderLayout()); // 設置容器爲邊界佈局管理器
JButtoncenterBtn = new JButton("中"),
northBtn= new JButton("北"),
southBtn= new JButton("南"),
westBtn= new JButton("西"),
eastBtn= new JButton("東");
c.add(centerBtn,BorderLayout.CENTER);// 中部添加按鈕
c.add(northBtn,BorderLayout.NORTH);// 北添加按鈕
c.add(southBtn,BorderLayout.SOUTH);// 南部添加按鈕
c.add(westBtn,BorderLayout.WEST);// 西部添加按鈕
c.add(eastBtn,BorderLayout.EAST);// 東部添加按鈕
setSize(350,200); // 設置窗體大小
setVisible(true);// 設置窗體可見
//設置窗體關閉方式
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
publicstatic void main(String[] args) {
newBorderLayoutPosition();
}
}
運行結果：
3.4網格佈局--將容器劃分爲網格，所有組件可以按行和列進行排列
網格佈局主要有以下兩個構造方法
1）public GridLayout（int rows，int columns）方法。
2）public GridLayout（int rows，int columns，int horizGap，int vertGap）方法。
代碼實現：
public classGridLayoutPosition extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicGridLayoutPosition() {
Containerc = getContentPane();
//設置容器使用網格佈局管理器，設置7行3列的網格
setLayout(newGridLayout(7, 3, 5, 5));
for(int i = 0; i < 20; i++) {
c.add(newJButton("button" + i)); // 循環添加按鈕
}
setSize(300,300);
setTitle("這是一個使用網格佈局管理器的窗體");
setVisible(true);
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
publicstatic void main(String[] args) {
newGridLayoutPosition();
}
}
運行結果
4常用面板
4.1JPanel面板--是一種容器，他繼承java.awt.Container類。
代碼實現：
public classJPanelTest extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicJPanelTest() {
Containerc = getContentPane();
//將整個容器設置爲2行1列的網格佈局
c.setLayout(newGridLayout(2, 1, 10, 10));
//初始化一個面板，設置1行3列的網格佈局
JPanelp1 = new JPanel(new GridLayout(1, 3, 10, 10));
JPanelp2 = new JPanel(new GridLayout(1, 2, 10, 10));
JPanelp3 = new JPanel(new GridLayout(1, 2, 10, 10));
JPanelp4 = new JPanel(new GridLayout(2, 1, 10, 10));
p1.setBorder(BorderFactory.createTitledBorder("面板1"));
p2.setBorder(BorderFactory.createTitledBorder("面板2"));
p3.setBorder(BorderFactory.createTitledBorder("面板3"));
p4.setBorder(BorderFactory.createTitledBorder("面板4"));
p1.add(newJButton("1")); // 在面板中添加按鈕
p1.add(newJButton("1"));
p1.add(newJButton("2"));
p1.add(newJButton("3"));
p2.add(newJButton("4"));
p2.add(newJButton("5"));
p3.add(newJButton("6"));
p3.add(newJButton("7"));
p4.add(newJButton("8"));
p4.add(newJButton("9"));
c.add(p1);// 在容器中添加面板
c.add(p2);
c.add(p3);
c.add(p4);
setTitle("在這個窗體中使用了面板");
setSize(420,200);
setVisible(true);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
publicstatic void main(String[] args) {
newJPanelTest();
}
}
運行結果：
4.2JScrollPane滾動面板--帶滾動條的
代碼實現：
public classJScrollPaneTest extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicJScrollPaneTest() {
Containerc = getContentPane(); // 創建容器
JTextAreata = new JTextArea(20, 50); // 創建文本區域組件
JScrollPanesp = new JScrollPane(ta); // 創建JScrollPane面板對象
c.add(sp);// 將該面板添加到該容器中
setTitle("帶滾動條的文字編譯器");
setSize(200,200);
setVisible(true);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
publicstatic void main(String[] args) {
newJScrollPaneTest();
}
}
運行結果：
5標籤組件與圖標
5.1JLabel標籤組件--簡單的顯示文本和圖片
JLabel的構造方法
5.2圖標的使用
1）創建圖標
代碼實現：
public classDrawIcon implements Icon { // 實現Icon接口
privateint width; // 聲明圖標的寬
privateint height; // 聲明圖標的長
publicint getIconHeight() { // 實現getIconHeight()方法
returnthis.height;
}
publicint getIconWidth() { // 實現getIconWidth()方法
returnthis.width;
}
publicDrawIcon(int width, int height) { // 定義構造方法
this.width= width;
this.height= height;
}
//實現paintIcon()方法
publicvoid paintIcon(Component arg0, Graphics arg1, int x, int y){
arg1.fillOval(x,y, width, height); // 繪製一個圓形
}
publicstatic void main(String[] args) {
DrawIconicon = new DrawIcon(15, 15);
//創建一個標籤，並設置標籤上的文字在標籤正中間
JLabelj = new JLabel("測試", icon, SwingConstants.CENTER);
JFramejf = new JFrame(); // 創建一個JFrame窗口
Containerc = jf.getContentPane();
c.add(j);
jf.setSize(100,100);
jf.setVisible(true);
jf.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
}
運行結果：
2）使用圖片創建圖標
代碼實現：
public classMyImageIcon extends JFrame {
privatestatic final long serialVersionUID = 1L;
publicMyImageIcon() {
Containercontainer = getContentPane();
//創建一個標籤
JLabeljl = new JLabel("這是一個JFrame窗體", JLabel.CENTER);
//獲取圖片所在的URL
URLurl = MyImageIcon.class.getResource("imageButton.jpg");
Iconicon = new ImageIcon(url); // 實例化Icon對象
jl.setIcon(icon);// 爲標籤設置圖片
//設置文字放置在標籤中間
jl.setHorizontalAlignment(SwingConstants.CENTER);
jl.setOpaque(true);// 設置標籤爲不透明狀態
container.add(jl);// 將標籤添加到容器中
setSize(250,100); // 設置窗體大小
setVisible(true);// 使窗體可見
//設置窗體關閉模式
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
publicstatic void main(String args[]) {
newMyImageIcon(); // 實例化MyImageIcon對象
}
}
運行結果：
6文本組件
6.1JTextField文本框組件
代碼實現：
public classJTextFieldTest extends JFrame{
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicJTextFieldTest(){
setSize(250,100);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
Containercp=getContentPane();
getContentPane().setLayout(newFlowLayout());
finalJTextField jt=new JTextField("aaa",20);
finalJButton jb=new JButton("清除");
cp.add(jt);
cp.add(jb);
jt.addActionListener(newActionListener(){
publicvoid actionPerformed(ActionEvent arg0) {
//TODO 自動生成方法存根
jt.setText("觸發事件");
}
});
jb.addActionListener(newActionListener(){
publicvoid actionPerformed(ActionEvent arg0) {
jt.setText("");
jt.requestFocus();
}
});
setVisible(true);
}
publicstatic void main(String[] args) {
newJTextFieldTest();
}
}
運行結果：
6.2JPasswordField密碼框組件--會給裏面的內容一個加密顯示
JPasswordField常用構造方法：
6.3JTextArea文本域組件
代碼實現：
public classJTextAreaTest extends JFrame{
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicJTextAreaTest(){
setSize(200,100);
setTitle("定義自動換行的文本域");
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
Containercp=getContentPane();
JTextAreajt=new JTextArea("文本域",6,6);
jt.setLineWrap(true);//可以自動換行
cp.add(jt);
setVisible(true);
}
publicstatic void main(String[] args) {
newJTextAreaTest();
}
}
運行結果
7按鈕組件
7.1JButton按鈕組件
代碼實現：
public classJButtonTest extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicJButtonTest() {
URLurl = JButtonTest.class.getResource("imageButtoo.jpg");
Iconicon = new ImageIcon(url);
setLayout(newGridLayout(3, 2, 5, 5)); // 設置網格佈局管理器
Containerc = getContentPane(); // 創建容器
for(int i = 0; i < 5; i++) {
//創建按鈕，同時設置按鈕文字與圖標
JButtonJ = new JButton("button" + i, icon);
c.add(J);// 在容器中添加按鈕
if(i % 2 == 0) {
J.setEnabled(false);// 設置其中一些按鈕不可用
}
}
JButtonjb = new JButton(); // 實例化一個沒有文字與圖片的按鈕
jb.setMaximumSize(newDimension(90, 30)); // 設置按鈕與圖片相同大小
jb.setIcon(icon);// 爲按鈕設置圖標
jb.setHideActionText(true);
jb.setToolTipText("圖片按鈕"); //設置按鈕提示爲文字
jb.setBorderPainted(false);// 設置按鈕邊界不顯示
jb.addActionListener(newActionListener() { // 爲按鈕添加監聽事件
publicvoid actionPerformed(ActionEvent e) {
//彈出確認對話框
JOptionPane.showMessageDialog(null,"彈出對話框");
}
});
c.add(jb);// 將按鈕添加到容器中
setTitle("創建帶文字與圖片的按鈕");
setSize(350,150);
setVisible(true);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
publicstatic void main(String args[]) {
newJButtonTest();
}
}
運行結果：
7.2JRadioButton單選按鈕組件
1）單選按鈕
2）按鈕組--ButtonGroup類表示按鈕組，一個按鈕組中只能單選一個按鈕
代碼實現：
public classRadioButtonTest extends JFrame {
publicRadioButtonTest() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setTitle("單選按鈕的使用");
setBounds(100,100, 220, 120);
getContentPane().setLayout(null);//設置絕對佈局
JLabellblNewLabel = new JLabel("請選擇發送方式：");
lblNewLabel.setBounds(5,5, 120, 15);
getContentPane().add(lblNewLabel);
JRadioButtonrbtnNormal = new JRadioButton("普通發送");
rbtnNormal.setSelected(true);
rbtnNormal.setFont(newFont("宋體", Font.PLAIN, 12));
rbtnNormal.setBounds(20,30, 75, 22);
rbtnNormal.addActionListener(newActionListener() {
@Override
publicvoid actionPerformed(ActionEvent arg0) {
//TODO Auto-generated method stub
if(rbtnNormal.isSelected())//判斷普通發送單選按鈕是否選中
JOptionPane.showMessageDialog(null,
"您選擇的是：" + rbtnNormal.getText(),
"提醒",JOptionPane.INFORMATION_MESSAGE);
}
});
getContentPane().add(rbtnNormal);
JRadioButtonrbtnPwd = new JRadioButton("加密發送");
rbtnPwd.setFont(newFont("宋體", Font.PLAIN, 12));
rbtnPwd.setBounds(100,30, 75, 22);
rbtnPwd.addActionListener(newActionListener() {
@Override
publicvoid actionPerformed(ActionEvent arg0) {
//TODO Auto-generated method stub
if(rbtnPwd.isSelected())//判斷加密發送單選按鈕是否選中
JOptionPane.showMessageDialog(null,
"您選擇的是：" + rbtnPwd.getText(),
"提醒",JOptionPane.INFORMATION_MESSAGE);
}
});
getContentPane().add(rbtnPwd);
/**
* 創建按鈕組，把交互面板中的單選按鈕添加到按鈕組中
*/
ButtonGroupgroup = new ButtonGroup();
group.add(rbtnNormal);
group.add(rbtnPwd);
}
publicstatic void main(String[] args) {
RadioButtonTestframe = new RadioButtonTest();//創建窗體對象
frame.setVisible(true);//使窗體可見
}
}
運行結果：
7.3JCheckBox複選框組件--可以進行多選設置
JCheckBox的常用構造方法：
1）public JCheckBox（）：創建一個沒有文本，沒有圖標並且最初未能被選中的複選框
2）public JCheckBox（Icon icon，Boolean checked）：創建一個帶圖標的複選框，並制定其最初是否處於選定狀態
3）public JCheckBox（String text，Boolean checked）：創建一個帶文本的複選框，並制定其最初是否處於選定狀態
代碼實現：
public class CheckBoxTest extends JFrame{
/**
*
*/
privatestatic final long serialVersionUID = 1L;
privateJPanel panel1 = new JPanel();
privateJPanel panel2 = new JPanel();
privateJTextArea jt=new JTextArea(3,10);
privateJCheckBox jc1=new JCheckBox("1");
privateJCheckBox jc2=new JCheckBox("2");
privateJCheckBox jc3=new JCheckBox("3");
publicCheckBoxTest(){
Containerc=getContentPane();
setSize(200,160);
setVisible(true);
setTitle("複選框的使用");
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
c.setLayout(newBorderLayout());
c.add(panel1,BorderLayout.NORTH);
finalJScrollPane scrollPane = new JScrollPane(jt);
panel1.add(scrollPane);
c.add(panel2,BorderLayout.SOUTH);
panel2.add(jc1);
jc1.addActionListener(newActionListener(){
publicvoid actionPerformed(ActionEvent e){
if(jc1.isSelected())
jt.append("複選框1被選中\n");
}
});
panel2.add(jc2);
jc2.addActionListener(newActionListener(){
publicvoid actionPerformed(ActionEvent e){
if(jc2.isSelected())
jt.append("複選框2被選中\n");
}
});
panel2.add(jc3);
jc3.addActionListener(newActionListener(){
publicvoid actionPerformed(ActionEvent e){
if(jc3.isSelected())
jt.append("複選框3被選中\n");
}
});
}
publicstatic void main(String[] args) {
newCheckBoxTest();
}
運行結果：
8列表組件
8.1JComboBox下來列表組件
JComboBox的常用構造方法
1）public JComboBox（）：創建具有默認數據模型的JComboBox
2）public JComboBox（ComboBox dataModel）：創建一個JComBox，下拉列表中的數據使用ComboBoxModel中的數據，ComboBoxModel是一個用於組合框的數據模型，它具有選擇項的概念。
3）public JComboBox（Object[]arrayData）：創建包含指定數組中元素的JComboBox。
4）public JComboBox（Vector vector）：創建包含指定Vector中元素JComboBox，Vector類是一個可增長的對象數組，和數組一樣，他包含可以使用整數索引進行訪問的組件，但是Vector的大小可以根據需要增大或縮小，以適應創建Vector後進行添加和移除項的操作。
JComboBox常用方法：
代碼實現：
public class JComboBoxTest extends JFrame {
publicJComboBoxTest() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setTitle("下拉列表框的使用");
setBounds(100,100, 317, 147);
getContentPane().setLayout(null);//設置絕對佈局
JLabellblNewLabel = new JLabel("請選擇證件：");
lblNewLabel.setBounds(28,14, 80, 15);
getContentPane().add(lblNewLabel);
JComboBox<String>comboBox = new JComboBox<String>();//創建一個下拉列表框
comboBox.setBounds(110,11, 80, 21);//設置座標
comboBox.addItem("身份證");//爲下拉列表中添加項
comboBox.addItem("軍人證");
comboBox.addItem("學生證");
comboBox.addItem("工作證");
comboBox.setEditable(true);
getContentPane().add(comboBox);//將下拉列表添加到容器中
JLabellblResult = new JLabel("");
lblResult.setBounds(0,57, 146, 15);
getContentPane().add(lblResult);
JButtonbtnNewButton = new JButton("確定");
btnNewButton.setBounds(200,10, 67, 23);
getContentPane().add(btnNewButton);
btnNewButton.addActionListener(newActionListener() {//爲按鈕添加監聽事件
@Override
publicvoid actionPerformed(ActionEvent arg0) {
lblResult.setText("您選擇的是："+comboBox.getSelectedItem());//獲取下拉列表中的選中項
}
});
}
publicstatic void main(String[] args) {
JComboBoxTestframe = new JComboBoxTest();//創建窗體對象
frame.setVisible(true);//使窗體可見
}
}
運行結果：
8.2JList列表框組件
代碼實現：
public class JListTest extends JFrame {
publicJListTest() {
Containercp = getContentPane();
cp.setLayout(null);
JTextAreatValue=new JTextArea();
tValue.setLineWrap(true);
tValue.setBounds(115,10, 60, 90);
cp.add(tValue);
JList<String>jl = new JList<>(new MyListModel());
jl.addListSelectionListener(newListSelectionListener() {
@Override
publicvoid valueChanged(ListSelectionEvent arg0) {
//TODO Auto-generated method stub
Object[]values=jl.getSelectedValues();//獲取所有選中項
StringstrValue="";
tValue.setText("");//清空文本域
for(inti=0;i<values.length;i++)
tValue.append(values[i]+"\n");//將選中內容顯示在文本域中
}
});
JScrollPanejs = new JScrollPane(jl);
js.setBounds(10,10, 100, 100);
cp.add(js);
setTitle("在這個窗體中使用了列表框");
setSize(200,150);
setVisible(true);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
publicstatic void main(String args[]) {
newJListTest();
}
}
class MyListModel extendsAbstractListModel<String> {// 繼承抽象類AbstractListModel
//設置列表框內容
privateString[] contents = { "列表1", "列表2", "列表3", "列表4", "列表5", "列表6" };
publicString getElementAt(int x) {// 重寫getElementAt()方法
if(x < contents.length)
returncontents[x++];
else
returnnull;
}
publicint getSize() {// 重寫getSize()方法
returncontents.length;
}
}
運行結果：
9常用事件監聽
9.1監聽事件簡介
9.2動作事件監聽--動作事件（ActionEvent）監聽器是Swing中比較常用的事件監聽器，很多組件的動作都會使用它監聽
| 事件名稱 | 事件源 | 監聽藉口 | 添加或刪除相應類型監聽器的方法 |
| ActionEvent | JButton、JList、JTextField等 | ActionListener | addActionListener(); removeActionListener(); |
public class SimpleEvent extends JFrame{
/**
*
*/
privatestatic final long serialVersionUID = 1L;
privateJButton jb=new JButton("我是按鈕，單擊我");
publicSimpleEvent(){
setLayout(null);
setSize(200,100);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
Containercp=getContentPane();
cp.add(jb);
jb.setBounds(10,10,100,30);
jb.addActionListener(newjbAction());
setVisible(true);
}
classjbAction implements ActionListener{
publicvoid actionPerformed(ActionEvent arg0) {
jb.setText("我被單擊了");
}
}
publicstatic void main(String[] args) {
newSimpleEvent();
}
}
運行結果：
9.3焦點事件監聽器--FocusEvent監聽器
| 事件名稱 | 事件源 | 監聽藉口 | 添加或刪除相應類型監聽器的方法 |
public class FocusEventTest extends JFrame{
private static final long serialVersionUID = 1L;
public FocusEventTest() {
setSize(250,100);
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
Container cp=getContentPane();
getContentPane().setLayout(new FlowLayout());
final JLabel label = new JLabel();
getContentPane().add(label);
JTextField jt=new JTextField("請單擊其他文本框",10);
JTextField jt2=new JTextField("請單擊我",10);
cp.add(jt);
cp.add(jt2);
jt.addFocusListener(new FocusListener(){
//組件失去焦點時調用的方法
public void focusLost(FocusEvent arg0) {
JOptionPane.showMessageDialog(null, "文本框失去焦點");
}
//組件獲取鍵盤焦點時調用的方法
public void focusGained(FocusEvent arg0) {
}
});
setVisible(true);
}
public static void main(String[] args) {
new FocusEventTest();
}
}
運行結果：
17.AWT繪圖
1.Java繪圖基礎
1.1Graphics類
1.2Graphics2D類
1.3Canvas類
2.繪製幾何圖形—使用不同的方法繪製不同的圖形
Java中繪製圖形的基本步驟：
代碼實現：
public classDrawTest extends JFrame {
publicDrawTest() {
super();
initialize();//調用初始化方法
}
//初始化方法
privatevoid initialize() {
this.setSize(300,200); // 設置窗體大小
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 設置窗體關閉模式
add(newCanvasTest ()); // 設置窗體面板爲繪圖面板對象
this.setTitle("繪製幾何圖形");// 設置窗體標題
}
publicstatic void main(String[] args) {
newDrawTest().setVisible(true);
}
classCanvasTest extends Canvas{// 創建畫布
publicvoid paint(Graphics g) {
super.paint(g);
Graphics2Dg2 = (Graphics2D) g;// 創建Graphics2D對象，用於畫圖
g2.drawOval(5,5, 100, 100);// 調用從Graphics類繼承的drawOval方法繪製圓形
g2.fillRect(15,15, 80, 80);// 調用從Graphics類繼承的fillRect方法填充矩形
Shape[]shapes = new Shape[2]; // 聲明圖形數組
shapes[0]= new Rectangle2D.Double(110, 5, 100, 100); // 創建矩形對象
shapes[1]= new Ellipse2D.Double(120, 15, 80, 80); // 創建圓形對象
for(Shape shape : shapes) { // 遍歷圖形數組
Rectangle2Dbounds = shape.getBounds2D();
if(bounds.getWidth() == 80)
g2.fill(shape);// 填充圖形
else
g2.draw(shape);// 繪製圖形
}
}
}
}
運行結果：
3.設置顏色和畫筆—Java中使用java.awt.Color類封裝顏色的各種屬性，並對顏色進行管理
3.1設置顏色—使用Color類可以創建任何顏色的對象，java以跨平臺支持顏色管理
Color類定義常用色彩的常量值如下表
代碼實現：
import java.awt.*;
import javax.swing.*;
public class ColorTest extends JFrame {
publicColorTest() {
super();
initialize();//調用初始化方法
}
privatevoid initialize() { // 初始化方法
this.setSize(300,200); // 設置窗體大小
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 設置窗體關閉模式
add(newCanvasTest()); // 設置窗體面板爲繪圖面板對象
this.setTitle("設置顏色");// 設置窗體標題
}
publicstatic void main(String[] args) {
newColorTest().setVisible(true);
}
classCanvasTest extends Canvas {// 創建畫布
publicvoid paint(Graphics g) {
super.paint(g);
Graphics2Dg2 = (Graphics2D) g;// 創建Graphics2D對象，用於畫圖
g2.setColor(Color.RED);//設置顏色爲紅色
g2.drawLine(5,30, 100, 30);// 調用從Graphics類繼承的drawLine方法繪製直線
}
}
}
運行結果
3.2設置畫筆—調用Stroke接口設置畫筆屬性
常用構造方法
代碼實現：
public class StrokeTest extendsJFrame {
publicStrokeTest() {
super();
initialize();//調用初始化方法
}
private voidinitialize() { // 初始化方法
this.setSize(300,200); // 設置窗體大小
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 設置窗體關閉模式
add(newCanvasTest()); // 設置窗體面板爲繪圖面板對象
this.setTitle("設置畫筆");// 設置窗體標題
}
public staticvoid main(String[] args) {
newStrokeTest().setVisible(true);
}
class CanvasTestextends Canvas {// 創建畫布
public voidpaint(Graphics g) {
super.paint(g);
Graphics2Dg2 = (Graphics2D) g;// 創建Graphics2D對象，用於畫圖
//創建畫筆，寬度爲8
Strokestroke=new BasicStroke(8);
g2.setStroke(stroke);//設置畫筆
g2.drawLine(20,30, 120, 30);// 調用從Graphics類繼承的drawLine方法繪製直線
//創建畫筆，寬度爲12，線端點的裝飾爲CAP_ROUND，應用在路徑線段交匯處的裝飾爲JOIN_BEVEL
StrokeroundStroke=new BasicStroke(12,BasicStroke.CAP_ROUND,BasicStroke.JOIN_BEVEL);
g2.setStroke(roundStroke);
g2.drawLine(20,50, 120, 50);// 調用從Graphics類繼承的drawLine方法繪製直線
}
}
}
運行結果：
4.繪製文本
4.1.設置字體—Font類中封裝了字體的大小，樣式等屬性
語法：Font（String name，int style，int size），用來指定字體的名稱、樣式，大小
4.2繪製文字—使用drawString方法可以實現繪製文字的功能
代碼實現：
import java.awt.*;
import javax.swing.*;
public class DrawStringTest extends JFrame {
public DrawStringTest(){
this.setSize(310,140); // 設置窗體大小
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 設置窗體關閉模式
add(newCanvasTest()); // 設置窗體面板爲繪圖面板對象
this.setTitle("繪製文本");// 設置窗體標題
}
public static voidmain(String[] args) {
newDrawStringTest().setVisible(true);
}
class CanvasTestextends Canvas {//創建畫布
public voidpaint(Graphics g) {//重寫paint方法
super.paint(g);
Graphics2Dg2 = (Graphics2D) g;//創建繪圖對象
g2.setColor(Color.BLUE);// 設置當前繪圖顏色
Fontfont = new Font("宋體", Font.BOLD, 16);// 字體對象
g2.setFont(font);// 設置字體
g2.drawString("Doneis better than perfect.", 20, 30); // 繪製文本
g2.drawString("——比完美更重要的是完成。",60, 60); // 繪製時間文本
}
}
}
運行結果
5.圖像處理
5.1繪製圖像—繪製圖像是須使用drawImage()方法，該方法可以用來將圖像資源顯示到繪圖的上下文中
drawImage(Image img，int x，int y，ImageObserver observe)；
代碼實現：
import java.awt.*;
import javax.swing.*;
public class DrawImageTest extends JFrame {
public DrawImageTest(){
this.setSize(500,380); // 設置窗體大小
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 設置窗體關閉模式
add(newCanvasTest()); // 設置窗體面板爲繪圖面板對象
this.setTitle("繪製圖像");// 設置窗體標題
}
public static voidmain(String[] args) {
newDrawImageTest().setVisible(true);//使窗體可見
}
class CanvasTestextends Canvas {// 創建畫布
public voidpaint(Graphics g) {
super.paint(g);
Graphics2Dg2 = (Graphics2D) g;// 創建繪圖對象
Imageimg = new ImageIcon("src/img.png").getImage(); // 獲取圖片資源
g2.drawImage(img,0, 0, this); // 顯示圖像
}
}
}
運行結果：
5.2圖像縮放—需要重載drawImage()方法
drawImage(Image img，int x，int y，int width，int height，ImageObserver observe)；
代碼實現：
public class ZoomImage extendsJFrame {
private intimgWidth, imgHeight;// 定義圖像的寬和高
private doublenum;// 圖片變化增量
private JPaneljPanImg = null;// 顯示圖像的面板
private JPaneljPanBtn = null;// 顯示控制按鈕的面板
private JButtonjBtnBig = null;// 放大按鈕
private JButtonjBtnSmall = null;// 縮小按鈕
privateCanvasTest canvas = null;// 繪圖面板
publicZoomImage() {
initialize();// 調用初始化方法
}
private voidinitialize() {// 界面初始化方法
this.setBounds(100,100, 500, 420); // 設置窗體大小和位置
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 設置窗體關閉模式
this.setTitle("圖像縮放");// 設置窗體標題
jPanImg = newJPanel();// 主容器面板
canvas = newCanvasTest();// 獲取畫布
jPanImg.setLayout(newBorderLayout());// 主容器面板
jPanImg.add(canvas,BorderLayout.CENTER);// 將畫布放到面板中央
setContentPane(jPanImg);//將主容器面板作爲窗體容器
jBtnBig = newJButton("放大(+)");// 放大按鈕
jBtnBig.addActionListener(newjava.awt.event.ActionListener() {
publicvoid actionPerformed(java.awt.event.ActionEvent e) {
num+= 20;// 設置正整數增量，每次點擊圖片寬高加20
canvas.repaint();//重繪放大的圖像
}
});
jBtnSmall = newJButton("縮小(-)");// 縮小按鈕
jBtnSmall.addActionListener(newjava.awt.event.ActionListener() {
publicvoid actionPerformed(java.awt.event.ActionEvent e) {
num-= 20;// 設置負整數增量，每次點擊圖片寬高減20
canvas.repaint();//重繪縮小的圖像
}
});
jPanBtn = newJPanel();// 按鈕面板
jPanBtn.setLayout(newFlowLayout());// 採用劉佈局
jPanBtn.add(jBtnBig);//添加按鈕
jPanBtn.add(jBtnSmall);//添加按鈕
jPanImg.add(jPanBtn,BorderLayout.SOUTH);// 放到容器底部
}
public staticvoid main(String[] args) {// 主方法
newZoomImage().setVisible(true);// 創建主類對象並顯示窗體
}
class CanvasTestextends Canvas {// 創建畫布
public voidpaint(Graphics g) {// 重寫paint方法，用來重繪圖像
Imageimg = new ImageIcon("src/img.png").getImage(); // 獲取圖片資源
imgWidth= img.getWidth(this); // 獲取圖像寬度
imgHeight= img.getHeight(this); // 獲取圖像高度
intnewW = (int) (imgWidth + num); // 計算圖像放大後的寬度
intnewH = (int) (imgHeight + num); // 計算圖像放大後的高度
g.drawImage(img,0, 0, newW, newH, this); // 繪製指定大小的圖像
}
}
}
運行結果：
5.3圖像翻轉--需要另一種重載drawImage()方法
drawImage(Image img，int dx1，int dy1，int dx2，int dy2，int sx1，int sy1，int dx2，int sy2,ImageObserver observe)；
代碼實現：
public class PartImage extendsJFrame {
private intdx1, dy1, dx2, dy2;// 目標矩形兩個角的x、y座標
private intsx1, sy1, sx2, sy2;// 源矩形兩個角的x、y座標
private finalint origin, width, high;// 分別記錄原點、圖片寬、高的三個常量
private Imageimg;// 圖片
private JPaneljPanImg = null;// 顯示圖像的面板
private JPaneljPanBtn = null;// 顯示控制按鈕的面板
private JButtonjBtnHor = null;// 水平翻轉按鈕
private JButtonjBtnVer = null;// 垂直翻轉按鈕
privateCanvasTest canvas = null;
publicPartImage() {
img = newImageIcon("src/img.png").getImage();// 獲取圖像資源
origin = 0;// 原點座標爲0
width =img.getWidth(this);// 獲取圖片寬度，輸入任意參數
high =img.getHeight(this);// 獲取圖片高度，輸入任意參數
dx1 = sx1 =origin;// 初始化目標矩形和源矩形的左上角的x座標都爲0
dy1 = sy1 =origin;// 初始化目標矩形和源矩形的左上角的y座標都爲0
dx2 = sx2 =width; // 初始化目標矩形和源矩形的右下角的x座標都爲圖像寬度
dy2 = sy2 =high; // 初始化目標矩形和源矩形的右下角的y座標都爲圖像高度
initialize();// 調用初始化方法
}
private voidinitialize() {// 界面初始化方法
this.setBounds(100,100, 550, 480); // 設置窗體大小和位置
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 設置窗體關閉模式
this.setTitle("圖像翻轉");// 設置窗體標題
jPanImg = newJPanel();// 獲取內容面板的方法
canvas = newCanvasTest();// 獲取畫布
jPanImg.setLayout(newBorderLayout());// 設爲邊界佈局
jPanImg.add(canvas,BorderLayout.CENTER);// 將畫布添加到內容面板中
this.setContentPane(jPanImg);//內容面板作爲窗體容器
jBtnHor = newJButton();// 獲取水平翻轉按鈕
jBtnHor.setText("水平翻轉");
jBtnHor.addActionListener(newjava.awt.event.ActionListener() {
publicvoid actionPerformed(java.awt.event.ActionEvent e) {
dx1= Math.abs(dx1 - width);// 第一個點的目標位置橫座標與圖片寬度相減，取絕對值
dx2= Math.abs(dx2 - width);// 第二個點的目標位置橫座標與圖片寬度相減，取絕對值
canvas.repaint();//重繪圖像
}
});
jBtnVer = newJButton();// 獲取垂直翻轉按鈕
jBtnVer.setText("垂直翻轉");
jBtnVer.addActionListener(newjava.awt.event.ActionListener() {
publicvoid actionPerformed(java.awt.event.ActionEvent e) {
dy1= Math.abs(dy1 - high);// 第一個點的目標位置縱座標與圖片高度相減，取絕對值
dy2= Math.abs(dy2 - high);// 第二個點的目標位置縱座標與圖片高度相減，取絕對值
canvas.repaint();//重繪圖像
}
});
jPanBtn = newJPanel();// 獲取按鈕控制面板的方法
jPanBtn.setLayout(newFlowLayout());// 設爲邊流佈局
jPanBtn.add(jBtnHor);//添加按鈕
jPanBtn.add(jBtnVer);
jPanImg.add(jPanBtn,BorderLayout.SOUTH);// 按鈕面板放到主面板最下端
}
public staticvoid main(String[] args) {// 主方法
newPartImage().setVisible(true);// 使窗體可見
}
class CanvasTestextends Canvas {// 創建畫布
public voidpaint(Graphics g) {// 重寫paint方法，以便重繪圖像
g.drawImage(img,dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, this);// 繪製指定大小的圖像
}
}
}
運行結果：
5.4圖像旋轉—調用Graphics2D類的rotate()方法，根據指定的弧度旋轉對象
語法：rotate（double theta）theta：旋轉的弧度。
代碼實現：
public class RotateImage extendsJFrame {
publicRotateImage() {
initialize();// 調用初始化方法
}
// 界面初始化方法
private voidinitialize() {
CanvasTestcanvasl = new CanvasTest();// 創建畫布對象
this.setBounds(100,100, 400, 350); // 設置窗體大小和位置
add(canvasl);//將畫布對象顯示在窗體中
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 設置窗體關閉模式
this.setTitle("圖像旋轉");// 設置窗體標題
}
public staticvoid main(String[] args) {
newRotateImage().setVisible(true);// 使窗體可見
}
class CanvasTestextends Canvas {// 創建畫布
public voidpaint(Graphics g) {// 重寫方法，以便重繪圖像
Graphics2Dg2 = (Graphics2D) g;// 創建繪圖對象
Imageimg = new ImageIcon("src/img.png").getImage(); // 獲取圖像資源
g2.rotate(Math.toRadians(5));//設置旋轉弧度
g2.drawImage(img,70, 10, 300, 200, this);// 繪製指定大小的圖像
g2.rotate(Math.toRadians(5));//設置旋轉弧度
g2.drawImage(img,70, 10, 300, 200, this);// 繪製指定大小的圖像
g2.rotate(Math.toRadians(5));//設置旋轉弧度
g2.drawImage(img,70, 10, 300, 200, this);// 繪製指定大小的圖像
}
}
}
運行結果：
5.5圖像傾斜--調用Graphics2D類的shear()方法，可以設置繪圖的傾斜方向
語法：publicabstract void shear（double shx，double shy）shx：水平方向的傾斜量，shy：垂直方向的傾斜量
代碼實現：
public class TiltImage extendsJFrame {
publicTiltImage() {
initialize(); //調用初始化方法
}
private voidinitialize() {// 界面初始化方法
CanvasTest canvas= new CanvasTest();// 創建畫布對象
this.setBounds(100,100, 380, 260); // 設置窗體大小和位置
add(canvas);//將畫布對象顯示在窗體中
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 設置窗體關閉模式
this.setTitle("圖像傾斜"); //設置窗體標題
}
public staticvoid main(String[] args) {
newTiltImage().setVisible(true);// 使窗體可見
}
class CanvasTestextends Canvas {// 創建畫布
public voidpaint(Graphics g) {// 重寫方法，以便重繪圖像
Graphics2Dg2 = (Graphics2D) g;// 創建繪圖對象
Image img= new ImageIcon("src/img.png").getImage(); // 獲取圖像資源
g2.shear(0.3,0);// 設置傾斜量
g2.drawImage(img,0, 0, 300, 200, this);// 繪製指定大小的圖像
}
}
}
運行結果：
18.事件監聽
1鍵盤事件
代碼實現：
/**
* 虛擬鍵盤(鍵盤的按下與釋放)
*/
public classKeyBoard extends JFrame { //創建“鍵盤”類繼承JFrame
//聲明窗體中的成員組件
privateJPanel contentPane;
privateJTextField textField;
privateJButton btnQ;
privateJButton btnW;
privateJButton btnE;
privateJButton btnR;
privateJButton btnT;
privateJButton btnY;
privateJButton btnU;
privateJButton btnI;
privateJButton btnO;
privateJButton btnP;
privateJButton btnA;
privateJButton btnS;
privateJButton btnD;
privateJButton btnF;
privateJButton btnG;
privateJButton btnH;
privateJButton btnJ;
privateJButton btnK;
privateJButton btnL;
privateJButton btnZ;
privateJButton btnX;
privateJButton btnC;
privateJButton btnV;
privateJButton btnB;
privateJButton btnN;
privateJButton btnM;
Colorgreen=Color.GREEN;//定義Color對象，用來表示按下鍵的顏色
Colorwhite=Color.WHITE;//定義Color對象，用來表示釋放鍵的顏色
ArrayList<JButton>btns=new ArrayList<JButton>();//定義一個集合，用來存儲所有的按鍵ID
//自定義一個方法，用來將容器中的所有JButton組件添加到集合中
privatevoid addButtons(){
for(Componentcmp :contentPane.getComponents()){//遍歷面板中的所有組件
if(cmpinstanceof JButton){//判斷組件的類型是否爲JButton類型
btns.add((JButton)cmp);//將JButton組件添加到集合中
}
}
}
/**
* 主方法
*/
publicstatic void main(String[] args) {
EventQueue.invokeLater(newRunnable() { //使得Runnable中的的run()方法在the system EventQueue的指派線程中被調用
publicvoid run() {
try{
KeyBoardframe = new KeyBoard(); //創建KeyBoard對象
frame.setVisible(true);//使frame可視
frame.addButtons();//初始化存儲所有按鍵的集合
}catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* 創建JFrame窗體
*/
publicKeyBoard() { //KeyBoard的構造方法
setTitle("\u865A\u62DF\u952E\u76D8\uFF08\u6A21\u62DF\u952E\u76D8\u7684\u6309\u4E0B\u4E0E\u91CA\u653E\uFF09");//設置窗體題目
setResizable(false);//不可改變窗體寬高
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//設置窗體關閉的方式
setBounds(100,100, 548, 280); //設置窗體的位置和寬高
/**
* 創建JPanel面板contentPane置於JFrame窗體中，並設置面板的背景色、邊距和佈局
*/
contentPane= new JPanel();
contentPane.setBackground(Color.WHITE);
contentPane.setBorder(newEmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(null);
/**
* 創建按鈕button置於面板contentPane中，設置按鈕的背景色、位置、寬高以及按鈕中的字體位置、內容、樣式
*/
btnQ= new JButton("Q");
btnQ.setBackground(white);
btnQ.setVerticalAlignment(SwingConstants.TOP);
btnQ.setHorizontalAlignment(SwingConstants.LEADING);
btnQ.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnQ.setBounds(0,60, 47, 45);
contentPane.add(btnQ);
/**
* 創建按鈕button_2置於面板contentPane中，設置按鈕的背景色、位置、寬高以及按鈕中的字體位置、內容、樣式
*/
btnW= new JButton("W");
btnW.setBackground(white);
btnW.setVerticalAlignment(SwingConstants.TOP);
btnW.setHorizontalAlignment(SwingConstants.LEADING);
btnW.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnW.setBounds(55,60, 49, 45);
contentPane.add(btnW);
/**
* 創建按鈕button_3置於面板contentPane中，設置按鈕的背景色、位置、寬高以及按鈕中的字體位置、內容、樣式
*/
btnE= new JButton("E");
btnE.setBackground(white);
btnE.setVerticalAlignment(SwingConstants.TOP);
btnE.setHorizontalAlignment(SwingConstants.LEADING);
btnE.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnE.setBounds(110,60, 45, 45);
contentPane.add(btnE);
/**
* 創建按鈕button_4置於面板contentPane中，設置按鈕的背景色、位置、寬高以及按鈕中的字體位置、內容、樣式
*/
btnR= new JButton("R");
btnR.setBackground(white);
btnR.setVerticalAlignment(SwingConstants.TOP);
btnR.setHorizontalAlignment(SwingConstants.LEADING);
btnR.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnR.setBounds(165,60, 45, 45);
contentPane.add(btnR);
/**
* 創建按鈕button_5置於面板contentPane中，設置按鈕的背景色、位置、寬高以及按鈕中的字體位置、內容、樣式
*/
btnF= new JButton("F");
btnF.setBackground(white);
btnF.setVerticalAlignment(SwingConstants.TOP);
btnF.setHorizontalAlignment(SwingConstants.LEADING);
btnF.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnF.setBounds(195,125, 45, 45);
contentPane.add(btnF);
/**
* 創建按鈕button_6置於面板contentPane中，設置按鈕的背景色、位置、寬高以及按鈕中的字體位置、內容、樣式
*/
btnD= new JButton("D");
btnD.setBackground(white);
btnD.setVerticalAlignment(SwingConstants.TOP);
btnD.setHorizontalAlignment(SwingConstants.LEADING);
btnD.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnD.setBounds(137,125, 45, 45);
contentPane.add(btnD);
btnT= new JButton("T");
btnT.setVerticalAlignment(SwingConstants.TOP);
btnT.setHorizontalAlignment(SwingConstants.LEADING);
btnT.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnT.setBackground(white);
btnT.setBounds(220,60, 45, 45);
contentPane.add(btnT);
btnY= new JButton("Y");
btnY.setVerticalAlignment(SwingConstants.TOP);
btnY.setHorizontalAlignment(SwingConstants.LEADING);
btnY.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnY.setBackground(white);
btnY.setBounds(275,60, 45, 45);
contentPane.add(btnY);
btnU= new JButton("U");
btnU.setVerticalAlignment(SwingConstants.TOP);
btnU.setHorizontalAlignment(SwingConstants.LEADING);
btnU.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnU.setBackground(white);
btnU.setBounds(330,60, 45, 45);
contentPane.add(btnU);
btnI= new JButton("I");
btnI.setVerticalAlignment(SwingConstants.TOP);
btnI.setHorizontalAlignment(SwingConstants.LEADING);
btnI.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnI.setBackground(white);
btnI.setBounds(385,60, 45, 45);
contentPane.add(btnI);
btnO= new JButton("O");
btnO.setVerticalAlignment(SwingConstants.TOP);
btnO.setHorizontalAlignment(SwingConstants.LEADING);
btnO.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnO.setBackground(white);
btnO.setBounds(440,60, 46, 45);
contentPane.add(btnO);
btnP= new JButton("P");
btnP.setVerticalAlignment(SwingConstants.TOP);
btnP.setHorizontalAlignment(SwingConstants.LEADING);
btnP.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnP.setBackground(white);
btnP.setBounds(495,60, 45, 45);
contentPane.add(btnP);
btnA= new JButton("A");
btnA.setVerticalAlignment(SwingConstants.TOP);
btnA.setHorizontalAlignment(SwingConstants.LEADING);
btnA.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnA.setBackground(white);
btnA.setBounds(23,125, 45, 45);
contentPane.add(btnA);
btnS= new JButton("S");
btnS.setVerticalAlignment(SwingConstants.TOP);
btnS.setHorizontalAlignment(SwingConstants.LEADING);
btnS.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnS.setBackground(white);
btnS.setBounds(82,125, 45, 45);
contentPane.add(btnS);
btnG= new JButton("G");
btnG.setVerticalAlignment(SwingConstants.TOP);
btnG.setHorizontalAlignment(SwingConstants.LEADING);
btnG.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnG.setBackground(white);
btnG.setBounds(251,125, 45, 45);
contentPane.add(btnG);
btnH= new JButton("H");
btnH.setVerticalAlignment(SwingConstants.TOP);
btnH.setHorizontalAlignment(SwingConstants.LEADING);
btnH.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnH.setBackground(white);
btnH.setBounds(306,125, 45, 45);
contentPane.add(btnH);
btnJ= new JButton("J");
btnJ.setVerticalAlignment(SwingConstants.TOP);
btnJ.setHorizontalAlignment(SwingConstants.LEADING);
btnJ.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnJ.setBackground(white);
btnJ.setBounds(361,125, 45, 45);
contentPane.add(btnJ);
btnK= new JButton("K");
btnK.setVerticalAlignment(SwingConstants.TOP);
btnK.setHorizontalAlignment(SwingConstants.LEADING);
btnK.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnK.setBackground(white);
btnK.setBounds(416,125, 47, 45);
contentPane.add(btnK);
btnL= new JButton("L");
btnL.setVerticalAlignment(SwingConstants.TOP);
btnL.setHorizontalAlignment(SwingConstants.LEADING);
btnL.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnL.setBackground(white);
btnL.setBounds(471,125, 45, 45);
contentPane.add(btnL);
btnZ= new JButton("Z");
btnZ.setVerticalAlignment(SwingConstants.TOP);
btnZ.setHorizontalAlignment(SwingConstants.LEADING);
btnZ.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnZ.setBackground(white);
btnZ.setBounds(39,190, 45, 45);
contentPane.add(btnZ);
btnX= new JButton("X");
btnX.setVerticalAlignment(SwingConstants.TOP);
btnX.setHorizontalAlignment(SwingConstants.LEADING);
btnX.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnX.setBackground(white);
btnX.setBounds(107,190, 45, 45);
contentPane.add(btnX);
btnC= new JButton("C");
btnC.setVerticalAlignment(SwingConstants.TOP);
btnC.setHorizontalAlignment(SwingConstants.LEADING);
btnC.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnC.setBackground(white);
btnC.setBounds(178,190, 45, 45);
contentPane.add(btnC);
btnV= new JButton("V");
btnV.setVerticalAlignment(SwingConstants.TOP);
btnV.setHorizontalAlignment(SwingConstants.LEADING);
btnV.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnV.setBackground(white);
btnV.setBounds(250,190, 45, 45);
contentPane.add(btnV);
btnB= new JButton("B");
btnB.setVerticalAlignment(SwingConstants.TOP);
btnB.setHorizontalAlignment(SwingConstants.LEADING);
btnB.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnB.setBackground(white);
btnB.setBounds(315,190, 45, 45);
contentPane.add(btnB);
btnN= new JButton("N");
btnN.setVerticalAlignment(SwingConstants.TOP);
btnN.setHorizontalAlignment(SwingConstants.LEADING);
btnN.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnN.setBackground(white);
btnN.setBounds(382,190, 47, 45);
contentPane.add(btnN);
btnM= new JButton("M");
btnM.setVerticalAlignment(SwingConstants.TOP);
btnM.setHorizontalAlignment(SwingConstants.LEADING);
btnM.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnM.setBackground(white);
btnM.setBounds(449,190, 48, 45);
contentPane.add(btnM);
/**
* 創建面板panel置於面板contentPane中，設置面板panel的位置、寬高、TitledBorder、背景色以及佈局方式（邊界佈局）
*/
JPanelpanel = new JPanel();
panel.setBorder(newTitledBorder(null, "文本顯示區", TitledBorder.LEADING, TitledBorder.TOP, null, null));
panel.setBackground(Color.WHITE);
panel.setBounds(0,0, 540, 45);
contentPane.add(panel);
panel.setLayout(newBorderLayout(0, 0));
/**
* 創建文本框textField置於面板panel的中間
*/
textField= new JTextField();
textField.addKeyListener(newKeyAdapter() { //文本框添加鍵盤事件的監聽
charword;
@Override
publicvoid keyPressed(KeyEvent e) { //按鍵被按下時被觸發
word=e.getKeyChar();//獲取按下鍵表示的字符
for(inti=0;i<btns.size();i++){//遍歷存儲按鍵ID的ArrayList集合
//判斷按鍵是否與遍歷到的按鍵的文本相同
if(String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())){
btns.get(i).setBackground(green);//將指定按鍵顏色設置爲綠色
}
}
}
@Override
publicvoid keyReleased(KeyEvent e) { //按鍵被釋放時被觸發
word=e.getKeyChar();//獲取釋放鍵表示的字符
for(inti=0;i<btns.size();i++){//遍歷存儲按鍵ID的ArrayList集合
//判斷按鍵是否與遍歷到的按鍵的文本相同
if(String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())){
btns.get(i).setBackground(white);//將指定按鍵顏色設置爲白色
}
}
}
});
panel.add(textField,BorderLayout.CENTER);
textField.setColumns(10);
}
}
運行結果：
2鼠標事件
代碼實現：
public classMouseEvent_Example extends JFrame { // 繼承窗體類JFrame
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicstatic void main(String args[]) {
MouseEvent_Exampleframe = new MouseEvent_Example();
frame.setVisible(true);// 設置窗體可見，默認爲不可見
}
/**
* 判斷按下的鼠標鍵，並輸出相應提示
* @param e 鼠標事件
*/
privatevoid mouseOper(MouseEvent e){
inti = e.getButton(); // 通過該值可以判斷按下的是哪個鍵
if(i == MouseEvent.BUTTON1)
System.out.println("按下的是鼠標左鍵");
elseif (i == MouseEvent.BUTTON2)
System.out.println("按下的是鼠標滾輪");
elseif (i == MouseEvent.BUTTON3)
System.out.println("按下的是鼠標右鍵");
}
publicMouseEvent_Example() {
super();// 繼承父類的構造方法
setTitle("鼠標事件示例");// 設置窗體的標題
setBounds(100,100, 500, 375); // 設置窗體的顯示位置及大小
//設置窗體關閉按鈕的動作爲退出
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
finalJLabel label = new JLabel();
label.addMouseListener(newMouseListener() {
publicvoid mouseEntered(MouseEvent e) {// 光標移入組件時被觸發
System.out.println("光標移入組件");
}
publicvoid mousePressed(MouseEvent e) {// 鼠標按鍵被按下時被觸發
System.out.print("鼠標按鍵被按下，");
mouseOper(e);
}
publicvoid mouseReleased(MouseEvent e) {// 鼠標按鍵被釋放時被觸發
System.out.print("鼠標按鍵被釋放，");
mouseOper(e);
}
publicvoid mouseClicked(MouseEvent e) {// 發生單擊事件時被觸發
System.out.print("單擊了鼠標按鍵，");
mouseOper(e);
intclickCount = e.getClickCount();//獲取鼠標單擊次數
System.out.println("單擊次數爲" +clickCount + "下");
}
publicvoid mouseExited(MouseEvent e) {// 光標移出組件時被觸發
System.out.println("光標移出組件");
}
});
getContentPane().add(label,BorderLayout.CENTER);
//
}
}
運行結果：
3窗體事件
3.1捕獲窗體焦點變化事件
代碼實現：
/**
* 焦點事件的監聽： 使用焦點事件的監聽模擬點亮燈泡的過程。
*/
public classFocus extends JFrame { // 創建一個“焦點”類，並繼承JFrame
//聲明窗體中的組件
privateJPanel contentPane;
privateJLabel lblTip;
privateJLabel lblLight;
/**
* 主方法
*/
publicstatic void main(String[] args) {
EventQueue.invokeLater(newRunnable() { // 使得Runnable中的的run()方法在the
//system EventQueue的指派線程中被調用
publicvoid run() {
try{
Focusframe = new Focus(); // 創建Flags對象
frame.setVisible(true);// 使frame可視
}catch (Exception e) {
e.printStackTrace();
}
}
});
}
privateclass myWindowFocusListener implements WindowFocusListener{
@Override
publicvoid windowGainedFocus(WindowEvent arg0) {
lblLight.setIcon(newImageIcon(Focus.class.getResource("light.png"))); // 設置標籤中的圖標，顯示燈亮
lblTip.setText("JFrame窗體獲得焦點後，燈亮了...");// 設置標籤中的文本
}
@Override
publicvoid windowLostFocus(WindowEvent arg0) {
lblLight.setIcon(newImageIcon(Focus.class.getResource("dark.png"))); // 設置標籤中的圖標，顯示燈滅
lblTip.setText("JFrame窗體失去焦點後，燈滅了...");// 設置標籤中的文本
}
}
/**
* 創建JFrame窗體
*/
publicFocus() { // Focus的構造方法
addWindowFocusListener(newmyWindowFocusListener());//爲窗體添加焦點事件監聽器
setAutoRequestFocus(false);// JFrame窗體失去焦點
setResizable(false);// 不可改變窗體大小
setTitle("焦點事件的監聽");// 設置窗體題目
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 設置窗體關閉的方式
setBounds(100,100, 300, 300); // 設置窗體大小
/**
* 創建JPanel面板contentPane置於JFrame窗體中，並設置面板的背景色、邊距和佈局
*/
contentPane= new JPanel();
contentPane.setBackground(Color.BLACK);
contentPane.setBorder(newEmptyBorder(5, 5, 5, 5));
contentPane.setLayout(newBorderLayout(0, 0));
setContentPane(contentPane);
/**
* 創建標籤lblTip置於JFrame窗體中的南側，設置標籤label_1中字體的顏色、樣式以及水平居中
*/
lblTip= new JLabel("JFrame窗體失去焦點時，燈沒亮！");
lblTip.setForeground(Color.CYAN);
lblTip.setFont(newFont("微軟雅黑", Font.PLAIN, 14));
lblTip.setHorizontalAlignment(SwingConstants.CENTER);
contentPane.add(lblTip,BorderLayout.SOUTH);
/**
* 創建標籤lblLight置於JFrame窗體中的中間，設置標籤label_2中的圖標位置和樣式
*/
lblLight= new JLabel("");
lblLight.setHorizontalAlignment(SwingConstants.CENTER);
lblLight.setIcon(newImageIcon(Focus.class.getResource("dark.png")));
contentPane.add(lblLight,BorderLayout.CENTER);
}
}
運行結果：
3.2捕獲窗體狀態變化事件
代碼實現：
public classWindowStateListener_Example extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicstatic void main(String args[]) {
WindowStateListener_Exampleframe = new WindowStateListener_Example();
frame.setVisible(true);
}
publicWindowStateListener_Example() {
super();
//爲窗體添加狀態事件監聽器
addWindowStateListener(newMyWindowStateListener());
setTitle("捕獲窗體狀態事件");
setBounds(100,100, 500, 375);
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
}
privateclass MyWindowStateListener implements WindowStateListener {
publicvoid windowStateChanged(WindowEvent e) {
intoldState = e.getOldState();// 獲得窗體以前的狀態
intnewState = e.getNewState();// 獲得窗體現在的狀態
Stringfrom = "";// 標識窗體以前狀態的中文字符串
Stringto = "";// 標識窗體現在狀態的中文字符串
switch(oldState) {// 判斷窗臺以前的狀態
caseFrame.NORMAL:// 窗體處於正常化
from= "正常化";
break;
caseFrame.MAXIMIZED_BOTH:// 窗體處於最大化
from= "最大化";
break;
default://窗體處於最小化
from= "最小化";
}
switch(newState) {// 判斷窗臺現在的狀態
caseFrame.NORMAL:// 窗體處於正常化
to= "正常化";
break;
caseFrame.MAXIMIZED_BOTH:// 窗體處於最大化
to= "最大化";
break;
default://窗體處於最小化
to= "最小化";
}
System.out.println(from+ "——>" + to);
}
}
}
運行結果：
3.3捕獲其他窗體事件
代碼實現：
public class WindowListener_Example extendsJFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicstatic void main(String args[]) {
WindowListener_Exampleframe = new WindowListener_Example();
frame.setVisible(true);
}
publicWindowListener_Example() {
super();
addWindowListener(newMyWindowListener());// 爲窗體添加其他事件監聽器
setTitle("捕獲其他窗體事件");
setBounds(100,100, 500, 375);
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
}
privateclass MyWindowListener implements WindowListener {
publicvoid windowActivated(WindowEvent e) {// 窗體被激活時觸發
System.out.println("窗口被激活！");
}
publicvoid windowOpened(WindowEvent e) {// 窗體被打開時觸發
System.out.println("窗口被打開！");
}
publicvoid windowIconified(WindowEvent e) {// 窗體被最小化時觸發
System.out.println("窗口被最小化！");
}
publicvoid windowDeiconified(WindowEvent e) {// 窗體被非最小化時觸發
System.out.println("窗口被非最小化！");
}
publicvoid windowClosing(WindowEvent e) {// 窗體將要被關閉時觸發
System.out.println("窗口將要被關閉！");
}
//窗體不再處於激活狀態時觸發
publicvoid windowDeactivated(WindowEvent e) {
System.out.println("窗口不再處於激活狀態！");
}
publicvoid windowClosed(WindowEvent e) {// 窗體已經被關閉時觸發
System.out.println("窗口已經被關閉！");
}
}
}
運行結果：
4選項事件
代碼實現：
/**
* 省市聯動菜單（下拉列表）之戶口本（局部）
*/
public classHouseRegister extends JFrame { // 創建一個“戶口本”類繼承JFrame
//聲明“戶口本”類中的成員組件
privateJComboBox<String> cboxProvince;
privateJComboBox<String> cboxCity;
privateJComboBox<String> cboxNProvince;
privateJComboBox<String> cboxNCity;
String[]strProvinces={ "黑龍江省", "吉林省", "遼寧省" };//存儲省份
//存儲黑龍江省的所有地級市
String[]strHLJ={ "哈爾濱", "齊齊哈爾", "牡丹江", "大慶", "伊春", "雙鴨山","鶴崗", "雞西", "佳木斯", "七臺河", "黑河", "綏化", "大興安嶺" };
//存儲吉林省的所有地級市
String[]strJL={ "長春", "延邊", "吉林", "白山", "白城", "四平", "松原", "遼源", "大安", "通化" };
//存儲遼寧省的所有地級市
String[]strLN={ "瀋陽", "大連", "葫蘆島", "旅順", "本溪", "撫順","鐵嶺", "遼陽", "營口", "阜新", "朝陽", "錦州", "丹東", "鞍山" };
/**
* 根據選擇的省顯示其所有地級市
* @param item ItemEvent類型，表示下拉列表中的選擇項
* @param cbox JComboBox類型，表示JComboBox組件
*/
privatevoid getCity(ItemEvent item, JComboBox<String> cbox){
StringstrProvince=String.valueOf(item.getItem());//獲取選中項
if(strProvince.equals("黑龍江省")) {
cbox.setModel(newDefaultComboBoxModel<String>(strHLJ));
}else if (strProvince.equals("吉林省")) {
cbox.setModel(newDefaultComboBoxModel<String>(strJL));
}else if (strProvince.equals("遼寧省")) {
cbox.setModel(newDefaultComboBoxModel<String>(strLN));
}
}
/**
* 主方法
*/
publicstatic void main(String[] args) {
newHouseRegister().setVisible(true); // 創建HouseRegister對象frame
}
/**
* 創建JFrame窗體
*/
publicHouseRegister() { // HouseRegister的構造方法
setTitle("戶口本（局部）");// 設置窗體題目
NPanelcontentPanel = new NPanel();// 創建一個面板對象
contentPanel.setLayout(null);//設置面板爲絕對佈局
getContentPane().add(contentPanel);//將面板添加到窗體上
setResizable(false);// 不可改變窗體大小
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 設置窗體關閉的方式
setBounds(100,100, 592, 190);
/**
* 創建下拉列表cboxProvince置於面板contentPane中，設置複選框裏的Model值、複選框的大小
*/
cboxProvince= new JComboBox<String>();
cboxProvince.setModel(newDefaultComboBoxModel<String>(strProvinces));
cboxProvince.addItemListener(newItemListener() {//添加選項事件監聽器
@Override
publicvoid itemStateChanged(ItemEvent arg0) {//重寫選項發生變化時的方法
getCity(arg0,cboxCity);//調用自定義方法實現省市聯動
}
});
cboxProvince.setBounds(69,97, 85, 21);
contentPanel.add(cboxProvince);
/**
* 創建下拉列表“市”，設置該下拉列表中的選項值，橫座標、縱座標、寬高，把下拉列表“市”放到面板contentPane中
*/
cboxCity= new JComboBox<String>(); // 創建下拉列表cboxCity
cboxCity.setModel(newDefaultComboBoxModel<String>(strHLJ));
cboxCity.setBounds(158,97, 85, 21); // 設置下拉列表的大小
contentPanel.add(cboxCity);// 將下拉列表cboxCity置於面板panel中
/**
* 創建下拉列表cboxNProvince置於面板contentPane中，設置複選框裏的Model值、複選框的大小
*/
cboxNProvince= new JComboBox<String>();
cboxNProvince.setModel(newDefaultComboBoxModel<String>(strProvinces));
cboxNProvince.addItemListener(newItemListener() {//添加選項事件監聽器
@Override
publicvoid itemStateChanged(ItemEvent arg0) {//重寫選項發生變化時的方法
getCity(arg0,cboxNCity);//調用自定義方法實現省市聯動
}
});
cboxNProvince.setBounds(69,131, 85, 21);
contentPanel.add(cboxNProvince);
/**
* 創建下拉列表“市”，設置該下拉列表中的選項值，橫座標、縱座標、寬高，把下拉列表“市”放到面板contentPane中
*/
cboxNCity= new JComboBox<String>(); // 創建下拉列表cboxNProvince
cboxNCity.setModel(newDefaultComboBoxModel<String>(strHLJ));
cboxNCity.setBounds(158,131, 85, 21); // 設置下拉列表的大小
contentPanel.add(cboxNCity);// 將下拉列表cboxNProvince置於面板panel中
}
classNPanel extends JPanel {// 重繪面板
@Override
protectedvoid paintComponent(Graphics arg0) {// 重寫事件，用來重繪面板背景
intx = 0, y = 0;// 定義重繪的起始點座標
//使用指定圖片創建ImageIcon對象
ImageIconimgBack = new ImageIcon(getClass().getResource("back.png"));
//按面板大小重繪圖片
arg0.drawImage(imgBack.getImage(),x, y, getSize().width, getSize().height, this);
while(true) {
arg0.drawImage(imgBack.getImage(),x, y, this);// 按原始大小重繪圖片
if(x > getSize().width && y > getSize().height)
break;
//保證窗口大於圖片時，圖片仍能夠覆蓋整個窗口
if(x > getSize().width) {
x= 0;
y+= imgBack.getIconHeight();
}else
x+= imgBack.getIconWidth();
}
}
}
}
運行結果：
