您的位置：首页 > 产品设计 > UI/UE

黑马程序员- GUI图形用户界面

2013-06-14 10:28 302 查看

------- android培训、java培训、期待与您交流！ ----------
1，简介

GUI

Graphical User Interface(图形用户接口).

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

CLI

Command line User Interface(命令行接口)

就是常见的Dos命令行操作

需要记忆一些常用的命令，操作不直观

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

Awt和Swing

java.Awt:Absttact Window ToolKit(抽象窗口工具包)，需要调用本地系统方法实现功能。属于重量级控件。对系统依赖性较强

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

继承关系图

Container:为容器，是一个特殊的组件，该组件可以通过add方法添加其他组件进来

布局管理器

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

常见的布局管理器

FlowLayout(流式布局管理器)

从左到右的顺序排列

Panel默认的布局管理器

BorderLayout(边界布局管理器)

东，南，西，北中

Frame默认的布局管理器

GridLayout(网格布局管理器)

规则的矩阵

GardLayout(卡片布局管理器)

非规则的矩阵

2，Frame

Frame基本界面步骤。代码如下：

import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;

/*
* 创建图形化界面
* 1，对窗体进行基本设置
* 2，对窗体进行基本设置
*      比如大小，位置，布局
* 3，定义组件
* 4，将组件通过窗体的add方法添加到窗体中。
* 5，让窗体显示，通过setVisible（true）完成
*/
public class Test1 {
public static void main(String[] args) {
Frame f = new Frame("my awt");// 初始化不可见的,默认布局管理器，边界是布局，如果没有指定东南西北，就全部填充
f.setSize(500, 100);// 设置横纵坐标
f.setLocation(300, 200);// 距离左上角的左边的位置，上边的位置
f.setLayout(new FlowLayout());
Button b = new Button("按钮");
f.add(b);
f.setVisible(true);// 设置可见的

// System.out.println("Hello world");
}

}

3，事件监听机制

事件源（组件）

事件（Event）

监听器（Lisener）

事件处理（引发事件处理方式）

import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

/*
* 事件监听机制的特点：
* 1，事件源
* 2，事件
* 3，监听器
* 4，事件处理
* 事件源:就是awt包中或者swing包中的那些图形界面组件
* 事件：每一个事件源都有自己特有的对应事件和共性事件
* 监听器：将可以触发某一个事件的动作都已经封装了监听器中。
* 以上三者：在java中都已经定义好了。
* 直接获取其对象来用就可以了。
* 我们要做的事情是，就是对产生的动作进行处理。
*/
public class Test2 {
public static void main(String[] args) {
Frame f = new Frame("my awt");// 初始化不可见的,默认布局管理器，边界是布局，如果没有指定东南西北，就全部填充
f.setSize(500, 100);// 设置横纵坐标
f.setLocation(300, 200);// 距离左上角的左边的位置，上边的位置
f.setLayout(new FlowLayout());
Button b = new Button("按钮");
f.add(b);
f.setVisible(true);// 设置可见的
f.addWindowListener(new MyWin());// 添加监听器，监听器里面定义的都是动作
// 匿名内部类的方法如下
/*
* f.addWindowListener(new WindowAdapter(){ public void
* windowClosing(WindowEvent e){ System.out.println("关闭");
* System.exit(0); }
*
* });
*/
// System.out.println("Hello world");
// WindowAdapter 实现了WindowListener接口
}

}

/*
* //覆盖了7个方法。可是我只用到了关闭动作 //其他动作却必须重写 class MyWin implements WindowListener{
*
* @Override public void windowActivated(WindowEvent e) { // TODO Auto-generated
* method stub
*
* }
*
* @Override public void windowClosed(WindowEvent e) { // TODO Auto-generated
* method stub
*
* }
*
* @Override public void windowClosing(WindowEvent e) { // TODO Auto-generated
* method stub
*
* }
*
* @Override public void windowDeactivated(WindowEvent e) { // TODO
* Auto-generated method stub
*
* }
*
* @Override public void windowDeiconified(WindowEvent e) { // TODO
* Auto-generated method stub
*
* }
*
* @Override public void windowIconified(WindowEvent e) { // TODO Auto-generated
* method stub
*
* }
*
* @Override public void windowOpened(WindowEvent e) { // TODO Auto-generated
* method stub
*
* } }
*/
// 因为WindowListener子类已经实现了WindwoListerer接口
// 并覆盖了其中所有的方法，那么我只要继承自Windowadapter覆盖我需要的方法即可
class MyWin extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.out.println("关闭");
System.exit(0);
}
}

4 Action事件

组件活动时触发代码如下：

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

public class Test3 {
// 初始化
Frame f = null;
Button but = null;

public Test3() {
init();
}

public void init() {
f = new Frame("my Frame");
f.setBounds(300, 100, 600, 500);// 相当于setsize();setlocation();坐标和宽度高度

f.setLayout(new FlowLayout());
but = new Button("my button");
// 价值窗体事件
myEvent();
f.add(but);
f.setVisible(true);
}

private void myEvent() {
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
// 让按钮具备退出程序功能
/*
* 按钮就是事件源 那么选择那个监听器呢？ 通过关闭窗体了解到，想要知道那个组件具备什么样的特有监听器 需要查看该组件对象的功能
* （具体的组件支持哪些监听，只有组件自己知道，添加监听的方法肯定定义在组件自己内部）
*/
but.addActionListener(new ActionListener() {

@Override
public void actionPerformed(ActionEvent e) {// 添加活动监听，所以参数是活动事件
// TODO Auto-generated method stub
System.out.println("退出按钮做的事");
System.exit(0);
}

});// 由于接口方法只有一个，所以不需要适配器，方法超过三个的几乎有适配器
}

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

5 鼠标事件

在任何组件上都可以发生鼠标事件，入：鼠标进入组件，退出组件，在组件上方单机鼠标，

拖动鼠标都发生鼠标事件，也就是说，组件可以成为发生鼠标事件的事件源

事件类型是MouseEvent，即当发生鼠标事件时，MouseEvent类自动创建一个事件对象。

MouseEvent类中有几个重要的方法。

1，getX();事件源的x坐标

2,getY();事件源的y坐标

3，getModifiers()获取鼠标的左键或右键。鼠标的左键和右键分别使用InputEvent类中的常量BUTTONI_MASK和BUTTON3来表示

4，getClickCount()获取鼠标被单机的次数

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

/*
* 演示鼠标事件
*/
public class Test4 {
// 初始化
Frame f = null;
Button but = null;

public Test4() {
init();
}

public void init() {
f = new Frame("my Frame");
f.setBounds(300, 100, 600, 500);

f.setLayout(new FlowLayout());
but = new Button("my button");
// 价值窗体事件
myEvent();
f.add(but);
f.setVisible(true);
}

private void myEvent() {
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
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 Test4();
}
}

6 键盘事件，文本框只能输入数字，组合键

在java事件模式中,必需有发生事件的事件源. 当一个组件处于激活状态时.敲击任何一个键,就会发生键盘事件.

具体的看代码示例如下：

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

/*
* 演示鼠标事件
*/
public class Test5 {
// 初始化
Frame f = null;
Button but = null;
TextField tf = null;

public Test5() {
init();
}

public void init() {
f = new Frame("my Frame");
f.setBounds(300, 100, 600, 500);

f.setLayout(new FlowLayout());
tf = new TextField(20);// 指定列数初始化，要求只能输入数字
but = new Button("my button");
// 价值窗体事件
myEvent();
f.add(tf);
f.add(but);
f.setVisible(true);
}

private void myEvent() {
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
// 给but添加一个键盘事件
but.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
if (e.isControlDown() && e.getKeyCode() == KeyEvent.VK_ENTER) {// 按下ctrl加上enter键组合键
System.out.println("ctrl enter is run");
}
if (e.getKeyCode() == KeyEvent.VK_ENTER) {// 按下enter键退出
System.exit(0);
}
System.out.println(KeyEvent.getKeyText(e.getKeyCode()) + ".."
+ e.getKeyCode());
}
});
tf.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
int code = e.getKeyCode();
if (!(code >= KeyEvent.VK_0 && code <= KeyEvent.VK_9)) {
System.out.println(code + "是非法的");
e.consume();// 不准备用默认的方式处理事件，默认是输入进去
}
}
});
}

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

7 Dialog 列出指定目录的内容,不存在的显示示例

Dialog类和Frame类都是window的子类。对话框必须依赖于某个窗口或组件，当它所依赖的窗口或组件消失时，对话框也消失；当它所依赖的窗口或组件可见时，对话框会自动恢复。

主要方法

Dialog(Frame f,String s):构造一个具有标题s的初始化不可见的对话框，所依赖的窗口。

Dialog(Frame f,String s,boolean b):构造一个具有标题s的初始化不可见的对话框所依赖的窗口，b决定对话框是有模式或无模式。

getTitle();获取对话框标题

setTitle();设置对话框的标题

setModel(boolean b)设置对话框的模式

setSize();设置对话框的大小

setVisible(boolean b)

对话框的模式

有模式对话框：对话框牌激活状态，只让程序响应对话框内部的事件，程序不能再激活它所依赖的窗口或组件，并堵塞其他线程的执行。

无模式对话框处于非激活状态，程序仍能激活它所依赖的窗口或组件，它也不堵塞线程的执行

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

/*
* 列出指定目录的内容
*/
public class Test6 {
private Frame f;
private TextField tf;
private Button btn;
private TextArea ta;
private Dialog d;
private Label lbl;
private Button okbtn;

public Test6() {
init();
}

public void init() {
f = new Frame("my window");
f.setBounds(300, 100, 600, 600);
f.setLayout(new FlowLayout());
tf = new TextField(30);
btn = new Button("转到");
ta = new TextArea(15, 40);

d = new Dialog(f, "提示信息——自己的self", true);// true代表如果不操作对话框，模式操作不了
d.setBounds(400, 200, 200, 100);
d.setLayout(new FlowLayout());
lbl = new Label();
okbtn = new Button("确定");
d.add(lbl);
d.add(okbtn);
f.add(tf);
f.add(btn);
f.add(ta);
myEvent();
f.setVisible(true);
}

public void myEvent() {
tf.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_ENTER) {
show();
}
}
});
okbtn.addActionListener(new ActionListener() {

@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
d.setVisible(false);
}

});
d.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
d.setVisible(false);
}
});
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
btn.addActionListener(new ActionListener() {

@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
show();
}

});
}

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

private void show() {
String path = tf.getText();
File dir = new File(path);
if (dir.isDirectory() && dir.exists()) {
String[] names = dir.list();
ta.setText("");
for (String name : names) {
ta.append(name + "\r\n");
}
tf.setText("");
} else {
String info = "您输入的信息：" + path + "是错误的的";
lbl.setText(info);
d.setVisible(true);
}
}
}

8，MenuBar,包含子菜单选项

菜单是窗口中常见的界面，是由

菜单项（MenuBar）菜单（Menu) 菜单项（MenuItem）复选菜单项（CheckboxMenuItem）等对象组成

MenuBar 就是负责创建菜单条的，即MenuBar的一个实例就是一个菜单项。MenuBar bar=new MenuBar();

Frame类有一个将菜单条放置到窗口中的方法，其一般格式为：setMenuBar(MenuBar menubar);,只能向窗口添加一个菜单条

Menu()建立一个空标题的菜单

Menu(String s)建立一个指定标题菜单，由参数s确定

若要创建菜单Menu，并添加到空菜单条对象bar中，可执行：Menu m1=nw Menu("file"); bar.add(m1);

MenuItem 类负责为菜单创建菜单项，或为每个菜单项创建其包含的更小的菜单子项MenuItem，并把菜单子项添加到菜单项中。

MenuItem open=new MenuItem("open"); m1.add(open);

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

public class Test7 {
private Frame f;
private MenuBar mb;
private Menu m, subMenu;
private MenuItem coloseItem, subItem;

public Test7() {
init();
};

public void init() {
f = new Frame("my window");
f.setBounds(300, 100, 500, 600);
f.setLayout(new FlowLayout());
mb = new MenuBar();
m = new Menu("文件");
subMenu = new Menu("子菜单 ");
subItem = new MenuItem("子条目");
coloseItem = new MenuItem("退出");
subMenu.add(subItem);
m.add(subMenu);
m.add(coloseItem);
mb.add(m);
f.setMenuBar(mb);
myEvent();
f.setVisible(true);
}

private void myEvent() {
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}

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

9,FileDialog一个简单的保存文件读取文件的文本编辑器。

是Dialog的子类

FileDialog(Dialog parent,String title, int mode)

zh_cn

创建一个具有指定标题的文件对话框窗口，用于加载或保存文件。

如果

mode

的值为

LOAD

，那么文件对话框将查找要读取的文件，所显示的文件是当前目录中的文件。如果

mode

的值为

SAVE

，则文件对话框将查找要写入文件的位置。

parent

zh_cn

对话框的所有者

title

zh_cn

对话框的标题；接受

null

值时不会抛出

NullPointerException

mode

zh_cn

对话框的模式，

FileDialog.LOAD

或

FileDialog.SAVE

import java.awt.*;
import java.awt.event.*;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

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

public Test8() {
init();
}

public void init() {
f = new Frame("my window");
f.setBounds(300, 100, 500, 600);
mb = new MenuBar();
fileMenu = new Menu("文件");
openItem = new MenuItem("打开");
saveItem = new MenuItem("保存");
closeItem = new MenuItem("退出");
ta = new TextArea();
fileMenu.add(openItem);
fileMenu.add(saveItem);
fileMenu.add(closeItem);
mb.add(fileMenu);
f.setMenuBar(mb);
f.add(ta);
openDia = new FileDialog(f, "我要打开", FileDialog.LOAD);
saveDia = new FileDialog(f, "我要保存", FileDialog.SAVE);
myEvent();
f.setVisible(true);

}

private void myEvent() {

saveItem.addActionListener(new ActionListener() {

@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if (file == null) {
saveDia.setVisible(true);
String path = saveDia.getDirectory();// 得到文件夹
String name = saveDia.getFile(); // 得到文件名字
if (path == null || name == null) {
return;
}
file = new File(path, name);
}
try {
BufferedWriter bufw = new BufferedWriter(new FileWriter(
file));
String text = ta.getText();
bufw.write(text);
bufw.close();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
});
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
openItem.addActionListener(new ActionListener() {

@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
openDia.setVisible(true);
String path = openDia.getDirectory();// 得到文件夹
String name = openDia.getFile(); // 得到文件名字
// System.out.println(path+"..."+name);
if (path == null || name == null) {
return;
}
file = new File(path, name);
ta.setText("");
try {
BufferedReader br = new BufferedReader(new FileReader(file));
String text = ta.getText();
String line = null;
try {
while ((line = br.readLine()) != null) {
ta.append(line + "\r\n");
}
br.close();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}

}

});

}

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

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航