java基礎學習總結——GUI編程(二)

時間 2019-11-10

標籤 java 基礎學習總結 gui 編程欄目 Java 简体版

原文原文鏈接

1、事件監聽

測試代碼一：java

 1 package cn.javastudy.summary;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 
 6 public class TestActionEvent {
 7     public static void main(String args[]) {
 8         Frame f = new Frame("TestActionEvent");
 9         Button btn = new Button("Press Me");
10         Monitor m = new Monitor();/* 建立一個監聽對象 */
11         btn.addActionListener(m);
12         /*
13          * 把監聽加入到按鈕裏面，監聽按鈕的動做， 當按鈕觸發打擊事件時，就會返回一個監聽對象e 而後就會自動執行actionPerformed方法
14          */
15         f.add(btn, BorderLayout.CENTER);
16         f.pack();
17         addWindowClosingEvent(f);
18         /* 調用這個方法能夠自動給Frame窗體裏面的子圖形元素一個合適的初始大小 */
19         f.setVisible(true);
20     }
21     
22     /**
23      * 點擊窗體上的關閉按鈕關閉窗體
24      * @param f
25      */
26     private static void addWindowClosingEvent(Frame f){
27         f.addWindowListener(new WindowAdapter() {
28             @Override
29             public void windowClosing(WindowEvent arg0) {
30                 System.exit(0);
31             }
32             
33         });
34     }
35 }
36 
37 /*
38  * 自定義Monitor(監聽)類實現事件監聽接口ActionListener 一個類要想成爲監聽類，那麼必須實現ActionListener接口
39  */
40 class Monitor implements ActionListener {
41     /* 重寫ActionListener接口裏面的actionPerformed(ActionEvent e)方法 */
42     public void actionPerformed(ActionEvent e) {
43         System.out.println("A Button has been Pressed");
44     }
45 }

測試代碼二：編程

 1 package cn.javastudy.summary;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 public class TestActionEvent2{
 6     public static void main(String args[]){
 7         Frame f = new Frame("TestActionEvent");
 8         Button btn1 = new Button("start");
 9         Button btn2 = new Button("stop");
10         Monitor2 m2 = new Monitor2();//建立監聽對象
11         btn1.addActionListener(m2);
12         /*一個監聽對象同時監聽兩個按鈕的動做*/
13         btn2.addActionListener(m2);
14         btn2.setActionCommand("GameOver");//設置btn2的執行單擊命令後的返回信息
15         f.add(btn1,BorderLayout.NORTH);
16         f.add(btn2,BorderLayout.CENTER);
17         
18         f.pack();
19         f.setVisible(true);
20     }
21 }
22 
23 class Monitor2 implements ActionListener{
24     public void actionPerformed(ActionEvent e){
25         System.out.println("a button has been pressed,"+"the relative info is:\n"+e.getActionCommand());
26         /*使用返回的監聽對象e調用getActionCommand()方法獲取兩個按鈕執行單擊命令後的返回信息
27         根據返回信息的不一樣區分開當前操做的是哪個按鈕,btn1沒有使用setActionCommand()方法設置
28         則btn1返回的信息就是按鈕上顯示的文本*/
29     }
30 }

2、TextField事件監聽

測試代碼：ide

 1 package cn.javastudy.summary;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 
 6 public class TestTextField {
 7     public static void main(String args[]) {
 8         new MyFrameTextField();
 9     }
10 }
11 
12 class MyFrameTextField extends Frame {
13     MyFrameTextField() {
14         TextField tf = new TextField();
15         add(tf);
16         tf.addActionListener(new Monitor3());
17         tf.setEchoChar('*');
18         /*
19          * 這個setEchoChar()方法是設置文本框輸入時顯示的字符，這裏設置爲*， 
20          * 這樣輸入任何內容就都以*顯示出來，不過打印出來時依然能夠看到輸入的內容
21          */
22         setVisible(true);
23         pack();
24     }
25 }
26 
27 class Monitor3 implements ActionListener {
28     /*
29      * 接口裏面的全部方法都是public(公共的) 
30      * 因此從API文檔複製void actionPerformed(ActionEvent e)時 要在void前面加上public
31      */
32     public void actionPerformed(ActionEvent e) {
33         /* 事件的相關信息都封裝在了對象e裏面，經過對象e的相關方法就能夠獲取事件的相關信息 */
34         TextField tf = (TextField) e.getSource();
35         /*
36          * getSource()方法是拿到事件源，注意：拿到這個事件源的時候，
37          * 是把它看成TextField的父類來對待 
38          * getSource()方法的定義是：「public Object getSource()」返回值是一個Object對象，
39          * 因此要強制轉換成TextField類型的對象 
40          * 在一個類裏面想訪問另一個類的事件源對象能夠經過getSource()方法
41          */
42         System.out.println(tf.getText());// tf.getText()是取得文本框裏面的內容
43         tf.setText("");// 把文本框裏面的內容清空
44     }
45 }

使用TextField類實現簡單的計算器佈局

 1 package cn.javastudy.summary;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 
 6 public class TestMath {
 7     public static void main(String args[]) {
 8         new TFFrame();
 9     }
10 }
11 
12 /* 這裏主要是完成計算器元素的佈局 */
13 class TFFrame extends Frame {
14     TFFrame() {
15         /*
16          * 建立3個文本框，並指定其初始大小分別爲10個字符和15個字符的大小 這裏使用的是TextField類的另一種構造方法 public TextField(int columns)
17          */
18         TextField num1 = new TextField(10);
19         TextField num2 = new TextField(10);
20         TextField num3 = new TextField(15);
21         /* 建立等號按鈕 */
22         Button btnEqual = new Button("=");
23         btnEqual.addActionListener(new MyMonitor(num1, num2, num3));
24         /* 給等號按鈕加上監聽，讓點擊按鈕後有響應事件發生 */
25         Label lblPlus = new Label("+");
26         /* 「+」是一個靜態文本，因此使用Label類建立一個靜態文本對象 */
27         setLayout(new FlowLayout());
28         /* 把Frame默認的BorderLayout佈局改爲FlowLayout佈局 */
29         add(num1);
30         add(lblPlus);
31         add(num2);
32         add(btnEqual);
33         add(num3);
34         pack();
35         setVisible(true);
36 
37     }
38 }
39 
40 class MyMonitor implements ActionListener {
41     TextField num1, num2, num3;
42 
43     /*
44      * 爲了使對按鈕的監聽可以對文本框也起做用， 
45      * 因此在自定義類MyMonitor裏面定義三個TextField類型的對象 num1,num2,num3,
46      * 而且定義了MyMonitor類的一個構造方法 這個構造方法帶有三個TextField類型的參數，
47      * 用於接收 從TFFrame類裏面傳遞過來的三個TextField類型的參數 
48      * 而後把接收到的三個TextField類型的參數賦值給在本類中聲明的 三個TextField類型的參數num1,num2,num3 而後再在actionPerformed()方法裏面處理num1,num2,num3
49      */
50     public MyMonitor(TextField num1, TextField num2, TextField num3) {
51         this.num1 = num1;
52         this.num2 = num2;
53         this.num3 = num3;
54     }
55 
56     public void actionPerformed(ActionEvent e) {
57         /* 事件的相關信息都封裝在了對象e裏面，經過對象e的相關方法就能夠獲取事件的相關信息 */
58         int n1 = Integer.parseInt(num1.getText());/* num1對象調用getText()方法取得本身顯示的文本字符串 */
59         int n2 = Integer.parseInt(num2.getText());/* num2對象調用getText()方法取得本身顯示的文本字符串 */
60         num3.setText("" + (n1 + n2));/* num3對象調用setText()方法設置本身的顯示文本 */
61         num1.setText("");
62         /* 計算結束後清空num1,num2文本框裏面的內容 */
63         num2.setText("");
64         // num3.setText(String.valueOf((n1+n2)));
65         /* 字符串與任意類型的數據使用「+」鏈接時獲得的必定是字符串，
66          * 這裏使用一個空字符串與int類型的數鏈接，這樣就能夠直接把(n1+n2)獲得的int類型的數隱式地轉換成字符串了，
67          * 這是一種把別的基礎數據類型轉換成字符串的一個小技巧。
68          * 也可使用「String.valueOf((n1+n2))」把(n1+n2)的和轉換成字符串 
69          */
70     }
71 }

JAVA裏面的經典用法：在一個類裏面持有另一個類的引用測試

 1 package cn.javastudy.summary;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 
 6 public class TestMath1 {
 7     public static void main(String args[]) {
 8         new TTMyFrame().launchFrame();
 9         /* 建立出TTMyFrame對象後調用lauchFrame()方法把計算器窗體顯示出來 */
10     }
11 }
12 
13 /* 作好計算器的窗體界面 */
14 class TTMyFrame extends Frame {
15     /* 把設計計算器窗體的代碼封裝成一個方法 */
16     TextField num1, num2, num3;
17 
18     public void launchFrame() {
19         num1 = new TextField(10);
20         num2 = new TextField(15);
21         num3 = new TextField(15);
22         Label lblPlus = new Label("+");
23         Button btnEqual = new Button("=");
24         btnEqual.addActionListener(new MyMonitorbtnEqual(this));
25         setLayout(new FlowLayout());
26         add(num1);
27         add(lblPlus);
28         add(num2);
29         add(btnEqual);
30         add(num3);
31         pack();
32         setVisible(true);
33     }
34 }
35 
36 /*
37  * 這裏經過取得TTMyFrame類的引用，而後使用這個引用去訪問TTMyFrame類裏面的成員變量 
38  * 這種作法比上一種直接去訪問TTMyFrame類裏面的成員變量要好得多，
39  * 由於如今不須要知道 TTMyFrame類裏面有哪些成員變量了，
40  * 如今要訪問TTMyFrame類裏面的成員變量，直接使用 TTMyFrame類對象的引用去訪問便可，
41  * 這個TTMyFrame類的對象比如是一個大管家， 而我告訴大管家，我要訪問TTMyFrame類裏面的那些成員變量，
42  * 大管家的引用就會去幫我找，再也不須要我本身去找了。 
43  * 這種在一個類裏面持有另外一個類的引用的用法是一種很是典型的用法 
44  * 使用獲取到的引用就能夠在一個類裏面訪問另外一個類的全部成員了
45  */
46 class MyMonitorbtnEqual implements ActionListener {
47     TTMyFrame ttmf = null;
48 
49     public MyMonitorbtnEqual(TTMyFrame ttmf) {
50         this.ttmf = ttmf;
51     }
52 
53     public void actionPerformed(ActionEvent e) {
54         int n1 = Integer.parseInt(ttmf.num1.getText());
55         int n2 = Integer.parseInt(ttmf.num2.getText());
56         ttmf.num3.setText("" + (n1 + n2));
57         ttmf.num1.setText("");
58         ttmf.num2.setText("");
59     }
60 }

運行結果以下：this

3、內部類

內部類的使用範例：spa

 1 package cn.javastudy.summary;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 
 6 public class TestMath3 {
 7 
 8     public static void main(String args[]) {
 9         new MyMathFrame().launchFrame();
10     }
11 }
12 
13 class MyMathFrame extends Frame {
14     TextField num1, num2, num3;
15 
16     public void launchFrame() {
17         num1 = new TextField(10);
18         num2 = new TextField(15);
19         num3 = new TextField(15);
20         Label lblPlus = new Label("+");
21         Button btnEqual = new Button("=");
22         btnEqual.addActionListener(new MyMonitor());
23         setLayout(new FlowLayout());
24         add(num1);
25         add(lblPlus);
26         add(num2);
27         add(btnEqual);
28         add(num3);
29         pack();
30         setVisible(true);
31     }
32 
33     /*
34      * 這個MyMonitor類是內部類，它在MyFrame類裏面定義 MyFrame類稱爲MyMonitor類的包裝類
35      */
36     /*
37      * 使用內部類的好處： 
38      * 第一個巨大的好處就是能夠暢通無阻地訪問外部類(即內部類的包裝類)的全部成員變量和方法 
39      * 如這裏的在MyFrame類(外部類)定義的三個成員變量num1,num2,num3， 
40      * 在MyMonitor(內部類)裏面就能夠直接訪問 
41      * 這至關於在建立外部類對象時內部類對象默認就擁有了一個外部類對象的引用
42      */
43     private class MyMonitor implements ActionListener {
44         public void actionPerformed(ActionEvent e) {
45             int n1 = Integer.parseInt(num1.getText());
46             int n2 = Integer.parseInt(num2.getText());
47             num3.setText("" + (n1 + n2));
48             num1.setText("");
49             num2.setText("");
50         }
51     }
52 }

內部類帶來的巨大好處是：設計

能夠很方便地訪問外部類定義的成員變量和方法
當某一個類不須要其餘類訪問的時候就把這個類聲明爲內部類。

4、Graphics 類

測試代碼：code

 1 package cn.javastudy.summary;
 2 
 3 import java.awt.*;
 4 public class TestPaint{
 5     public static void main(String args[]){
 6         new MyPaint().launchFrame();
 7         /*在main()方法裏面並無顯示調用paint(Graphics g)方法
 8         但是當建立出Frame窗體後卻能夠看到Frame窗體上畫出了
 9         圓和矩形，這是由於paint()方法是一個比較特殊的方法
10         在建立Frame窗體時會自動隱式調用
11         當咱們把Frame窗體最小化又再次打開時，又會再次調用
12         paint()方法從新把圓和矩形在Frame窗體上畫出來
13 　　　　即每次須要重畫Frame窗體的時候就會自動調用paint()方法*/
14     }
15 }
16 
17 class MyPaint extends Frame{
18     public void launchFrame(){
19         setBounds(200,200,640,480);
20         setVisible(true);
21     }
22     
23     public void paint(Graphics g){
24         /*paint(Graphics g)方法有一個Graphics類型的參數g
25         咱們能夠把這個g看成是一個畫家，這個畫家手裏拿着一隻畫筆
26         咱們經過設置畫筆的顏色與形狀來畫出咱們想要的各類各樣的圖像*/
27         /*設置畫筆的顏色*/
28         g.setColor(Color.red);
29         g.fillOval(100,100,100,100);/*畫一個實心橢圓*/
30         g.setColor(Color.green);
31         g.fillRect(150,200,200,200);/*畫一個實心矩形*/
32         /*這下面的兩行代碼是爲了寫程序的良好編程習慣而寫的
33         前面設置了畫筆的顏色，如今就應該把畫筆的初始顏色恢復過來
34         就至關因而畫家用完畫筆以後把畫筆上的顏色清理掉同樣*/
35         Color c = g.getColor();
36         g.setColor(c);
37     }
38 }

運行結果：orm

5、鼠標事件適配器

測試代碼：

 1 package cn.galc.test;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 import java.util.*;
 6 public class MyMouseAdapter{
 7   public static void main(String args[]) {
 8     new MyFrame("drawing...");
 9   }
10 }
11 
12 class MyFrame extends Frame {
13   ArrayList points = null;
14   MyFrame(String s) {
15     super(s);
16     points = new ArrayList(); 
17     setLayout(null);
18     setBounds(300,300,400,300); 
19     this.setBackground(new Color(204,204,255));
20     setVisible(true);
21     this.addMouseListener(new Monitor());
22     }
23     
24     public void paint(Graphics g) {
25     Iterator i = points.iterator();
26     while(i.hasNext()){
27       Point p = (Point)i.next();
28       g.setColor(Color.BLUE);
29       g.fillOval(p.x,p.y,10,10);
30       
31     }
32   }
33   
34   public void addPoint(Point p){
35     points.add(p);
36   }
37 }
38 
39 class Monitor extends MouseAdapter {
40   public void mousePressed(MouseEvent e) {
41     MyFrame f = (MyFrame)e.getSource();
42     f.addPoint(new Point(e.getX(),e.getY()));
43     f.repaint();
44   }
45 }

6、window事件

測試代碼：

 1 package cn.galc.test;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 public class TestWindowClose{
 6     public static void main(String args[]){
 7         new WindowFrame("關閉WindowFrame");
 8     }
 9 }
10 
11 class WindowFrame extends Frame{
12     public WindowFrame(String s){
13         super(s);
14         setBounds(200,200,400,300);
15         setLayout(null);
16         setBackground(new Color(204,204,255));
17         setVisible(true);
18         this.addWindowListener(new WindowMonitor());
19 /*監聽本窗體的動做，把全部的動做信息封裝成一個對象傳遞到監聽類裏面*/
20         
21         this.addWindowListener(
22         /*在一個方法裏面定義一個類，這個類稱爲局部類，也叫匿名的內部類，
23         這裏的{……代碼……}裏面的代碼很像一個類的類體，只不過這個類沒有名字，因此叫匿名類
24         在這裏是把這個匿名類當成WindowAdapter類來使用，語法上這樣寫的本質意義是至關於這個匿名類
25         從WindowAdapter類繼承，如今new了一個匿名類的對象出來而後把這個對象當成WindowAdapter來使用
26         這個匿名類出了()就沒有人認識了*/
27             new WindowAdapter(){
28                 public void windowClosing(WindowEvent e){
29                     setVisible(false);
30                     System.exit(-1);
31                 }
32             }
33         );
34     }
35     
36     /*這裏也是將監聽類定義爲內部類*/
37     class WindowMonitor extends WindowAdapter{
38         /*WindowAdapter(Window適配器)類實現了WindowListener監聽接口
39         重寫了WindowListener接口裏面的全部方法
40         若是直接使用自定義WindowMonitor類直接去
41         實現WindowListener接口，那麼就得要重寫WindowListener接口
42         裏面的全部方法，但如今只須要用到這些方法裏面的其中一個方法
43         因此採用繼承實現WindowListener監聽接口的一個子類
44         並重寫這個子類裏面須要用到的那個方法便可
45         這種作法比直接實現WindowListener監聽接口要重寫不少個用不到的方法要簡潔方便得多*/
46 /*重寫須要用到的windowClosing(WindowEvent e)方法*/
47         public void windowClosing(WindowEvent e){
48                 setVisible(false);/*將窗體設置爲不顯示，便可實現窗體關閉*/
49                 System.exit(0);/*正常退出*/
50             }
51     }
52 }

7、鍵盤響應事件——KeyEvent

測試代碼：

 1 package cn.galc.test;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 public class TestKeyEvent{
 6     public static void main(String args[]){
 7         new KeyFrame("鍵盤響應事件");
 8     }
 9 }
10 
11 class KeyFrame extends Frame{
12     public KeyFrame(String s){
13             super(s);
14             setBounds(200,200,400,300);
15             setLayout(null);
16             setVisible(true);
17             addKeyListener(new KeyMonitor());
18         }
19     /*把自定義的鍵盤的監聽類定義爲內部類
20     這個監聽類從鍵盤適配器KeyAdapter類繼承
21     從KeyAdapter類繼承也是爲了能夠簡潔方便
22     只須要重寫須要用到的方法便可，這種作法比
23     直接實現KeyListener接口要簡單方便，若是
24     直接實現KeyListener接口就要把KeyListener
25     接口裏面的全部方法重寫一遍，但真正用到的
26     只有一個方法，這樣重寫其餘的方法但又用不到
27     不免會作無用功*/    
28     class KeyMonitor extends KeyAdapter{
29         public void keyPressed(KeyEvent e){
30                 int keycode = e.getKeyCode();
31             /*使用getKeyCode()方法獲取按鍵的虛擬碼*/
32             /*若是獲取到的鍵的虛擬碼等於up鍵的虛擬碼
33             則表示當前按下的鍵是up鍵
34             KeyEvent.VK_UP表示取得up鍵的虛擬碼
35             鍵盤中的每個鍵都對應有一個虛擬碼
36             這些虛擬碼在KeyEvent類裏面都被定義爲靜態常量
37             因此可使用「類名.靜態常量名」的形式訪問獲得這些靜態常量*/
38                 if(keycode == KeyEvent.VK_UP){
39                         System.out.println("你按的是up鍵");
40                     }
41             }
42         }
43 }
44 /*鍵盤的處理事件是這樣的：每個鍵都對應着一個虛擬的碼，
45 當按下某一個鍵時，系統就會去找這個鍵對應的虛擬的碼，以此來肯定當前按下的是那個鍵
46 */