java之图形化界面（GUI）

一、概述

      用户与计算机进行交换的方式有两种：

GLI：Command lin User Interface（命令行用户接口），也就是常见的dos窗口，它需要记住一些常用的命令，操作不直观方便。

GUI：Graphical User Interface(图形用户接口)，用图形的方式，来显示计算机操作的界面，这样更方便直观。

这两种交换方式就对应两种交互界面：命令行界面和图形化界面。

现在图形化界面是主流。

Java为GUI提供的对象都在java.awt和javax.swing这两个包中。

Awt和Swing

java.awt：bstractWindow ToolKit(抽象窗口工具集，需要调用本地系统方法实现功能，属于重量级控件。

java.swing：在AWT的基础上，建立的一套图形界面系统，其中提供更多的组件，而且完全由java实现，增强了移植性，属于轻量级控件。

小知识点：这里的“重量级”是指跟平台结合紧密，轻量级与之相反。

AWT继承关系图

Frame

Frame是windows的子类，它启动时，要通过setVisiable(true)方法来启动窗口。

GUI中，启动一个窗体就是启动一个前台线程，虽然main函数运行完了，但前台线程没结束，所以程序也就不会结束。

窗口布局管理器

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

常见的布局管理器：•

FlowLayout（流式布局管理器）：从左到右的顺序排列。Panel默认的布局管理器。

BorderLayout（边界布局管理器）：东，南，西，北，中。Frame默认的布局管理器。

GridLayout（网格布局管理器）：规则的矩阵。

CardLayout（卡片布局管理器）：选项卡。

GridBagLayout（网格包布局管理器）：非规则的矩阵。

事件监听机制

 事件监听机制由四部分组成：事件源（组件）、事件（Event）、监听器（Listener）和事件处理（引发事件后的处理方式）。

1.事件源：就是java.awt和javax.swing包中的GUI组件。

2.事件：每个事件源都有自己的特有事件和共性事件（鼠标事件和键盘事件即是它们的共性事件）。

3.监听器：将可以触发某一事件的动作（不止一个）都封装在了监听器中。
  4.事件处理：事件源、事件和监听器在java中已经定义好了，直接获取其对象来用就可以了，我们要做的是对产生的动作进行处理。

窗体事件

WindowEvent事件对于的是WindowListener，事件对象作为参数，传入监听器的处理事件方法中。

WindowListener，是一个接口，对应的Window组件体系。查看该接口发现它有7个方法需要实现，这起个方法对应7个动作。如果我仅对其中的1个动作进行处理，却需要同时复写其他的6个方法，这样不方便与编程，所以java提供了一个WindowListener的抽象子类WindowAdapter。WindowAdapter虽然是抽象的，但没有抽象方法，它定义为抽象，是为不能直接建立对象，而让你去继承，复写你要想处理的动作方法。编程中，对事件监听器用匿名内部类的比较多。

当监听器接口的方法多于3个时，一般该监听器接口都用相应的Adapter（适配器）。

程序示例：

[java]  view plain  copy

 print ?

1. /* 
2.  创建图形化界面步骤： 
3. 1.创建fram窗体。 
4. 2.对窗体进行基本设置。 
5.     比如大小，位置，布局。 
6. 3.定义组件。 
7. 4.将组件通过窗体的add方法添加到窗体中 
8. 5.让窗体显示，通过setVisible（true）方法。 
9.  */  
10. import java.awt.*;  
11. import java.awt.event.*;  
12. class  AwtDemo  
13. {  
14.     public static void main(String[] args)   
15.     {  
16.         Frame f =new Frame("my awt");  
17.         f.setSize(500,400);//设置窗体大小500是宽，400是高  
18.         f.setLocation(300,200);//设置初始显示位置，300是x坐标，200是y坐标  
19. //      上边两个方法可以用它 f.setBounds(x, y, width, height)来统一设置  
20.         f.setLayout(new FlowLayout());//默认的是边界布局管理器  
21.           
22.         Button b = new Button("我是一个按钮");  
23.         f.add(b);  
24.   
25.         f.addWindowListener(new WindowAdapter()  
26.         {  
27.             public void windowClosing(WindowEvent e)  
28.             {  
29.                 System.out.println("我关");  
30.                 System.exit(0);//这个方法的 关闭的是虚拟机，退出虚拟机，当然就退出了程序    
31.             }  
32.             public void windowActivated(WindowEvent e)  
33.             {  
34.                 System.out.println("我活动的");  
35.             }  
36.             public  void windowOpened(WindowEvent e)    
37.             {  
38.                 System.out.println("我被打开了");  
39.   
40.             }  
41.         });   
42.         //设置frame显示，这时图形界面线程才启动  
43.         f.setVisible(true);  
44.     }  
45. }  
46. class MyWin extends WindowAdapter  
47. {  
48.     public void windowClosing(WindowEvent e)  
49.     {  
50.         System.exit(0);  
51.         //System.out.println("MyWin------------"+e.toString());  
52.     }  
53. }  

Action事件

    

     按钮对应的是ActionEvent事件，ActionEvent对应的是ActionListener监听器。只用按钮活动，就能执行，而键盘和鼠标都能让按钮活动。所以，如果对按钮处理的动作只有一种，最好使用ActionListener，因为鼠标键盘都会触发它。

ActionListener监听器接口只用一个方法，所以没有相应的Adapter，它是三个没有配适器的监听器接口之一。

代码示例：

[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.   
9.     FrameDemo()  
10.     {  
11.         init();  
12.     }  
13.     //初始化图形界面  
14.     public void init()//初始化  
15.     {  
16.         f= new Frame("day22-MyFrame");  
17.   
18.         //对frame进行基本设置。  
19.         f.setBounds(300,100,600,500);  
20.         f.setLayout(new FlowLayout());  
21.         but = new Button("my button");  
22.         //将组件添加到Frame中  
23.         f.add(but);   
24.         //加载一下窗体上的事件。  
25.         myEvent();  
26.         //显示窗体  
27.         f.setVisible(true);  
28.     }  
29.     //最好把事件处理和GUI组件的基本初始化分离开  
30.     public void myEvent()//这些都是组件的特有事件，还有共性事件。  
31.     {  
32.         f.addWindowListener(new WindowAdapter()  
33.         {  
34.             public void windowClosing(WindowEvent e)  
35.             {  
36.                 System.out.println("关闭窗口");  
37.                 System.exit(0);//这个方法的 关闭的是虚拟机，退出虚拟机，当然就退出了程序    
38.             }  
39.         });  
40.         //让按钮具备退出程序的功能。  
41.         /* 
42.         按钮就是事件源，那么选择哪一个监听器呢？通过关闭窗体实例了解到。想要知道那个组件具备什么样的特与监听器， 
43.         需要查看该组件对象的功能。那么通过查阅button的描述，发现支持一个特有监听addActionListener(ActionListener l)； 
44.         是没有适配器的少数组件之一，只要事件方法超过3个的组件，都有配适器（Adapter）； 
45.         */  
46.         but.addActionListener(new ActionListener()  
47.         {  
48.             public void actionPerformed(ActionEvent e)   
49.             {  
50.                 System.out.println("退出，按钮干的");  
51.                 System.exit(0);  
52.             }  
53.   
54.         });  
55.     }  
56.     //主函数，用于测试  
57.     public static void main(String[] args)   
58.     {  
59.         new FrameDemo();  
60.     }  
61. }  

鼠标事件

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

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

键盘事件

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

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

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

代码示例：

[java]  view plain  copy

 print ?

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

对话框

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

其体系如下：

|----Dialog

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

         |----JDialog

代码示例：模拟系统文件目录浏览器

[java]  view plain  copy

 print ?

1. package tzq;  
2. import java.awt.*;  
3. import java.awt.event.*;  
4. import java.io.File;  
5.   
6. public class MyWindowDemo {  
7.     private Frame f;  
8.     private Button but;  
9.     private TextArea ta;  
10.     private TextField tf;  
11.       
12.     private Dialog d;  
13.     private Label lab;  
14.     private Button okBut;  
15.       
16.       
17.     public MyWindowDemo() {  
18.         init();  
19.     }  
20.     private void init() {  
21.         f=new Frame("My Window");  
22.         f.setBounds(300, 200, 500, 400);  
23.         f.setLayout(new FlowLayout());  
24.           
25.         tf=new TextField(40);  
26.         but=new Button("转到");  
27.         ta=new TextArea(20,45);  
28.           
29.         d=new Dialog(f, "提示信息", true);  
30.         d.setBounds(400, 200, 300, 130);  
31.         d.setLayout(new FlowLayout());  
32.           
33.         lab=new Label();  
34.         okBut=new Button("确定");  
35.           
36.         d.add(lab);  
37.         d.add(okBut);  
38.           
39.         f.add(tf);  
40.         f.add(but);  
41.         f.add(ta);  
42.       
43.           
44.         myEvent();  
45.           
46.         f.setVisible(true);  
47.           
48.           
49.   
50.     }  
51.       
52.       
53.     public void myEvent(){  
54.          //添加按钮活动事件监听器   
55.         but.addActionListener(new ActionListener() {  
56.               
57.             @Override  
58.             public void actionPerformed(ActionEvent arg0) {  
59.                 showDir();  
60.                   
61.             }  
62.         });  
63.         //okBut监听器  
64.         okBut.addActionListener(new ActionListener() {  
65.               
66.             @Override  
67.             public void actionPerformed(ActionEvent e) {  
68.                 d.setVisible(false);  
69.                   
70.             }  
71.         });  
72.         //添加textField的键盘监听器    
73.         tf.addKeyListener(new KeyAdapter() {  
74.             @Override  
75.             public void keyPressed(KeyEvent e) {  
76.                 if(e.getKeyCode()==KeyEvent.VK_ENTER){  
77.                     showDir();  
78.                 }  
79.                   
80.             }  
81.         });  
82.           
83.         d.addWindowListener(new WindowAdapter() {  
84.             @Override  
85.             public void windowClosing(WindowEvent e) {  
86.                 d.setVisible(false);  
87.             }  
88.               
89.               
90.         });  
91.           
92.           
93.         //frame监听器  
94.         f.addWindowListener(new WindowAdapter() {  
95.             @Override  
96.             public void windowClosing(WindowEvent e) {  
97.                 System.out.println("程序关闭");  
98.                 System.exit(0);  
99.   
100.             }  
101.         });  
102.           
103.     }  
104.       
105.     private void showDir(){  
106.         String disPath=tf.getText();  
107.         File dir=new File(disPath);  
108.         if(dir.exists() && dir.isDirectory()){  
109.             ta.setText("");  
110.             String []names=dir.list();  
111.             for(String name:names){  
112.                 ta.append(name+"\r\n");  
113.                   
114.             }     
115.         }else{  
116.             String info="您输入的信息"+disPath+"是错误的，请重新输入！";  
117.             lab.setText(info);  
118.             d.setVisible(true);  
119.         }  
120.         tf.setText("");  
121.     }  
122.       
123.       
124.       
125.       
126.       
127.     public static void main(String[] args) {  
128.         new MyWindowDemo();  
129.     }  
130. }  

菜单

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

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

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

MenuItem：菜单条目。

注意：其继承体系如下：

|---MenuComponent

         |---- MenuBar

         |---- MenuItem

    |-----Menu

练习：简单模拟记事本

[java]  view plain  copy

 print ?

1. package tzq;  
2. import java.awt.*;  
3. import java.io.*;  
4. import java.awt.event.*;  
5. public class NoteTest {  
6.     private Frame f;  
7.     private MenuBar mb;  
8.     private Menu m;  
9.     private MenuItem openItem,closeItem,saveItem;  
10.     private TextArea ta;  
11.     private FileDialog diaOpen,diaSave;  
12.     private File file;  
13.       
14.     public NoteTest() {  
15.         init();  
16.     }  
17.     private void init() {  
18.         f=new Frame("记事本");  
19.         f.setBounds(400, 300, 600, 500);  
20.         //f.setLayout(new FlowLayout());//使用默认的边界布局管理器   
21.           
22.         //设置菜单  
23.         mb=new MenuBar();  
24.         m=new Menu("文件");  
25.         openItem=new MenuItem("打开");  
26.         saveItem=new MenuItem("保存");  
27.         closeItem=new MenuItem("关闭");  
28.           
29.         m.add(openItem);  
30.         m.add(saveItem);  
31.         m.add(closeItem);  
32.         mb.add(m);  
33.           
34.         //设置文本区  
35.         ta=new  TextArea();  
36.           
37.         //建立文件打开和保存的对话框  
38.         diaOpen=new FileDialog(f, "打开", FileDialog.LOAD);  
39.         diaSave=new FileDialog(f, "保存", FileDialog.SAVE);  
40.           
41.         //将菜单添加到Frame(窗体）中  
42.         f.setMenuBar(mb);  
43.         f.add(ta);  
44.           
45.         //添加事件  
46.         myEvent();  
47.         //设置窗体显示  
48.         f.setVisible(true);  
49.     }  
50.     private void myEvent() {  
51.         //frame窗体关闭监听  
52.         f.addWindowListener(new WindowAdapter() {  
53.             @Override  
54.             public void windowClosing(WindowEvent e) {  
55.                 System.exit(0);  
56.             }  
57.         });  
58.         //关闭菜单  
59.         closeItem.addActionListener(new ActionListener() {  
60.               
61.             @Override  
62.             public void actionPerformed(ActionEvent arg0) {  
63.                 System.exit(0);  
64.                   
65.             }  
66.         });  
67.         //保存文件  
68.         saveItem.addActionListener(new ActionListener() {  
69.               
70.             @Override  
71.             public void actionPerformed(ActionEvent e) {  
72.                 //先判断文件是否存在？  
73.                   //如果文件不存在则打开文件保存对话框  
74.                 if(file==null){  
75.                     diaSave.setVisible(true);  
76.                     String dirPath=diaSave.getDirectory();  
77.                     String fileName=diaSave.getFile();  
78.                     //将路径封装成文件对象  
79.                     file=new File(dirPath,fileName);  
80.                       
81.                     //防止点击取消按钮产生异常，这时直接返回  
82.                     if(dirPath==null && fileName==null){  
83.                         return;  
84.                     }  
85.                     //上边的代码保证了文件肯定存在，然后开始保存数据    
86.                       
87.                     try {  
88.                         BufferedWriter bufw=new BufferedWriter(new FileWriter(file));  
89.                         bufw.write(ta.getText());  
90.                         bufw.close();  
91.                           
92.                     } catch (Exception e2) {  
93.                         throw new RuntimeException("保存失败！");  
94.   
95.                     }  
96.                 }  
97.                   
98.             }  
99.         });  
100.        //打开文件  
101.         openItem.addActionListener(new ActionListener() {  
102.               
103.             /* (non-Javadoc) 
104.              * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent) 
105.              */  
106.             @Override  
107.             public void actionPerformed(ActionEvent arg0) {  
108.                 //启动文件时打开对话框  
109.                 diaOpen.setVisible(true);  
110.                 //获得所选取文件的目录  
111.                 String dirPath=diaOpen.getDirectory();  
112.                 //获得选取的文件的文件名字，如果没有选取，则返回null（即点击的是取消按钮），这要处理一下    
113.                 String fileName=diaOpen.getFile();  
114.                 if(dirPath==null && fileName==null){  
115.                     return;  
116.                 }  
117.                 //选取有效文件后清空文本区域  
118.                 ta.setText("");  
119.                 //将选取的文件读到文本区域中  
120.                 file=new File(dirPath, fileName);  
121.                 //对IO异常进行处理，将文件内容加到文本区域中    
122.                 try {  
123.                     BufferedReader bufr=new BufferedReader(new FileReader(file));  
124.                     StringBuilder sb=new StringBuilder();  
125.                     String line=null;  
126.                     while((line=bufr.readLine())!=null){  
127.                             sb.append(line+"\r\n");  
128.                     }  
129.                     ta.append(sb.toString());  
130.                     bufr.close();  
131.                       
132.                       
133.                 } catch (Exception e) {  
134.                     throw new RuntimeException("读取失败");   
135.                 }  
136.                   
137.                   
138.                   
139.             }  
140.         });  
141.           
142.     }  
143.       
144.     public static void main(String[] args) {  
145.         new NoteTest();  
146.     }  
147.       
148.       
149.       
150. }  

产生问题：点击保存按钮后取消时系统报错：

八、GUI双击jar包执行

写好读到GUI程序，可以封装成jar包，通过对系统进行设置，使得双击jar包后，程序可以执行。以上边的写的记事本程序为例：

操作步骤：

1.      在源文件的第一行加上包：package mymenu

2.      dos命令行中启动“javac  -d  c:\myclassMyMenuTest.java”命令。

3.      在menu包所在目录下，新建一个名为“1.txt”的文本文档，里边录入一下内容：
Main-Class: mymenu.MyMenuTest

注意：1，冒号后面要有一个空格；2，末尾一定要加换行符，即敲一下Enter键。

4.      在在dos切换到c:\myclass目录下，启动”jar –cvfm my.jar 1.txt menu”    命令，这时得到的jar包即可启动。

 

在此之前要先将jar文件注册的系统中，其过程如下：

xP系统：工具à文件夹选项à文件类型à新建扩展名为jar的文件类型à选中jar，

点击“高级”按钮à更改图标，图标可以任意选；点击”新建”按键à添加open操作，操行名称写完“open”，用于执行操作的程序选择JDK目录下的javaw工具，并在末尾加上–jar参数。

Win7系统：

1、选择默认程序：右击jar包，打开方式->选择默认程序->浏览，选中jre下bin文件中javaw.exe(比如我的javaw.exe在D:\ProgramFiles\Java\jre6\bin下）。

  2、编辑注册表：HKEY_CLASSES_ROOT\Applications\javaw.exe\shell\open\command,修改数据数值为"D:\ProgramFiles\Java\jdk1.6.0_21\jre\bin\javaw.exe" -jar "%1"（只要在原来的数值下添加-jar即可）。

 

错误示例：

jar时出现： invalid header field错误提示，

原因是

Main-Class:mymenu.MyMenuTest

 

冒号后边少一个空格，改为

Main-Class: mymenu.MyMenuTest即可。

from: http://blog.csdn.net/u010834071/article/details/38471605?utm_source=tuicool&utm_medium=referral