## Java图形开发--GUI
### 1、图形用户界面(gui)介绍
图形用户界面(Graphics User Interface,GUI)是用户与程序交互的窗口，比命令行的界面更加直观并且更好操作。
awt,swing,swt,Jface是什么？
Sun已经提供了一个跨平台GUI开发工具包AWT抽象窗口工具箱(Abstract Window Toolkit).
↓
Sun又创建了一个新的GUI框架swing.解决了AWT存在的Icd问题.
↓
IBM认为swing比较消耗内存，创建了一个新的GUI库，这就是SWT
↓
IBM为了方便开发SWT程序，在SWT基础上又创建了一个更易用，功能强大的图开包"JFace"
### 2、eclipse开发工具介绍
eclipse是什么东西，我们用三句话来说明：
1、eclipse最早是IBM附属公司oti开发的，一共投入了4000万美金，后来捐献给开源社区
2、eclipse是一个开源的、可扩展的集成开发环境，已经成为目前最流行的java开发工具
3、eclipse安装后就可以开发java se的项目了，但不能开发java ee项目，需要安装web开发插件(lomboz或是myeclipse..)
ide(集成开发环境，比如jcreator、vs、myeclipse这些开发工具都是ide)
### 3、swing组件介绍
1、JFrame是Frame的子类
2、属于容器类组件，顶层容器
3、JFrame有一些常用的方法，通过示例与java的帮助文档即可了解。
在图形用户界面编程中，我们在窗体中会经常使用到按钮，我们在进行选择的时候，常常需要确认，所以按钮很重要。
只需要在窗体中添加按钮组件(JButton)即可完成。
### 按钮组件--深入讨论
1、JButton是AbstractButton的子类
2、属于窗口类组件，可以加入别的组件
3、Swing包的按钮组件不只有JButton，还有单选按钮(JRadioButton)、箭头按钮(BasicArrowButton)、触发器按钮(JToggleButton)。
~~~
/**
* 功能：GUI开发
*/
package com.gui;
import javax.swing.*;
import java.awt.*;
//JFrame是一个顶层容器类（可以添加其他swing组件的类）
public class Gui1 extends JFrame {
//需要的swing组件，定义到这里
JButton jb1 = null;
// 构造函数
public Gui1() {
// 创建了一个Button按钮
jb1 = new JButton("按钮");
// 添加组件
add(jb1);
// 给窗体设置标题
setTitle("hello,world!");
// 设置大小，按像素计算
setSize(200, 200);
// 设置初始位置
setLocation(100, 200);
// 设置当窗口关闭时，保证JVM也退出
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// 显示
setVisible(true);
}
public static void main(String[] args) {
Gui1 gui1 = new Gui1();
}
}
~~~
### 4、三大常用布局管理器
### 布局管理器--介绍
#### 1、概念
组件在容器(比如JFrame)中的位置和大小是由布局管理器来决定的。所有的容器都会
使用一个布局管理器，通过它来自动进行组件的布局管理。
#### 2、种类
java共提供了五种布局管理器：流式布局管理器(FlowLayout)、边界布局管理器(BorderLayout)、网格布局管理器(GridLayout)、卡片布局管理器(CardLayout)、网格包布局管理器(GridBagLayout)。其中前三种是最常见的布局管理器。
##### 边界布局BorderLayout--介绍
边界布局(BorderLayout)将容器简单的划分为东南西北5个区域，中间区域最大。
JFrame窗体，JDialog对话框组件默认布局方法
~~~
/**
* 边界布局
*/
package com.gui;
import java.awt.*;
import javax.swing.*;
//1.继承JFrame
public class Gui2 extends JFrame{
//2.定义组件
JButton jb1, jb2, jb3, jb4, jb5;
public Gui2(){
//3.创建组件
jb1 = new JButton("中部");
jb2 = new JButton("北部");
jb3 = new JButton("东部");
jb4 = new JButton("南部");
jb5 = new JButton("西部");
//4.添加各个组件
add(jb1, BorderLayout.CENTER);
add(jb2, BorderLayout.NORTH);
add(jb3, BorderLayout.EAST);
add(jb4, BorderLayout.SOUTH);
add(jb5, BorderLayout.WEST);
//5.设置窗体属性
setTitle("边界布局");
setSize(300, 200);
setLocation(200, 200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//6.显示窗体
setVisible(true);
}
public static void main(String[] args) {
Gui2 gui1 = new Gui2();
}
}
~~~
##### 边界布局BorderLayout--注意事项
1、不是五个部分都必需添加；
2、中部组件会自动调节大小；
3、JFrame，JDialog默认布局管理器就是BorderLayout
##### 流式布局FlowLayout--介绍
FlowLayout布局，按照组件的添加次序将按钮组件(当然也可以是别的组件)从左到右放置在容器中。当到达容器的边界时，组件将放置到下一行中。FlowLayout可以以左对齐、居中对齐、以右对齐的方式排列组件。
~~~
/**
* 流式布局
*/
package com.gui;
import java.awt.*;
import javax.swing.*;
public class Gui3 extends JFrame{
//定义组件
JButton jb1, jb2, jb3, jb4, jb5, jb6;
//构造函数
public Gui3(){
//创建组件
jb1 = new JButton("Button1");
jb2 = new JButton("Button2");
jb3 = new JButton("Button3");
jb4 = new JButton("Button4");
jb5 = new JButton("Button5");
jb6 = new JButton("Button6");
//添加组件
add(jb1);
add(jb2);
add(jb3);
add(jb4);
add(jb5);
add(jb6);
//设置流式布局
setLayout(new FlowLayout(FlowLayout.RIGHT));
//设置窗体属性
setTitle("流式布局");
setSize(300, 200);
setLocation(200, 200);
//禁止用户改变窗体大小
setResizable(false);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
Gui3 gui1 = new Gui3();
}
}
~~~
##### 流式布局FlowLayout--注意事项
1、不限制他所管理的组件大小，允许他们有最佳大小
2、当容器被缩放、扩大时，组件的位置可能变化，但组件的大小不变。
3、默认组件是居中对齐，可以通过FlowLayout(int align)函数来指定对齐方式。
##### 网格布局GridLayout--介绍
GridLayout布局，听其名而知其意，它将容器分割成多行多列，组件被填充到每个网格中，添加到容器中的组件首先放置在左上角的网格中，然后从左到右放置其它的组件，当占满该行的所有网格后，接着继续在下一行从左到右放置组件。
~~~
/**
* 网格布局
*/
package com.gui;
import java.awt.*;
import javax.swing.*;
public class Gui4 extends JFrame{
int size = 9;
//定义组件;
JButton[] jbs = new JButton[9];
public Gui4(){
//创建组件
for(int i = 0; i < size; i++){
jbs[i] = new JButton("" + i);
}
//设置网格布局
setLayout(new GridLayout(3, 3, 5, 5));
//添加组件
for(int i = 0; i < size; i++){
add(jbs[i]);
}
//设置窗体属性
setTitle("网格布局");
setSize(300, 300);
setLocation(200,200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
Gui4 gui1 = new Gui4();
}
}
~~~
##### 网格布局GridLayout--注意事项
1、组件的相对位置不随容器的缩放而变化，但大小会变化；
2、所有组件的大小相同；
3、可以通过GridLayout(int rows,int cols,int hgap,int vgap)来指定网格的行/列，水平间隙/垂直间隙。
参数说明：rows:行数/cols:列数/hgap:垂直间隙/vgap:水平间隙
#### 3、开发GUI程序步骤
1、继承JFrame(类继承)
2、定义需要的组件(成员变量)
3、创建组件(构造函数中)
4、添加组件(构造方法中)
5、设置布局管理器(构造方法中)
6、显示窗体(构造函数中)
### 5、Swing组件--面板组件
### 面板组件(JPanel)--介绍
在图形用户界面编程中，如果只是普通的组件布局，我们用前面讲的三种布局管理器就可以解决，但在比较复杂的布局要求时，就需要使用布局管理器的组合使用。
JPanel：面板组件，非顶层容器，一个界面只可以有一个JFrame窗体组件，但可以有多个JPanel面板组件，而JPanel上也可以使用FlowLayout、BorderLayout、GirdLayout等各种布局管理器，这样可以组合使用达到较为复杂的布局效果。
~~~
/**
* 多种布局管理器的使用
*/
package com.gui;
import java.awt.*;
import javax.swing.*;
public class Gui5 extends JFrame{
//定义组件
JPanel jp1, jp2;
JButton jb1, jb2, jb3, jb4, jb5, jb6;
//构造方法
public Gui5(){
//创建组件
//JPanel布局默认是FlowLayout
jp1 = new JPanel();
jp2 = new JPanel();
jb1 = new JButton("Button1");
jb2 = new JButton("Button2");
jb3 = new JButton("Button3");
jb4 = new JButton("Button4");
jb5 = new JButton("Button5");
jb6 = new JButton("Button6");
//添加JPanel
jp1.add(jb1);
jp1.add(jb2);
jp2.add(jb3);
jp2.add(jb4);
jp2.add(jb5);
//把JPanel加入JFrame
add(jp1, BorderLayout.NORTH);
add(jb6, BorderLayout.CENTER);
add(jp2, BorderLayout.SOUTH);
//设置窗体
setTitle("多种布局管理器的使用");
setSize(300, 300);
setLocation(200, 200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String args[]){
Gui5 gui1 = new Gui5();
}
}
~~~
### 面板(JPanel)组件--注意事项
1、JPanel是JComponent的子类；
2、属于容器类组件，可以加入别的组件；
3、默认布局管理器是流式布局(FlowLayout)
### Swing组件--文本框/密码框/标签组件
在图形用户界面编程中，我们常常会提供用户登录界面，比如登录到会员管理系统，登录到工资管理系统、仓库管理系统等。这时候我们就会用到：
1、文本框(JTextField)
2、密码框(JPasswordField)
3、标签(JLable)
~~~
package com.gui;
import java.awt.*;
import javax.swing.*;
public class Gui6 extends JFrame{
//定义组件
JPanel jp1, jp2, jp3;
JLabel jlb1, jlb2;
JButton jb1, jb2;
JTextField jtf;
JPasswordField jpf;
//构造方法
public Gui6(){
//创建组件
jp1 = new JPanel();
jp2 = new JPanel();
jp3 = new JPanel();
jlb1 = new JLabel("用户名：");
jlb2 = new JLabel("密 码：");
jb1 = new JButton("登录");
jb2 = new JButton("取消");
jtf = new JTextField(10);
jpf = new JPasswordField(10);
//设置布局管理器
setLayout(new GridLayout(3, 1));
//加入组件
jp1.add(jlb1);
jp1.add(jtf);
jp2.add(jlb2);
jp2.add(jpf);
jp3.add(jb1);
jp3.add(jb2);
//加入到JFrame
add(jp1);
add(jp2);
add(jp3);
//设置窗体
setTitle("登录界面");
setSize(300, 150);
setLocation(500,500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
Gui6 gui1 = new Gui6();
}
}
~~~
### Swing组件--复选框/单选框组件
在图形用户界面编程中，我们常常会提供用户注册界面，这时候我们就会用到：
1、复选框组件(JCheckBox)
2、单选框组件(JRadioBuutton)
特别说明：
同一组单选按钮必需先创建ButtonGroup，然后把单选框组件放入到ButtonGroup中
~~~
package com.gui;
import java.awt.*;
import javax.swing.*;
public class Gui7 extends JFrame{
//定义组件
JPanel jp1, jp2, jp3;
JLabel jl1, jl2;
JButton jb1, jb2;
JCheckBox jcb1, jcb2, jcb3;
JRadioButton jrb1, jrb2;
ButtonGroup bg;
//构造函数
public Gui7(){
//创建组件
jp1 = new JPanel();
jp2 = new JPanel();
jp3 = new JPanel();
jl1 = new JLabel("你喜欢的运动：");
jl2 = new JLabel("你喜欢的运动：");
jb1 = new JButton("注册用户");
jb2 = new JButton("取消注册");
jcb1 = new JCheckBox("足球");
jcb2 = new JCheckBox("篮球");
jcb3 = new JCheckBox("网球");
jrb1 = new JRadioButton("男");
jrb2 = new JRadioButton("女");
//单选组件一定要放入到一个ButtonGroup
//不放入的话，可以多选
bg = new ButtonGroup();
bg.add(jrb1);
bg.add(jrb2);
//设置布局管理器
setLayout(new GridLayout(3, 1));
//添加组件
jp1.add(jl1);
jp1.add(jcb1);
jp1.add(jcb2);
jp1.add(jcb3);
jp2.add(jl2);
jp2.add(jrb1);
jp2.add(jrb2);
jp3.add(jb1);
jp3.add(jb2);
add(jp1);
add(jp2);
add(jp3);
//设置窗体
setTitle("调查报告");
setSize(300, 300);
setLocation(500, 500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
Gui7 gui1 = new Gui7();
}
}
~~~
### Swing组件--下拉框/列表框/流动空格组件
在图形用户界面编程中，常常会提供用户调查界面，这个时候会用到：
1、下拉框组件(JComboBox)
2、列表框组件(JList)
3、滚动窗格组件(JScrollPane)
特别说明：
一般来说，列表框组件+滚动窗格组件是结合使用的。目的是让列表框中的选项可以有滚动条支持。
~~~
package com.gui;
import java.awt.*;
import javax.swing.*;
public class Gui8 extends JFrame{
//定义组件
JPanel jp1, jp2;
JLabel jl1, jl2;
JComboBox jcb;
JList jlist;
JScrollPane jsp;
//构造方法
public Gui8(){
//创建组件
jp1 = new JPanel();
jp2 = new JPanel();
jl1 = new JLabel("你的籍贯：");
jl2 = new JLabel("旅游地点：");
String[] jg = {"北京", "上海", "天津", "火星"};
jcb = new JComboBox(jg);
String[] dd = {"九寨沟", "故宫", "长城", "天安门"};
jlist = new JList(dd);
//设置显示选项个数
jlist.setVisibleRowCount(2);
jsp = new JScrollPane(jlist);
//设置布局
setLayout(new GridLayout(3, 1));
//添加组件
jp1.add(jl1);
jp1.add(jcb);
jp2.add(jl2);
jp2.add(jsp);
add(jp1);
add(jp2);
//设置窗体
setTitle("旅游");
setSize(300, 300);
setLocation(500, 500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
Gui8 gui1 = new Gui8();
}
}
~~~
### Swing组件--总结
总结：
1、Swing的常用组件(JFrame(框架)、Jpanel(面板)、JButton(按钮)、JLable(标签)、JTextField(文本框)、JPasswordField(密码框)、JCheckBox(复选框)、JRadioButton(单选框)、JComboBox(下拉框)、JScrollPane(滚动窗格)、JList(列表框))。
2、三大布局管理器(BorderLayout(边界布局)、FlowLayout(流布局)、GridLayout(网格布局))，要灵活使用，从而满足设计需求。
### 6、GUI编程实践
### 1、拆分窗格(JSplitPane)属于容器类组件
~~~
package com.gui;
import java.awt.*;
import javax.swing.*;
public class Gui9 extends JFrame{
//定义组件
JSplitPane jsp;
JList jlist;
JLabel jl;
//构造方法
public Gui9(){
//创建组件
String[] words = {"boy", "girl", "bird"};
jlist = new JList(words);
jl = new JLabel(new ImageIcon("images/image01.jpg"));
//拆分窗格
jsp = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, jlist, jl);
//可以变化
jsp.setOneTouchExpandable(true);
//添加组件
add(jsp);
//设置窗体
setTitle("分割");
setSize(400, 300);
setLocation(500, 500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
Gui9 gui1 = new Gui9();
}
}
~~~
### 2、多行文本框(JTextArea)组件
~~~
package com.gui;
import java.awt.*;
import javax.swing.*;
public class Gui10 extends JFrame{
//定义组件
JTextArea jta = null;
JPanel jp1 = null;
JComboBox jcb = null;
JTextField jtf = null;
JButton jb = null;
JScrollPane jsp = null;
//构造方法
public Gui10(){
jta = new JTextArea();
jsp = new JScrollPane(jta);
jp1 = new JPanel();
String[] chatter = {"张三","李四"};
jcb = new JComboBox(chatter);
jtf = new JTextField(10);
jb = new JButton("发送");
//添加组件
jp1.add(jcb);
jp1.add(jtf);
jp1.add(jb);
//加入JFrame
add(jsp);
add(jp1, BorderLayout.SOUTH);
//设置窗体
setIconImage((new ImageIcon("images/image01.jpg")).getImage());
setTitle("聊天");
setSize(400, 300);
setLocation(500, 500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
Gui10 gui1 = new Gui10();
}
}
~~~
### 3、页签组件(JTabbedPane)选项卡窗格
~~~
package com.gui;
import java.awt.*;
import javax.swing.*;
public class Gui11 extends JFrame{
//定义组件
JPanel jp1, jp2, jp3, jp4;
JLabel jl1, jl2, jl3, jl4, jl5;
JTextField jtf1;
JPasswordField jpf1;
JCheckBox jcb1, jcb2;
JButton jb1, jb2, jb3, jb4;
JTabbedPane jtp;
//构造函数
public Gui11(){
//创建组件
jp1 = new JPanel();
jp2 = new JPanel();
jp3 = new JPanel();
jp4 = new JPanel();
jl1 = new JLabel(new ImageIcon("images/image01.jpg"));
jl2 = new JLabel("账号");
jl3 = new JLabel("密码");
jl4 = new JLabel("忘记密码");
jl4.setForeground(Color.BLUE);
jl5 = new JLabel("<html><a href='http://blog.csdn.net/q547550831'>访问</a>");
jl5.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
jtf1 = new JTextField(10);
jpf1 = new JPasswordField(10);
jcb1 = new JCheckBox("隐身登录");
jcb2 = new JCheckBox("记住密码");
jb1 = new JButton("清除号码");
jb2 = new JButton("登录");
jb3 = new JButton("注销");
jb4 = new JButton("注册");
jtp = new JTabbedPane();
//设置布局
jp1.setLayout(new GridLayout(3, 3));
jp1.add(jl2);
jp1.add(jtf1);
jp1.add(jb1);
jp1.add(jl3);
jp1.add(jpf1);
jp1.add(jl4);
jp1.add(jcb1);
jp1.add(jcb2);
jp1.add(jl5);
jp2.setBackground(Color.RED);
jp3.setBackground(Color.BLUE);
jtp.add("账号", jp1);
jtp.add("手机号码", jp2);
jtp.add("电子邮件", jp3);
jp4.add(jb2);
jp4.add(jb3);
jp4.add(jb4);
//加入到JFrame
add(jl1, BorderLayout.NORTH);
add(jtp);
add(jp4, BorderLayout.SOUTH);
//设置窗体
setTitle("登录界面");
setIconImage((new ImageIcon("images/image02.jpg")).getImage());
setSize(400, 300);
setLocation(500, 500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
Gui11 gui1 = new Gui11();
}
}
~~~
### 4、菜单组件（JMenuBar、JMenu、JMenuItem）工具条组件（JToolBar）
~~~
package com.gui;
/**
* 1、菜单组件
JMenuBar 菜单条组件 树干
JMenu 菜单组件 树枝
JMenuItem 菜单项组件 树叶
2、二级菜单制作
JMenu里面可以嵌套JMenu
3、工具条组件
JToolBar 容器类组件
*/
import java.awt.*;
import java.awt.event.InputEvent;
import java.awt.event.InputMethodEvent;
import java.awt.event.KeyEvent;
import javax.swing.*;
public class Gui12 extends JFrame{
//文件组定义组件
JMenuBar jmb;//菜单条组件
JMenu menu1,menu2,menu3,menu4,menu5;//主菜单：文件、编辑、格式、查看、帮助
JMenuItem item2,item3,item4,item5,item6,item7;//子菜单：新建、打开、保存、另存为、页面设置、打印、退出
JMenu xinjian;//二级菜单
JMenuItem file,project;
//编辑组定义组件
//编辑：撤消、剪切、复制、粘贴、删除、查找、查找下一个、替换、转到、全选、时间/日期
JMenuItem eitem1,eitem2,eitem3,eitem4,eitem5,eitem6,eitem7,eitem8,eitem9,eitem10,eitem11;
//格式组定义组件
JMenuItem oitem1,oitem2;//格式：自动换行、字体
//查看组定义组件
JMenuItem vitem1;//查看：状态栏
//帮助组定义组件
JMenuItem hitem1,hitem2;//帮助：查看帮助、关于记事本
JTextArea jta;
//工具条
JToolBar jtb;
JButton jb1,jb2,jb3,jb4,jb5,jb6,jb7,jb8;
public static void main(String[] args) {
Gui12 win=new Gui12();
}
//构造函数
public Gui12(){
//构建组件
//工具条
jtb=new JToolBar();
jb1=new JButton(new ImageIcon("images/new.jpg"));
jb1.setToolTipText("新建");//设置提示信息
jb2=new JButton(new ImageIcon("images/open.jpg"));
jb2.setToolTipText("打开");
jb3=new JButton(new ImageIcon("images/save.jpg"));
jb3.setToolTipText("保存");
jb4=new JButton(new ImageIcon("images/copy.jpg"));
jb4.setToolTipText("复制");
jb5=new JButton(new ImageIcon("images/delete.jpg"));
jb5.setToolTipText("删除");
jb6=new JButton(new ImageIcon("images/modify.jpg"));
jb6.setToolTipText("编辑");
jb7=new JButton(new ImageIcon("images/print.jpg"));
jb7.setToolTipText("打印");
jb8=new JButton(new ImageIcon("images/close.jpg"));
jb8.setToolTipText("关闭");
jmb=new JMenuBar();
//主菜单
menu1=new JMenu("文件(F)");
menu1.setMnemonic('F');//设置助记符
menu2=new JMenu("编辑(E)");
menu2.setMnemonic('E');
menu3=new JMenu("格式(O)");
menu3.setMnemonic('O');
menu4=new JMenu("查看(V)");
menu4.setMnemonic('V');
menu5=new JMenu("帮助(H)");
menu5.setMnemonic('H');
//文件--新建--子目录
xinjian=new JMenu("新建");
file=new JMenuItem("文件");
project=new JMenuItem("工程");
item2=new JMenuItem("打开(O)");
item2.setMnemonic('O');
item2.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O,InputEvent.CTRL_MASK));//设置ctrl快捷组合键
item3=new JMenuItem("保存(S)");
item3.setMnemonic('S');
item3.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,InputEvent.CTRL_MASK));
item4=new JMenuItem("另存为(A)");
item4.setMnemonic('A');
item5=new JMenuItem("页面设置(U)");
item5.setMnemonic('U');
item6=new JMenuItem("打印(P)");
item6.setMnemonic('P');
item6.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P,InputEvent.CTRL_MASK));
item7=new JMenuItem("退出(X)");
item7.setMnemonic('X');
eitem1=new JMenuItem("撤消(U)");
eitem1.setMnemonic('U');
eitem1.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_U,InputEvent.CTRL_MASK));
eitem2=new JMenuItem("剪切(T)");
eitem2.setMnemonic('T');
eitem2.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_T,InputEvent.CTRL_MASK));
eitem3=new JMenuItem("复制(C)");
eitem3.setMnemonic('C');
eitem3.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C,InputEvent.CTRL_MASK));
eitem4=new JMenuItem("粘贴(P)");
eitem4.setMnemonic('P');
eitem4.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P,InputEvent.CTRL_MASK));
eitem5=new JMenuItem("删除(L)");
eitem5.setMnemonic('L');
eitem5.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE,0));
eitem6=new JMenuItem("查找(F)");
eitem6.setMnemonic('F');
eitem6.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F,InputEvent.CTRL_MASK));
eitem7=new JMenuItem("查找下一个(N)");
eitem7.setMnemonic('N');
eitem7.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F3,0));
eitem8=new JMenuItem("替换(R)");
eitem8.setMnemonic('R');
eitem8.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R,InputEvent.CTRL_MASK));
eitem9=new JMenuItem("转到(G)");
eitem9.setMnemonic('G');
eitem9.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_G,InputEvent.CTRL_MASK));
eitem10=new JMenuItem("全选(A)");
eitem10.setMnemonic('A');
eitem10.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A,InputEvent.CTRL_MASK));
eitem11=new JMenuItem("时间/日期(D)");
eitem11.setMnemonic('D');
eitem11.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F5,0));
oitem1=new JMenuItem("自动换行(W)");
oitem1.setMnemonic('W');
oitem2=new JMenuItem("字体(F)");
oitem2.setMnemonic('F');
vitem1=new JMenuItem("状态栏(S)");
vitem1.setMnemonic('S');
hitem1=new JMenuItem("查看帮助(H)");
hitem1.setMnemonic('H');
hitem2=new JMenuItem("关于记事本(A)");
hitem2.setMnemonic('A');
jta=new JTextArea();
//设定布局管理器
//加入组件
//将按钮添加到工具条上
jtb.add(jb1);
jtb.add(jb2);
jtb.add(jb3);
jtb.add(jb4);
jtb.add(jb5);
jtb.add(jb6);
jtb.add(jb7);
jtb.add(jb8);
//将菜单项添加到菜单上
xinjian.add(file);
xinjian.add(project);
menu1.add(xinjian);
menu1.add(item2);
menu1.add(item3);
menu1.add(item4);
menu1.addSeparator();//添加分割线
menu1.add(item5);
menu1.add(item6);
menu1.addSeparator();
menu1.add(item7);
menu2.add(eitem1);
menu2.addSeparator();
menu2.add(eitem2);
menu2.add(eitem3);
menu2.add(eitem4);
menu2.add(eitem5);
menu2.addSeparator();
menu2.add(eitem6);
menu2.add(eitem7);
menu2.add(eitem8);
menu2.add(eitem9);
menu2.addSeparator();
menu2.add(eitem10);
menu2.add(eitem11);
menu3.add(oitem1);
menu3.add(oitem2);
menu4.add(vitem1);
menu5.add(hitem1);
menu5.addSeparator();
menu5.add(hitem2);
//将菜单添加到菜单条上
jmb.add(menu1);
jmb.add(menu2);
jmb.add(menu3);
jmb.add(menu4);
jmb.add(menu5);
//将菜单条添加到窗体上
this.setJMenuBar(jmb);
//将工具条添加到窗体上
this.add(jtb,BorderLayout.NORTH);
JScrollPane jsp=new JScrollPane(jta);
jsp.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
this.add(jsp);
//窗体设置
this.setTitle("Java记事本");
this.setSize(500, 400);
this.setLocationRelativeTo(null);
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
~~~
### 7、java绘图坐标体系
### 绘图坐标本系--介绍
坐标原点位于左上角，以像素为单位。像素是计算机屏幕上最小的显示单位。在java的坐标系中，第一个是X坐标，表示当前位置为水平方向，距离坐标原点X个像素；第二个是Y坐标，表示当前位置为垂直方向，距离坐标原点Y个像素。
### 坐标体系--像素
计算机在屏幕上显示的内容都是由屏幕上的每一个像素组成的。例如，计算机显示器的分辨率是800×600，表示计算机屏幕上的每一行由800个点组成，共有600行，整个计算机屏幕共有480000个像素。现在的计算机可以支持更高的分辨率，也就是说，屏幕上可以显示更多的像素。因此，像素是一个密度单位，而厘米是长度单位，两者无法比较。
### 绘图原理(1)
Component类提供了两个和绘图相关最重要的方法：
1、paint(Graphics g)绘制组件的外观
2、repaint()刷新组件的外观
当组件第一次在屏幕显示的时候，程序会自动的调用paint()方法来绘制组件
### 绘图原理(2)
在以下情况paint()将会被调用：
1、窗口最小化，再最大化
2、窗口的大小发生变化
3、repaint函数被调用
### java绘图技术--Graphics
#### Graphics类
Graphics类你可以理解就是画笔，为我们提供了各种绘制图形的方法：
1、画直线 drawLine(int x1,int y1,int x2,int y2);
2、画矩形边框 drawRect(int x,int y,int width,int height);
3、画椭圆边框 drawOval(int x,int y,int width,int height);
4、填充矩形 fillRect(int x,int y,int width,int height);
5、填充椭圆 fillOval(int x,int y,int width,int height);
6、画图片 drawImage(Image img.int x,int y,..);
7、画字符串 drawString(String str,int x,int y);
8、设置画笔的字体 setFont(Font font);
9、设置画笔的颜色 setColor(Color c);
~~~
package com.gui;
import java.awt.*;
import javax.swing.*;
public class Gui13 extends JFrame{
MyPanel mp = null;
public Gui13(){
mp = new MyPanel();
add(mp);
setSize(400, 300);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
Gui13 gui1 = new Gui13();
}
}
//定义一个MyPanel,用于绘图和显示绘图的区域
class MyPanel extends JPanel{
//覆盖JPanel的paint方法
//Graphics是绘图的重要类，等价于画笔
public void paint(Graphics g){
//1.调用父类方法，完成初始化
super.paint(g);
//空心圆
//g.drawOval(10, 10, 30, 30);
//直线
//g.drawLine(10, 10, 40, 40);
//空心矩形
//g.drawRect(10, 10, 40, 60);
//填充矩形
// g.setColor(Color.BLUE);
// g.fillRect(10, 10, 40, 60);
// g.setColor(Color.RED);
// g.fillRect(70, 70, 40, 60);
//在面板上画出图片
// Image im = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/images/image01.jpg"));
// g.drawImage(im, 10, 10, 200, 150, this);
//字符
// g.setColor(Color.red);
// g.setFont(new Font(("隶书"), Font.BOLD, 30));
// g.drawString("String 字符串", 100, 100);
//圆的轮廓
g.drawArc(100, 100, 100, 100, 20, 300);
}
}
~~~
### 8、java事件处理机制
### java事件处理机制--初步介绍
java事件处理是采取“委派事件模型”。所谓“委派事件模型”是指当事件发生时，产生事件的对象(即事件源)，会把此“信息”传递给“事件的监听者”处理的一种方式，而这里所说的“信息”实际上就是java.awt.event事件类库里某个类所创建的对象，我们暂时把它称为“事件的对象”。
比如：当按下按钮时，就会在按钮触发一个“事件”，程序就会产生一个“事件对象”来表示这个事件，并把这个“事件对象”传递给“事件的监听者”，“事件的监听者”再根据“事件对象”的类型进行相应处理。
为了让“产生事件的对象”[比如按钮]知道要把事件传递给哪一个“事件监听者”，我们必需先把“事件监听者”在“产生事件的对象”注册，这个操作也就是要告知“产生事件的对象”要把事件传递给它。
~~~
/**
* 功能：事件处理机制
*/
package com.gui;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class Gui14 extends JFrame implements ActionListener{
//定义组件
Panel mp = null;
JButton jb1, jb2;
public Gui14(){
mp = new Panel();
//设置背景颜色
mp.setBackground(Color.black);
jb1 = new JButton("黑色");
jb2 = new JButton("红色");
add(jb1, BorderLayout.NORTH);
add(mp);
add(jb2, BorderLayout.SOUTH);
//注册监听
jb1.addActionListener(this);
jb2.addActionListener(this);
//事件源是jb1,jb2,事件监听者是gui14的对象
//指定action命令
jb1.setActionCommand("黑色");
jb2.setActionCommand("红色");
//设置窗体
setSize(300, 200);
setLocation(500, 500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
Gui14 gui1 = new Gui14();
}
//对事件处理的方法
@Override
public void actionPerformed(ActionEvent e) {
//判断是哪个按钮被点击
if(e.getActionCommand().equals("黑色")){
//System.out.println("黑色");
mp.setBackground(Color.black);
} else if(e.getActionCommand().equals("红色")){
//System.out.println("红色");
mp.setBackground(Color.red);
} else {
}
}
}
class MyPanel2 extends JPanel{
public void paint(Graphics g){
}
}
~~~
~~~
/**
* 1.通过上下左右键来控制一个小球的移动
*/
package com.gui;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class Gui15 extends JFrame{
//定义组件
MyPanel3 mp =null;
public Gui15(){
mp = new MyPanel3();
//mp加入JFrame
add(mp);
//添加监听
addKeyListener(mp);
//设置窗体
setTitle("小球");
setSize(400, 300);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
Gui15 gui1 = new Gui15();
}
}
//定义自己的面板
class MyPanel3 extends JPanel implements KeyListener{
private int x = 10;
private int y = 10;
public void paint(Graphics g){
super.paint(g);
//圆
g.fillOval(x, y, 20, 20);
}
//输入的一个具体信息
@Override
public void keyTyped(KeyEvent e) {
// TODO Auto-generated method stub
//System.out.println("typed");
}
//按压
@Override
public void keyPressed(KeyEvent e) {
// TODO Auto-generated method stub
//System.out.println("press");
//向下 向上 向左 向右
if(e.getKeyCode() == KeyEvent.VK_DOWN){
y += 2;
} else if(e.getKeyCode() == KeyEvent.VK_UP){
y -= 2;
} else if(e.getKeyCode() == KeyEvent.VK_LEFT){
x -= 2;
} else if(e.getKeyCode() == KeyEvent.VK_RIGHT){
x += 2;
}
//调用repaint()方法，重绘面板
repaint();
}
//释放
@Override
public void keyReleased(KeyEvent e) {
// TODO Auto-generated method stub
//System.out.println("released" + (char)e.getKeyCode());
}
}
~~~
### java事件处理机制--深入理解
#### 1、事件源
事件源是一个产生(或触发)事件的对象，比如前面的JButton的一个对象jb1。当这个事件源对象的某些状态以某种方式发生变化时，就会产生某种类型的事件(一个事件源可能会生成多个不同类型的事件)。如果某个组件(对象)希望得到事件源产生的事件，就需要在这个事件源上注册。
#### 2、事件
事件就是承载事件源状态改变时的信息对象。或者说，事件是事件源事件监听器传输事件源状态信息的载体。在用户与GUI组件进行交互时就会生成事件，比如当鼠标在面板中移动时，就会生成一个鼠标移动事件的对象，而这个对象保存着当前鼠标在面板中位置信息。java.awt.event包和javax.swing.event包中定义了各种事件类型，常见的事件类有：
<table><tbody><tr><td valign="top"><p>事件类</p></td><td valign="top"><p>说明</p></td></tr><tr><td valign="top"><p>ActionEvent</p></td><td valign="top"><p>通常在按下按钮，或双击一个列表项或选中某个菜单时发生</p></td></tr><tr><td valign="top"><p>AdjustmentEvnet</p></td><td valign="top"><p>当操作一个滚动条时发生</p></td></tr><tr><td valign="top"><p>ComponentEvent</p></td><td valign="top"><p>当一个组件隐藏、移动、改变大小时发送</p></td></tr><tr><td valign="top"><p>ContainerEvent</p></td><td valign="top"><p>当一个组件从容器中加入或者删除时发生</p></td></tr><tr><td valign="top"><p>FocusEvent</p></td><td valign="top"><p>当一个组件获得或是失去焦点时发生</p></td></tr><tr><td valign="top"><p>ItemEvent</p></td><td valign="top"><p>当一个复选框或是列表项被选中时，当一个选择框或选择菜单被选中</p></td></tr><tr><td valign="top"><p>KeyEvent</p></td><td valign="top"><p>当从键盘的按键被按下，松开时发生</p></td></tr><tr><td valign="top"><p>MouseEvent</p></td><td valign="top"><p>当鼠标被拖动、移动、点击、按下..</p></td></tr><tr><td valign="top"><p>TextEvent</p></td><td valign="top"><p>当文本区和文本域的文本发生改变时发生</p></td></tr><tr><td valign="top"><p>WindowEvent</p></td><td valign="top"><p>当一个窗口激活、关闭、失效、恢复、最小化...</p></td></tr></tbody></table>
#### 3、事件监听器接口
事件源产生一个事件，可以传送给事件监听者处理，那么怎样才能编写一个事件监听者呢？
事件监听者实际上就是一个类，该类实现了某个事件监听器接口、比如前面我们案例中的MyPanel就是一个类，它实现了ActionListener接口，它就可以作为一个事件监听者，对接受到的事件进行处理。
事件监听器接口有多种，不同的事件监听器接口可以监听不同的事件，一个类可以实现一个事件监听接口，也可以实现多个监听接口，这些接口在java.awt.event和javax.swing.event包中定义。
~~~
package com.gui;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class Gui16 extends JFrame{
//定义组件
MyPanel4 mp = null;
//构造方法
public Gui16(){
mp = new MyPanel4();
//mp加入JFrame
add(mp);
//注册监听
addMouseListener(mp);
addKeyListener(mp);
addMouseMotionListener(mp);
//设置窗体
setSize(400, 300);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
Gui16 gui1 = new Gui16();
}
}
//1 鼠标按下输出坐标，移出，移入，按下，释放
//2.按键按下对应字符
//3.鼠标移动、拖拽
//4.窗口变化(关闭，最小化，最大化)
//定义自己的面板
class MyPanel4 extends JPanel implements MouseListener, KeyListener, MouseMotionListener, WindowListener{
public void paint(Graphics g){
super.paint(g);
}
//鼠标
//鼠标点击
@Override
public void mouseClicked(MouseEvent e) {
// TODO Auto-generated method stub
System.out.println("鼠标点击了 x = " + e.getX() + " y = " + e.getY());
}
//鼠标按下
@Override
public void mousePressed(MouseEvent e) {
// TODO Auto-generated method stub
System.out.println("鼠标按下");
}
//鼠标松开
@Override
public void mouseReleased(MouseEvent e) {
// TODO Auto-generated method stub
System.out.println("鼠标松开");
}
//鼠标移动到MyPanel4
@Override
public void mouseEntered(MouseEvent e) {
// TODO Auto-generated method stub
System.out.println("鼠标移出");
}
//鼠标移出MyPanel4
@Override
public void mouseExited(MouseEvent e) {
// TODO Auto-generated method stub
System.out.println("鼠标进入");
}
//鼠标拖拽
@Override
public void mouseDragged(MouseEvent e) {
// TODO Auto-generated method stub
}
//鼠标移动
@Override
public void mouseMoved(MouseEvent e) {
// TODO Auto-generated method stub
System.out.println("鼠标当前坐标x = " + e.getX() + " Y = " + e.getY());
}
//键盘
//输入具体信息
@Override
public void keyTyped(KeyEvent e) {
// TODO Auto-generated method stub
}
//按下
@Override
public void keyPressed(KeyEvent e) {
// TODO Auto-generated method stub
System.out.println(e.getKeyChar() + "键被按下");
}
//释放
@Override
public void keyReleased(KeyEvent e) {
// TODO Auto-generated method stub
}
//窗口
//窗口打开
@Override
public void windowOpened(WindowEvent e) {
// TODO Auto-generated method stub
}
//窗口正在关闭
@Override
public void windowClosing(WindowEvent e) {
// TODO Auto-generated method stub
}
//窗口关闭
@Override
public void windowClosed(WindowEvent e) {
// TODO Auto-generated method stub
}
//窗口最小化
@Override
public void windowIconified(WindowEvent e) {
// TODO Auto-generated method stub
}
//窗口最小化到显示
@Override
public void windowDeiconified(WindowEvent e) {
// TODO Auto-generated method stub
}
//窗口被激活了
@Override
public void windowActivated(WindowEvent e) {
// TODO Auto-generated method stub
}
//窗口变成非激活窗口
@Override
public void windowDeactivated(WindowEvent e) {
// TODO Auto-generated method stub
}
}
~~~
### java事件处理机制--总结
#### 总结--事件编程步骤：
1、编写事件处理类(事件监听者)
2、根据需求给事件处理类实现监听器接口
3、在事件处理中重写(实现)其事件处理的函数
4、在事件源类中指定该事件的监听器(响应者)是谁
#### 注意事项：
1、java采用委托机制处理事件
2、java中的事件是分类的，比如对窗体事件、鼠标事件、按键事件、操作事件[按按钮]
3、java中一个类要监听某个事件，则必需实现相应的事件监听接口
4、事件监听接口有多种，程序员应当针对不同的情况，实现不同的监听接口，比如监听鼠标事件就应当实现MouseListener;要监听键盘事件，就应当实现KeyListener..
5、在实现监听接口的类(事件监听类/者)中，需要重写处理函数，比如实现了ActionListener接口，就应当重写actionPerformed(ActionEvent e),可以参考前面的事件监听器接口表格
6、在事件源中需要注册事件监听类。否则事件监听类接收不到事件源发生的事件。
#### 一个类要实现监听的步骤：
a、实现相应的接口[KeyListener/MouseListener/ActionListener/WindowListener]
b、把接口的处理方法根据需要重新编写(Override)
c、在事件源上注册监听
d、事件传递是靠事件(类)对象
----------参考《韩顺平.循序渐进学.java.从入门到精通》
----------参考《JDK_API_1_6_zh_CN》
Java学习笔记--导航[http://blog.csdn.net/q547550831/article/details/49819641](http://blog.csdn.net/q547550831/article/details/49819641)
