黑马程序员——java之GUI编程

------------android培训、java培训、期待与您交流！ -------------

1、GUI的概述：

Graphical user Interface(图形化接口)

对象都在java.awt（abstract windows ToolKit首相窗口工具包），需要调用本地系统方法实现功能（依赖平台，造成观感不同），属于重量级。

Javax.swing：在Awt基础上，建立了一套图形化界面系统，提供了更多组建，而且完全有java实现，增强了移植性，属于轻量级。

CLI （command line User Interface）用户命令行接口

2、继承关系图

 

3、容器中的组件的排放方式，就是布局。

 

常见的布局管理器：

FlowLayout（流式布局管理器）

从左到右的顺序排列。

    Panel默认的布局管理器。

BorderLayout（边界布局管理器）

东，南，西，北，中

    Frame默认的布局管理器。

GridLayout（网格布局管理器）

规则的矩阵

CardLayout（卡片布局管理器）

选项卡

GridBagLayout（网格包布局管理器）

非规则的矩阵

坐标式布局？没用过，查找。用开发工具的扩展包，用画布更方便类似于VB的开发。

 

 

4、创建图形化界面：

1，创建frame窗体。

2，对窗体进行基本设置。

比如大小，位置，布局。

3，定义组件。

4，将组件通过窗体的add方法添加到窗体中。

5，让窗体显示，通过setVisible(true)

5、事件监听机制的特点：

1，事件源。

2，事件。

3，监听器。

4，事件处理。

事件源：就是awt包或者swing包中的那些图形界面组件。

事件：每一个事件源都有自己特有的对应事件和共性事件。

监听器：将可以触发某一个事件的动作（不只一个动作）都已经封装到了监听器中。

以上三者，在java中都已经定义好了。

直接获取其对象来用就可以了。

我们要做的事情是，就是对产生的动作进行处理。

6、//让按钮具备退出程序的功能

/*

按钮就是事件源。

那么选择哪个监听器呢？

通过关闭窗体示例了解到，想要知道哪个组件具备什么样的特有监听器。

需要查看该组件对象的功能。

 通过查阅button的描述。发现按钮支持一个特有监听addActionListener。

因为其接口的方法只有一个所以不需要适配器（adapter）（适配器的目的是为了，实现接口中的方法，让适配器的子类覆盖需要的时间就行，而不用覆盖全部），一般当时间超过三个时，就会设计适配器。

常见的侦听器：

|——java.util  EventListener

     |——java.awt.event ActionListener（一个）

   |——java.awt.event ContainerListener（两个方法）

   |——java.awt.event KeyListener（有 KeyAdapter 类）

   |——java.awt.event MouseListener（有MouseAdapter 类）

   |——java.awt.event TextListener（一个方法）

   |——java.awt.event  WindowListener（有WindowAdapter类）

示例代码：

[java]  view plain copy print ?

1. import java.awt.*;    
2. import java.awt.event.*;    
3. class  FrameDemo    
4. {    
5.     //定义该图形中所需的组件的引用。    
6.     private Frame f;    
7.     private Button but;    
8.     FrameDemo()   {  //这是一种良好的编程，否则构造函数看起来一团糟  
9.         init();    
10.     }    
11.     //初始化图形界面    
12.     public void init()//初始化    
13.     {    
14.         f= new Frame("day22-MyFrame");    
15.         //对frame进行基本设置。    
16.         f.setBounds(300,100,600,500);  //直接设置位置、大小  
17.         f.setLayout(new FlowLayout());  //流式布局  
18.         but = new Button("my button");    
19.         //将组件添加到Frame中    
20.         f.add(but);     
21.         //加载一下窗体上的事件。    
22.         myEvent();    
23.         //显示窗体    
24.         f.setVisible(true);    
25.     }    
26.     //最好把事件处理和GUI组件的基本初始化分离开    
27.     public void myEvent()//这些都是组件的特有事件，还有共性事件。    
28.     {    
29.         f.addWindowListener(new WindowAdapter()  //匿名内部类、覆盖父类的close方法  
30.         {    
31.             public void windowClosing(WindowEvent e)    
32.             {    
33.                 System.out.println("关闭窗口");    
34.                 System.exit(0);//这个方法的 关闭的是虚拟机，退出虚拟机，当然就退出了程序      
35.             }    
36.         });    
37.         //让按钮具备退出程序的功能。    
38.         /* 按钮就是事件源，那么选择哪一个监听器呢？通过关闭窗体实例了解到。想要知道那个组件具备什么样的特与监听器，  
39.         需要查看该组件对象的功能。那么通过查阅button的描述，发现支持一个特有监听addActionListener(ActionListener l)；  
40.         是没有适配器的少数组件之一，只要事件方法超过3个的组件，都有配适器（Adapter）；  
41.         */    
42.         but.addActionListener(new ActionListener()  {    
43.             public void actionPerformed(ActionEvent e) {    
44.                 System.out.println("退出，按钮干的");  //验证用的  
45.                 System.exit(0);    
46.             }    
47.         });    
48.     }    
49.     //主函数，用于测试    
50.     public static void main(String[] args)    {    
51.         new FrameDemo();    
52.     }    
53. }    

7、鼠标事件、键盘事件

鼠标事件

MouseEvent，它是所有组件都有的共性事件，所以它的添加监听器方法是定义在Component抽象类中，键盘事件也是共性事件。

它对应的是MouseListener。

鼠标单击次数是定义在MouseEvent事件对象中的，在MouseEvent事件对象中还能还封装了触发事件的是鼠标的一些相关信息。

MouseListener有对应的MouseAdapter。

 

键盘事件

KeyEvent事件对象，内部封装了对应于键盘各个键的字段和触发事件的具体按键的信息。

这些信息可以通过该对象对外提供的方法获取到。

keyEvent 对应的事件监听器的KeyListener·，有对应的KeyAdapter。

[java]  view plain copy print ?

1. 代码示例：  
2. import java.awt.*;    
3. import java.awt.event.*;    
4. class MouseAndKeyEvent     
5. {    
6.     //定义该图形中所需的组件的引用。    
7.     private Frame f;    
8.     private Button but;    
9.     private TextField tf;    
10.     
11.     MouseAndKeyEvent()    
12.     {    
13.         init();    
14.     }    
15.     public void init()//初始化    
16.     {    
17.         f= new Frame("day22-MyFrame");    
18.     
19.         //对frame进行基本设置。    
20.         f.setBounds(300,100,600,500);    
21.         f.setLayout(new FlowLayout());    
22.     
23.         but = new Button("my button");    
24.         tf = new TextField(10);    
25.             
26.         f.add(but);  //添加组件的顺序很重要  
27.         f.add(tf);    
28.         
29.         myEvent();    
30.         f.setVisible(true);    
31.     }    
32.     public void myEvent()    
33.     {    
34.         f.addWindowListener(new WindowAdapter()    
35.         {    
36.             public void windowClosing(WindowEvent e)    
37.             {    
38.                 System.exit(0);    
39.             }    
40.         });    
41.         //给but添加一个键盘侦听器    
42.         but.addKeyListener(new KeyAdapter()    
43.         {    
44.             private int count;    
45.             public void keyPressed(KeyEvent e)    
46.             {    
47.                 //判断组合键    
48.                 if(e.isControlDown() && e.getKeyCode()==KeyEvent.VK_ENTER)  
49.                      //从父类InputEvent 找isControlDown    
50.                     //System.exit(0);    
51.                     System.out.println("Ctrl + Enter is down");    
52.                 //System.out.println("按下某个键了---"+count++);    
53.                 //System.out.println(e.getKeyChar());    
54.                 //打印按下的键上在字符串，及键值。    
55. 　　System.out.println(KeyEvent.getKeyText(e.getKeyCode())+"....."+e.getKeyCode());    
56.             }    
57.         });    
58.     
59.         tf.addKeyListener(new KeyAdapter()    
60.         {    
61.             public void keyPressed(KeyEvent e)    
62.             {    
63.                 //模拟QQ登陆，限定键值的范围 （0—9）  
64.                 int code =e.getKeyCode();    
65.                 if(!(code>=KeyEvent.VK_0 && code<=KeyEvent.VK_9))    
66.                 {    
67.                     //不处理，取消掉事件，具有屏蔽键的作用，如果键入是字符非法则不写入文本框。    
68.                     e.consume();//从父类InputEvent中获取的方法consume，不按照默认的方法处理该事件。    
69.                     System.out.println(code + "....是非法的");    
70.                 }    
71.             }    
72.         });    
73.             
74.         //给but添加监听器    
75.         but.addActionListener(new ActionListener()    
76.         {    
77.             public void actionPerformed(ActionEvent e)     
78.             {    
79.                 System.out.println("button action");    
80.             }    
81.     
82.         });    
83.         
84.         //给but添加鼠标监听器    
85.         but.addMouseListener(new MouseAdapter()    
86.         {    
87.             private int count;    
88.             private int clickCount;    
89.             public void mouseEntered(MouseEvent e)     
90.             {    
91.                 System.out.println("鼠标进入组件区域啦--"+count++);                  
92.             }    
93.             public void mouseClicked(MouseEvent e)     
94.             {    
95.                 if(e.getClickCount()==2)    
96.                 System.out.println("鼠标双击Button了--"+clickCount++);    
97.             }    
98.     
99.         });    
100.     }    
101.     
102.     public static void main(String[] args)     
103.     {    
104.         new MouseAndKeyEvent();    
105.     
106.     }    
107. }    

 

8、对话框

Dialog在构造时，可以设置模式，如果为true那么，在该对话框关闭前，程序的其他窗口都不能被操作。

其体系如下：

|----Dialog

         |----FileDialog文件对话框，可以从中选择文件。

         |----JDialog

模拟打开文件系统，从下边的代码可以看出，其实只要图形化做出来，添加事件的处理办法都平时学的就一样了，知识调用了一下方法。

[java]  view plain copy print ?

1. import java.awt.Button;  
2. import java.awt.Dialog;  
3. import java.awt.FlowLayout;  
4. import java.awt.Frame;  
5. import java.awt.Label;  
6. import java.awt.TextArea;  
7. import java.awt.TextField;  
8.   
9. import java.awt.event.*;  
10. import java.io.File;  
11. public class MyWindowsDemo {  
12.   
13.     /** 
14.      * @param args 
15.      */  
16.    //创建所需的组件  
17.     private Frame f;  
18.     private Button but;  
19.     private TextField tf ;  
20.     private TextArea ta;  
21.     MyWindowsDemo(){  
22.         init();  
23.     }  
24.     public void init(){//初始化图形  
25.         f = new Frame("my windows");  
26.         but = new Button("转到");  
27.         tf = new TextField(55);  
28.         ta = new TextArea(40,70);  
29.           
30.         f.setBounds(300,400,500,500);  
31.         f.setLayout(new FlowLayout(0));  
32.           
33.         f.add(tf);  
34.         f.add(but);  
35.         f.add(ta);  
36.           
37.         myEvent();//添加事件侦听  
38.         f.setVisible(true);  
39.     }  
40.       
41.     private void myEvent(){  
42.           
43.         but.addActionListener(new ActionListener(){  
44.             public void actionPerformed(ActionEvent e){           
45.                 show();//调用方法  
46.             }  
47.         });  
48.         f.addWindowListener(new WindowAdapter(){  
49.             public void windowClosing(WindowEvent e){  
50.                 System.exit(0);  
51.             }  
52.         });  
53.         tf.addKeyListener(new KeyAdapter(){  
54.             public void keyPressed(KeyEvent e){  
55.                 if(e.getKeyCode()==KeyEvent.VK_ENTER){  
56.                     show();               
57.                 }  
58.             }  
59.         });  
60.     }  
61.     private void show(){  
62.         String s = tf.getText();  
63.         File dir = new File(s);  
64.         if(dir.exists()&&dir.isDirectory()){  
65.             ta.setText("");  
66.             String [] file = dir.list();  
67.             for(String name:file){  
68.             ta.append(name+"\r\n");  
69.             }  
70.         }  
71.         else{  
72.   
73.          final  Dialog dl =  
74. 　　new Dialog(f,"error--info",true);//匿名内部类会用到所以用final修饰  
75. 　　  
76.             Label  la = new Label();  
77.             Button butok = new Button("OK");  
78.               
79.             dl.setBounds(200,150,200,200);  
80.             dl.setLayout(new FlowLayout());  
81.               
82.             dl.add(la);  
83.             dl.add(butok);  
84.                           
85.             la.setText("路径错误："+ tf.getText()+" 请重输    ");  
86.           
87.             butok.addActionListener(new ActionListener(){  
88.                 public void actionPerformed(ActionEvent e){  
89.                 dl.setVisible(false);  
90.             }  
91.             });  
92.             dl.addWindowListener(new WindowAdapter(){  
93.                 public void windowClosing(WindowEvent e){  
94.                     System.exit(0);  
95.                 }  
96.             });  
97.               
98.             dl.setVisible(true);  
99.         }  
100.         }  
101.   
102.     public static void main(String[] args) {  
103.         // TODO Auto-generated method stub  
104.         new MyWindowsDemo();  
105.     }  
106. }  

效果图

 

9、菜单

 

主要由三个类组成：MenuBar，Menu和MenuItem。

MenuBar：菜单条，里边只能添加Menu。

Menu：可以添加MenuItem菜单条目，如果这个MenuItem是一个Menu，那么这个Menu是一个子菜单。

MenuItem：菜单条目。

注意：其继承体系如下：

|---MenuComponent

         |---- MenuBar

         |---- MenuItem

|-----Menu

 

 

[java]  view plain copy print ?

1. 练习：简单模拟记事本  
2. import java.awt.*;  
3. import java.awt.event.*;  
4. import java.io.BufferedReader;  
5. import java.io.BufferedWriter;  
6. import java.io.File;  
7. import java.io.FileReader;  
8. import java.io.FileWriter;  
9. import java.io.IOException;  
10.   
11. import until.cn.itcast.Print;  
12. public class MyMenuTest {  
13.   
14.     /** 
15.      * @param args 
16.      */  
17.     private Frame f;  
18.     private MenuBar bar;  
19.     private TextArea ta;  
20.     private Menu filemenu;  
21.       
22.     private MenuItem closeMenu,openMenu,saveMenu;  
23.       
24.       
25.       
26.     private FileDialog openDia;  
27.     private FileDialog saveDia;  
28.       
29.     private File file;  
30.       
31.     MyMenuTest(){  
32.         init();  
33.     }  
34.       
35.     public void init(){  
36.         f = new Frame("my menu");  
37.         f.setBounds(200,300,400,500);  
38.           
39.          bar = new MenuBar();  
40.            
41.          ta = new TextArea();  
42.          f.setMenuBar(bar);  
43.            
44.          filemenu = new Menu("文件");  
45.          bar.add(filemenu);  
46.            
47.         closeMenu = new MenuItem("关闭");  
48.         openMenu = new MenuItem("打开");  
49.         saveMenu = new MenuItem("保存");  
50.         filemenu.add(openMenu);  
51.         filemenu.add(saveMenu);  
52.         filemenu.add(closeMenu);  
53.           
54.         openDia = new FileDialog(f,"我要打开",FileDialog.LOAD);  
55.         saveDia = new FileDialog(f,"我要保存",FileDialog.SAVE);  
56.           
57.         f.add(ta);  
58.           
59.         myEvent();  
60.           
61.         f.setVisible(true);  
62.            
63.     }  
64.       
65.     private void myEvent(){  
66.         saveMenu.addActionListener(new ActionListener(){  
67.             public void actionPerformed(ActionEvent e){  
68.                 if(file == null){  
69.                 openDia.setVisible(true);  
70.                 String dir = saveDia.getDirectory();  
71.                 String name = saveDia.getFile();  
72.                 if(dir==null&name==null)  
73.                     return;  
74.                 file = new File(dir,name);  
75.                 }  
76.                 try{  
77.                 BufferedWriterbw   =  
78. 　　                      New  BufferedWriter(newFileWriter(file));  
79.                     String text = ta.getText();  
80.                     Print.sop(text);  
81.                     bw.write(text);  
82.                     bw.close();  
83.                 }catch(IOException ex){  
84.                     throw new RuntimeException("保存失败");  
85.                 }  
86.             }  
87.         });  
88.         openMenu.addActionListener(new ActionListener(){  
89.             public void actionPerformed(ActionEvent e){  
90.                 openDia.setVisible(true);  
91.                 String dir = openDia.getDirectory();  
92.                 String name = openDia.getFile();  
93.                 if(dir==null&name==null)  
94.                     return;  
95.                 ta.setText("");  
96.                 file = new File(dir,name);  
97.                 try{  
98.                 BufferedReader br=  
99.                            new BufferedReader(new FileReader(file));  
100.                     String line = null;  
101.                     while((line = br.readLine())!=null){  
102.                         ta.append(line+"\r\n");  
103.                     }  
104.                       
105.                     br.close();  
106.                 }catch(IOException ex){  
107.                     throw new RuntimeException("读取失败");  
108.                 }  
109.             }  
110.         });  
111.         closeMenu.addActionListener(new ActionListener(){  
112.             public void actionPerformed(ActionEvent e){  
113.                 System.exit(0);  
114.             }  
115.         });  
116.         f.addWindowListener(new WindowAdapter(){  
117.             public void windowClosing(WindowEvent e){  
118.                 System.exit(0);  
119.             }  
120.         });  
121.     }  
122.     public static void main(String[] args) {  
123.         // TODO Auto-generated method stub  
124.         new MyMenuTest();  
125.     }  
126.   
127. }  
128. 　　  

效果图