java基础--GUI（图形化界面）

笔记摘要：

本篇文章主要介绍了java中的图形化界面，其中重点在于监听机制，通过几个示例我们可以掌握监听机制的原理以及使用，

其中对于监听器其实抽象方法，但是其实现类为我们实现了抽象方法，即适配器的概念，我们只要获取适配器，然后复写

我们所需要的事件监听即可，对于错误事件的处理引入了对话框的创建与使用，后面介绍了菜单的创建与使用，最后通过

一个简单的具有打开与保存的记事本进行了总结，其实我们要做的就是监听的事件处理，以及使用我们前面学到的IO技术

对文本进行读取和写入

一、GUI（图形用户界面）

1、GUI介绍

Graphical User Interface（图形用户接口）

用图形的方式，来显示计算机操作的界面，这样更方便直观

2、CLI介绍

Commondline User Interface(命令行用户接口)

就是常见的Dos命令行操作， 需要记忆一些常用的命令，操作不直观

举例：

创建文件夹，或者删除操作文件等

3、Awt和Swing

Java为GUI提供的对象都在java.Awt和javax.Swing两个包中。

· Java.Awt: Abstract Window ToolKit (抽象窗口工具包)，需要调用本地系统方法实现功能，属于重量级控件

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

4、GUI继承关系图

二、布局管理器

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

常见的布局管理器：

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

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

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

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

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

三、 监听机制

1、事件监听机制组成

事件源（组件）、事件（Event）、监听器（Listener）、事件处理（引发事件后处理方式）

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

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

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

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

以上三者，在java中都已经定义好了，直接获取其对象来用就可以了。

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

事件监听流程图

事件监听机制的使用

1、确定事件源（容器或组件）

2、通过事件源对象的addxxxListener（）方法将监听器注册到该事件源上

3、该方法中接收xxxListener的子类对象，或者xxxListener的子类xxxAdapter的子类对象，一般用匿名内部类来表示

4、在覆盖方法的时候，方法的参数一般是xxxEvent类型的变量接收。

5、事件触发后会把事件打包成对象传递给该变量（其中包括事件源对象，通过getSource()，或者getComponent()获取）

对于活动事件的监听：键盘和鼠标都可一触发事件源

因为WindowListener的子类WindowAdapter已经实现了WindowListener接口。

并覆盖了其中的所有方法。那么我只要继承自Windowadapter覆盖我需要的方法即可。

四、示例演示

1、建立一个简单的窗体

示例说明：

这里介绍了简单窗体的创建方式和事件监听的创建方式以及事件的处理

class  AwtDemo{
public static void main(String[] args) {
//创建窗体，默认为边界布局
Frame f = new Frame("my awt");
//设置长宽
f.setSize(500,400);
//设置位置，距左，距上
f.setLocation(300,200);
//设置为流式布局
f.setLayout(new FlowLayout());

Button b = new Button("我是一个按钮");
f.add(b);

//为窗体添加窗口关闭动作的监听器
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.out.println("我关");
System.exit(0);
}

// 将 Window 设置为活动 Window 时调用，即窗体处于最前端
public void windowActivated(WindowEvent e) {
System.out.println("我活了。");

}

public void windowOpened(WindowEvent e) {
System.out.println("我被打开了,hahahhahah");
}
});

f.setVisible(true);
//System.out.println("Hello World!");
}
}

2、在窗体中通过按钮关闭窗体

示例说明：

这里我们将图形化界面和事件分离，上面的示例只为介绍，所以在代码方面没有考虑

分析： 让按钮具备退出程序的功能
按钮就是事件源。

那么选择哪个监听器呢？

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

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

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

import java.awt.*;
import java.awt.event.*;

class  FrameDemo{

//定义该图形中所需的组件的引用。
private Frame f;
private Button but;

FrameDemo(){
init();
}

//创建窗体并进行基本设置
public void init(){

f = new Frame("my frame");
//对frame的位置和大小进行设置。
f.setBounds(300,100,600,500);
//设置布局
f.setLayout(new FlowLayout());
//添加按钮组件
but = new Button("my button");

//将组件添加到frame中
f.add(but);
//加载窗体上事件
myEvent();
//显示窗体;
f.setVisible(true);

}

//事件监听和处理
private void myEvent(){
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});

//为按钮添加活动事件监听
but.addActionListener(new ActionListener(){
private int count = 1;
public void actionPerformed(ActionEvent e){
System.out.println("退出，按钮干的");
System.exit(0);

//f.add(new Button("Button-"+(count++)));
//f.setVisible(true);
//使容器再次布置其子组件,已经显示容器后，在修改此容器的子组件的时候,应该调用此方法
//f.validate();

//System.out.println(e.getSource());
//获取事件源
//Button b = (Button)e.getSource();
//得到窗体
//Frame f1 = (Frame)b.getParent();
//为窗体添加按钮组件
//f1.add(new Button("button-"+count++));
//再次布置窗体中的组件
//f1.validate();
}
});
}

public static void main(String[] args) {
new FrameDemo();
}
}

3、熟悉键盘事件与鼠标事件

示例说明：

这里介绍了键盘与鼠标事件的监听与处理，为文本区添加键盘监听，

为Button添加一个键盘监听：当Button为当前事件源时，就可以触发键盘事件

活动监听处理事件，鼠标和键盘都可触发

效果图示
窗体



事件监听处理结果

import java.awt.*;
import java.awt.event.*;

class MouseAndKeyEvent {
private Frame f;
private Button but;
private TextField tf;

MouseAndKeyEvent(){
init();
}

//创建窗体并初始化一些组件
public void init(){
//创建窗体并初始化位置、大小、布局
f = new Frame("my frame");
f.setBounds(300,100,600,500);
f.setLayout(new FlowLayout());

//创建文本区
tf = new TextField(20);
//创建Button组件
but = new Button("my button");

//为窗体添加组件
f.add(tf);
f.add(but);

//注册事件监听和处理事件
myEvent();

//显示窗体
f.setVisible(true);
}

//事件的监听和处理
private void myEvent(){
//为窗体添加关闭窗口关闭动作的监听
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});

//为文本区添加键盘监听器，当时事件源为文本区时，按下指定键，可触发
tf.addKeyListener(new KeyAdapter(){

//文本区只能输入0-9
public void keyPressed(KeyEvent e){
int code = e.getKeyCode();
if(!(code>=KeyEvent.VK_0 && code<=KeyEvent.VK_9)){
System.out.println(code+".....是非法的");
//取消事件，当不是0-9时，就不让进入文本区
e.consume();
}
}
});

//给Button添加一个键盘监听，当Button为当前事件源时，就可以触发键盘事件
but.addKeyListener(new KeyAdapter(){
public void keyPressed(KeyEvent e){
//Ctrl+Enter组合键
if(e.isControlDown()&&e.getKeyCode()==KeyEvent.VK_ENTER)
//System.exit(0);
System.out.println("ctrl+enter is run");

//打印编码制对应的键和该键的编码值
//System.out.println(KeyEvent.getKeyText(e.getKeyCode())+"...."+e.getKeyCode());
}
});

//活动监听处理事件，鼠标和键盘都可触发
but.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
System.out.println("action ok");
}
});

//鼠标事件的监听和处理
but.addMouseListener(new MouseAdapter(){
private int count = 1;
private int clickCount = 1;

//鼠标光标移入组件上时处理
public void mouseEntered(MouseEvent e) {
System.out.println("鼠标进入到该组件"+count++);
}

//鼠标点击事件处理
public void mouseClicked(MouseEvent e){
//双击动作处理
if(e.getClickCount()==2)
System.out.println("双击动作"+clickCount++);
}
});

}

public static void main(String[] args) {
new MouseAndKeyEvent();
}
}

4、图形化界面列出文件夹中的目录，并给出错误提示的对话框

示例说明：
这里包括了两类事件处理，一类是对于事件的执行时监听并处理，

另一类是对于错误事件进行监听和处理，这里使用弹出对话框的方式对非法文件路径进行处理

效果图：

import java.awt.*;
import java.awt.event.*;
import java.io.*;

class  MyWindowDemo{
private Frame f;
private TextField tf;
private Button but;
private TextArea ta;

MyWindowDemo(){
init();
}
//创建窗体和组件
public void init(){
//创建窗体并初始化位置、大小、布局
f = new Frame("my window");
f.setBounds(300,100,600,500);
f.setLayout(new FlowLayout());

//创建文本框
tf = new TextField(60);
//创建按钮组件
but = new Button("转到");
//创建文本区
ta = new TextArea(25,70);

//为窗体添加组件
f.add(tf);
f.add(but);
f.add(ta);

//注册监听器和事件处理
myEvent();

//设置窗体为可见
f.setVisible(true);
}

//正常事件监听及处理
private void  myEvent(){

//为文本区添加键盘监听，以便按下Enter也可执行
tf.addKeyListener(new KeyAdapter(){
public void keyPressed(KeyEvent e){

//当按下Enter键时调用showDir()
if(e.getKeyCode()==KeyEvent.VK_ENTER)
showDir();
}
});

//为转到按钮添加活动监听，以便当前事件源为转到按钮时，点击按钮和键盘（空格）都可以触发事件
but.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e)
{
showDir();

}
});

//添加窗体监听
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
}

//错误事件监听及处理
private void errorEvent(){

//为对话框的确定按钮添加活动监听，
okBut.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
d.setVisible(false);
}
});

//为对话框添加窗口监听
d.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
d.setVisible(false);
}
});
}

//遍历文件夹的方法
private void showDir(){
String dirPath = tf.getText();
File dir = new File(dirPath);

//如果路径正确且是文件夹，则遍历该文件夹目录
if(dir.exists() && dir.isDirectory()){
//清空上次文本区中的内容
ta.setText("");
String[] names = dir.list();
for(String name : names){
ta.append(name+"\r\n");
}
}
//路径错误弹出错误对话框提示
else{
//设为true时，如果该对话框不操作，它所属的对话框操作不了
Dialog d = new Dialog(f,"提示信息-self",true);
d.setBounds(400,200,240,150);
d.setLayout(new FlowLayout());
Label lab = new Label();
Button okBut = new Button("确定");
d.add(lab);
d.add(okBut);

String info = "您输入的信息："+dirPath+"是错误的。请重输";
lab.setText(info);
//添加错误事件监听器和事件处理
errorEvent();
d.setVisible(true);
}
}

public static void main(String[] args) {
new MyWindowDemo();
}
}

五、菜单

菜单介绍：

MenuBar 菜单栏，Menu 菜单，MenuItem 菜单项

条目没有向右的箭头，菜单有。

菜单的使用：

先创建菜单条，再创建菜单，每一个菜单中建立菜单项

也可以将菜单添加到菜单中，作为子菜单

通过setMenuBar()方法，将菜单添加到Frame中。

菜单继承体系图

效果图

import java.awt.*;
import java.awt.event.*;

class MyMenuDemo {

private Frame f;
private MenuBar mb;
private Menu m,subMenu;
private MenuItemcloseItem,subItem;

//执行程序时，直接初始化
MyMenuDemo(){
init();
}

//创建窗体并初始化一些组件
public void init(){

//创建窗体并初始化位置、大小、布局
f = newFrame("my window");
f.setBounds(300,100,500,600);
f.setLayout(newFlowLayout());

//创建菜单条
mb = newMenuBar();
//创建菜单和子菜单
m = newMenu("文件");
subMenu = newMenu("子菜单");
//创建菜单条目
subItem = newMenuItem("子条目");
closeItem = newMenuItem("退出");

//为子菜单添加子条目
subMenu.add(subItem);

//为菜单添加子菜单和关闭条目
m.add(subMenu);
m.add(closeItem);
//将菜单添加到菜单条中
mb.add(m);

//为窗体添加菜单条
f.setMenuBar(mb);

//注册监听器和监听事件
myEvent();

//显示窗体
f.setVisible(true);
}

//注册监听器和监听事件
private void myEvent(){

//为关闭菜单条目添加监听器和监听事件
closeItem.addActionListener(newActionListener(){
publicvoid actionPerformed(ActionEvent e){
System.exit(0);
}
});
//添加窗体关闭事件
f.addWindowListener(newWindowAdapter(){
publicvoid windowClosing(WindowEvent e){
System.exit(0);
}
});
}

public static voidmain(String[] args) {
newMyMenuDemo();
}
}

示例：完成一个简单的记事本程序

示例说明：

这里实现了和记事本一样的打开文件、保存文件的功能

//package mymenu;
import java.awt.*;
import java.awt.event.*;
import java.io.*;

public class MyMenuTest{
private Frame f;
private MenuBar bar;
private TextArea ta;
private Menu fileMenu;
private MenuItem openItem,saveItem,closeItem;
private FileDialog openDia,saveDia;
private File file;

MyMenuTest(){
init();
}
//构建窗体及组件
public void init(){
f = new Frame("my window");
f.setBounds(300,100,650,600);
//创建菜单条
bar = new MenuBar();
//创建一个文本区域
ta = new TextArea();

//创建菜单和菜单条目
fileMenu = new Menu("文件");
openItem = new MenuItem("打开");
saveItem = new MenuItem("保存");
closeItem = new MenuItem("退出");

//为菜单添加菜单条目
fileMenu.add(openItem);
fileMenu.add(saveItem);
fileMenu.add(closeItem);

//将菜单添加到菜单条中
bar.add(fileMenu);
//为窗体设置菜单条
f.setMenuBar(bar);

//创建“打开”和“保存”对话框
openDia = new FileDialog(f,"我要打开",FileDialog.LOAD);
saveDia = new FileDialog(f,"我要保存",FileDialog.SAVE);

//为窗体添加文本区
f.add(ta);
//注册监听器和监听事件

myEvent();
//显示窗体
f.setVisible(true);
}

//注册监听器和监听事件
private void myEvent(){
//为保存菜单条目监听以及事件处理
//当文件是新创建的，弹出对话框，否则直接保存
//而另存为则一定弹出对话框
saveItem.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){
//判断文件是否已经存在
if(file==null){
saveDia.setVisible(true);

//获取文件的路径和名称
String dirPath = saveDia.getDirectory();
String fileName = saveDia.getFile();

//取消时，做健壮性判断，防止空指针异常
if(dirPath==null || fileName==null)
return ;

file = new File(dirPath,fileName);
}

try{
//创建一个写入缓冲流
BufferedWriter bufw  = new BufferedWriter(new FileWriter(file));
//获取文本区中的内容
String text = ta.getText();
bufw.write(text);
//bufw.flush();
bufw.close();
}
catch (IOException ex){
throw new RuntimeException();
}
}
});

//为“打开”菜单条目添加监听器和处理事件
openItem.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){
//显示对话框
openDia.setVisible(true);
//获取文件路径和名称
String dirPath = openDia.getDirectory();
String fileName = openDia.getFile();
//				System.out.println(dirPath+"..."+fileName);

//点击“取消”时，做健壮性判断，防止空指针异常
if(dirPath==null || fileName==null)
return ;
//清空上次打开的内容
ta.setText("");
//新建一个文件对象
file = new File(dirPath,fileName);

//将文本区中的内容写到创建的文件中
try{
BufferedReader bufr = new BufferedReader(new FileReader(file));
String line = null;
while((line=bufr.readLine())!=null){
ta.append(line+"\r\n");
}
bufr.close();
}
catch (IOException ex){
throw new RuntimeException("读取失败");
}
}
});

//为关闭条目添加监听器及处理
closeItem.addActionListener(new ActionListener(){
//用于关闭窗体
public void actionPerformed(ActionEvent e){
System.exit(0);
}
});

//窗体监听及处理
f.addWindowListener(new WindowAdapter(){
//关闭窗体
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
}

public static void main(String[] args) {
new MyMenuTest();
}
}

六、制作一个可双击执行的jar包

以上面的MyMenuTest.java 为例

1， 将多个类封装到了一个包(package)中。

首先加一个包 package mymenu

2，定义一个jar包的配置信息。

定义一个文件a.txt 。文件内容内容为：

Main-Class:(空格)包名.类名(回车)

Main-Class：mymenu.MymenuTest

3，打一个包含指定清单文件的清单信息的jar包

jar -cvfm my.jar a.txt 包名

jar -cvfm my.jar a.txt mymenu

4，通过winrar程序进行验证，查看该jar的配置文件中是否有自定义的配置信息。

5，通过工具--文件夹选项--文件类型--jar类型文件，通过高级，定义该jar类型文件的打开动作的关联程序。

jdk\bin\javaw.exe -jar

6，双击执行

其中第5步为可选，一般只要是通过安装文件安装jdk时，就会自动在本地注册