1 //java基础视频教程第22天-01-GUI(概述)
2 /*
3 本节课主要讲解了GUI的概述，主要包括以下几点
4 1.GUI和CLI
5 GUI（图形命令接口）Graphical User Interface
6 CLI（命令行用户接口）Command line User Interface
7 2.java中为图形用户接口提供的对象有java.Awt和javax.Swing
8 (1)Awt(Abstract Window ToolKit)比较依赖于系统，所以属于重量级控件
9 (2)Swing是完全基于Awt，它依赖系统相对Awt少了很多，所以属于轻量级控件
10 3.继承关系
11 Component(组件)
12 |--Button(按钮)
13 |--Lable(标签)
14 |--Checkbox(复选框)
15 |--TextComponnet(文本组件)
16 |--TextArea（文本区域）
17 |--TextField（文本框）
18 |--Container（容器）
19 |--Panel（面板）
20 |--Window（窗口）
21 |--Frame（框架）
22 |--Dialog（对话框）
23 |--FileDialog（文件对话框）
24 */
1 //java基础视频教程第22天-02-GUI（布局）
2 /*
3 本节课主要讲解了几种布局方式
4 1.FlowLayout(流式布局)，
5 2.BorderLayout(边界布局管理器),Frame默认布局
6 3.GridLayout(网格布局管理器)
7 4.GardLayout（卡片布局）
8 5.GridBagLayout(网格包布局)
9 */
1 //java基础视频教程第22天-03-GUI（Fram）
2 /*
3 本节课主要讲解了创建图形化界面的五个步骤，主要用到的Component方法有如下几个
4 public void setVisible(boolean b),显示组件
5 public void setSize(int width,int height)，设置组件宽高
6 public void setLocation(int x,int y),设置组件的位置
7 public void add(PopupMenu popup)，向组件添加新的组件
8 public Frame(String title),构造一个不可见的frame，这个是Frame的构造方法
9 public Button(String label),构造一个带指定标签的按钮
10 public void setLayout(LayoutManager mgr),设置布局
11
12 Frame默认的布局是边界式布局，如果没有指点边界布局的东南西北，它会默认居中填充
13 步骤：
14 1.创建Frame窗体
15 2.设置Frame窗体的大小，位置，布局
16 3.创建组件
17 4.将组件添加到Frame中
18 5.设置Frame窗体可见
19
20
21 */
22 import java.awt.*;
23 class AwtDemo
24 {
25 public static void main(String[] args)
26 {
27 Frame f = new Frame("哈哈"); //创建一个看不见的Frame，名字为哈哈
28 f.setVisible(true); //显示Frame
29 f.setSize(500,500); //设置Frame的宽高
30 f.setLocation(500,500); //设置Frame默认出现的位置
31 Button b = new Button("按钮"); //构造一个名为按钮的按钮
32 f.add(b); //将按钮添加到Frame组件中去，如果没有指点布局，则按钮会填充整个布局
33 f.setLayout(new FlowLayout()); //设置布局为流式布局
34
35 }
36 }
1 //java基础视频教程第22天-04-GUI（事件监听机制）
2 /*
3 本节课主要围绕着事件监听机制流程图来讲解的
4 监听机制主要有如下几点组成
5 1.外部动作
6 2.事件源（组件）
7 3.事件
8 4.监听器
9 5.事件处理
10 其中事件处理是由我们来写的
11 流程：由外部动作引发事件源产生事件对象，然后把事件对象传递给监听器，引发监听器中相关的处理事件动作，其中监听器是注册到事件源上的
12
13 */
1 //java基础视频教程第22天-05-GUI（窗体事件）
2 /*
3 本节课主要讲解了如何实现监听关闭，用到的方法如下
4 public void addWindowListener(WindowListener l),添加窗口监听器
5 public interface WindowListener（窗口监听器接口）,添加监听器的参数是一个接口，并且接口中有七个事件方法，显然创建它的子类并实现它，然后在new子类对象比较麻烦，包括匿名内部类也是一样，因为有七个方法要实现
6 public abstract class WindowAdapter（窗口抽象适配器），它是窗口监听器接口的子类，并且是一个抽象的（防止建立对象），而且还继承了WindowListener的方法（这些方法并不是抽象的），那么我们可以创建子类继承它，调用其中的事件方法
7 public void windowClosing(WindowEvent e),窗口正在关闭时调用
8 public void windowActivated(WindowEvent e),窗口激活调用
9 public void windowOpened(WindowEvent e),已打开窗口时调用
10 e.toString()打印的事件
11 sun.awt.TimedWindowEvent[WINDOW_CLOSING,opposite=null,oldState=0,newState=0] on frame0
12 注意：要把显示窗口放在addWindowListener之后，不然windowOpened不起作用
13
14 */
15 import java.awt.*;
16 import java.awt.event.*; //事件监听属于这个包，WindowListener
17 class AwtDemo1
18 {
19 public static void main(String[] args)
20 {
21 Frame f = new Frame("窗体");
22 f.setSize(500,500);
23 f.setLocation(500,500);
24
25 Button b = new Button("按钮");
26 f.add(b);
27 f.setLayout(new FlowLayout());
28 //f.addWindowListener(new MyWin()); 可用匿名内部类来代替
29 f.addWindowListener(new WindowAdapter(){ //添加window监听器
30
31 public void windowActivated(WindowEvent e)
32 {
33 System.out.println("激活状态");
34 }
35 public void windowClosing(WindowEvent e)
36 {
37 System.out.println(e.toString());
38 System.exit(0);
39 }
40 public void windowOpened(WindowEvent e) //打开调用怎么没有作用？？？
41 {
42 System.out.println("我没用，怎么回事！");
43 }
44 });
45 f.setVisible(true); //注意：要把显示窗口放在addWindowListener之后，不然windowOpened不起作用
46
47 }
48
49 }
50 /*
51 class MyWin extends WindowAdapter
52 {
53 public void windowClosing(WindowEvent e)
54 {
55 System.exit(0);
56 }
57 public void windowActivated(WindowEvent e)
58 {
59 System.out.println("激活啦");
60 }
61 public void windowOpened(WindowEvent e)
62 {
63 System.out.println("windowClosing"+e.toString()); //打印出事件
64 }
65 }
66 */
1 //java基础视频教程第22天-06-GUI（Action事件）
2 /*
3 本节课主要有两点
4 1.将窗体和事件分离开来
5 2.让按钮具备退出程序的功能
6 public void setBounds(int x,int y,int width,int height),设置组件的位置和宽高，相当于setLocation()和setSize()的组合
7 public void addActionListener(ActionListener l),为按钮添加监听器，它接收的是一个ActionListener接口，接口只有一个方法actionPerformed(ActionEvent e)
8 void actionPerformed(ActionEvent e)，发生操作时调用,可以用匿名内部类
9
10 WindowListener()和ActiveListener的区别
11 这两个都是接口，
12 WindowListener()有七个方法，而且有四个子类，鉴于它的方法多，就用一个抽象类继承它AdapterListener，然后用这个子类去作匿名内部类
13 ActiveListener()只有一个方法，有很多子类，鉴于它的方法很少，可以用它作为匿名内部类
14 综上，当监听器的方法较多时，必须由一个适配器来调用父类的方法
15
16 */
17 import java.awt.*;
18 import java.awt.event.*;
19 class FrameDemo
20 {
21 public static void main(String[] args)
22 {
23 new Init();
24 }
25 }
26 class Init
27 {
28 private Frame f;
29 private Button b;
30 Init()
31 {
32 myFrame();
33 }
34 public void myFrame() //分离窗体
35 {
36 f = new Frame("My Frame");
37 f.setBounds(500,500,500,500);
38 f.setLayout(new FlowLayout()); //设置布局为流式布局
39 b = new Button("Button");
40 f.add(b);
41 myEvent();
42 f.setVisible(true); //设置窗体可见
43 }
44 public void myEvent() //分离事件
45 {
46 f.addWindowListener(new WindowAdapter(){
47 public void windowClosing(WindowEvent e) //注意，关闭事件是windowClosing
48 {
49 System.exit(0);
50 }
51 });
52 b.addActionListener(new ActionListener(){ //让按钮具备退出程序功能
53 public void actionPerformed(ActionEvent e)
54 {
55 System.out.println("按钮关闭");
56 System.exit(0);
57
58 }
59 });
60 }
61 }
1 //java基础视频教程第22天-07-GUI（鼠标事件）
2 /*
3 本节课主要讲解了鼠标事件
4 1.把鼠标放在button就发生事件
5 在那个组件上发生的事件就到那个组件去找相应的方法Mouse和Key都数据大众就到Component里面去找
6 public void addMouseListener(MouseListener l)，为组件添加鼠标监听器，它的参数是一个拥有五个方法的接口
7 所以它必须有子类适配器MouseAdapter()来调用方法,于是就可用鼠标适配器MouseAdapter来作匿名内部类
8
9 2.鼠标双击Button时发生事件
10 MouseEvent 中有获取鼠标点击次数的方法
11 public int getClickCount()，通过设置获取点击次数为2次实现双击事件
12
13 */
14 import java.awt.*;
15 import java.awt.event.*;
16 class MouseEventDemo
17 {
18 public static void main(String[] args)
19 {
20 new Init();
21 }
22 }
23 class Init
24 {
25 private Frame f;
26 private Button b;
27 Init()
28 {
29 myFrame();
30 }
31 public void myFrame()
32 {
33 f = new Frame("窗体");
34 f.setBounds(500,500,500,500);
35 f.setLayout(new FlowLayout());
36 b = new Button("button");
37 f.add(b);
38 myEvent();
39 f.setVisible(true);
40 }
41 public void myEvent()
42 {
43
44 f.addWindowListener(new WindowAdapter(){ //窗口事件
45 public void windowClosing(WindowEvent e)
46 {
47 System.out.println("Bye Bye!");
48 System.exit(0);
49 }
50 });
51 b.addActionListener(new ActionListener(){ //激活按钮比鼠标点击按钮要后执行
52 private int actionCount =0;
53 public void actionPerformed(ActionEvent e)
54 {
55 System.out.println("第"+actionCount+++"次激活按钮");
56 }
57 });
58 b.addMouseListener(new MouseAdapter(){
59 private int enteredCount =0;
60 private int clickedCount = 0;
61 private int doubleClickCount = 0;
62 public void mouseEntered(MouseEvent e) //鼠标放在按钮上事件
63 {
64 System.out.println("鼠标第"+enteredCount+++"出现在按钮上");
65 }
66
67 /*
68 public void mouseClicked(MouseEvent e) //鼠标单击事件
69 {
70 System.out.println("鼠标第"+clickedCount+++"点击按钮");
71 }
72 */
73 public void mouseClicked(MouseEvent e) //鼠标双击事件
74 {
75 if(e.getClickCount()==2) //设置鼠标点击次数
76 System.out.println("鼠标双击按钮"+doubleClickCount++);
77 }
78
79 });
80
81
82 }
83 }
1 //java基础视频教程第22天-08-GUI（键盘事件）
2 /*
3 public char getKeyChar()，返回打的字符，
4 public int getKeyCode()，返回打的字符的对应的数字
5 public static String getKeyText(int keyCode),返回键的文本
6 public void consume(),禁止默认方式处理
7 本节课主要讲解了两点
8 1.键盘事件
9 (1).打印出按的键对应的字符以及对应的整数
10 (2).打印出按的键对应的文本以及对应的整数
11 (3).当按ESC键盘退出窗体
12 2.文本框组件
13 (1).要求文本框中输入的只能是数字
14 public void consume()，使用此事件，以便不会按照默认的方式由产生此事件的源代码来处理此事件。
15
16 */
17 import java.awt.*;
18 import java.awt.event.*;
19 class KeyEventDemo
20 {
21 public static void main(String[] args)
22 {
23 new Init();
24 }
25 }
26 class Init
27 {
28 private Frame f;
29 private Button b;
30 private TextField tf;
31 Init()
32 {
33 myFrame();
34 }
35 public void myFrame()
36 {
37 f=new Frame("框架");
38 f.setBounds(500,500,500,500);
39 f.setLayout(new FlowLayout());
40 b=new Button("按钮");
41 tf=new TextField(15); //创建一个文本框组件，长度为15
42 f.add(b);
43 f.add(tf);
44 myEvent();
45 f.setVisible(true);
46 }
47 public void myEvent()
48 {
49 f.addWindowListener(new WindowAdapter(){ //添加窗体监听器
50 public void windowClosing(WindowEvent e) //窗体事件
51 {
52 System.exit(0);
53 }
54 });
55 b.addActionListener(new ActionListener(){ //添加动作监听器，没有适配器
56 public void actionPerformed(ActionEvent e)
57 {
58 System.out.println("哈哈");
59 }
60 });
61 b.addMouseListener(new MouseAdapter(){
62 private int mouseEnteredCount =0;
63 private int mouseClickedCount =0;
64 public void mouseEntered(MouseEvent e)
65 {
66 System.out.println("mouseEnteredCount"+mouseEnteredCount++);
67 }
68 public void mouseClicked(MouseEvent e)
69 {
70 System.out.println("mouseClickCount"+mouseClickedCount++);
71 }
72 });
73 b.addKeyListener(new KeyAdapter(){ //为按钮添加键盘监听器
74 public void keyPressed(KeyEvent e)
75 {
76 //System.out.println(e.getKeyChar()+"---"+e.getKeyCode()); //打印出键盘按键对应以及对应的数字
77 System.out.println(e.getKeyText(e.getKeyCode())+"---"+e.getKeyCode()); //打印出数字对应的键的文本以及键的数字
78 if(e.getKeyCode()==KeyEvent.VK_ESCAPE) //当按了ESC键就退出
79 System.exit(0);
80 }
81 });
82 tf.addKeyListener(new KeyAdapter(){
83 public void keyPressed(KeyEvent e)
84 {
85 if(!(e.getKeyCode()>=KeyEvent.VK_0&&e.getKeyCode()<=KeyEvent.VK_9))
86 {
87 System.out.println("非法字符！");
88 e.consume(); //如果是不是数字的话就不要放入到文本框里面去，默认的是放入到文本框去，这里用这个方法就是为了不用默认的方式处理
89 }
90 System.out.println(e.getKeyCode()+"---"+e.getKeyChar());
91 }
92 });
93 }
94 }
1 //java基础视频教程第22天-09-GUI（练习-列出指定目录内容）
2 /*
3 本节课主要模拟在文本框中输入一个地址，然后按按钮之后在文本区域中获得这个地址的所有文件及文件夹名称
4 主要用的方法有如下
5 文本框(textField)以及文本区域(textArea)的父类(Component)方法
6 public String getText()，获取文本内容
7 public String setText(),设置文本内容
8 还用到文本区域(textArae)的方法
9 public void append(String str),追加文本
10
11 */
12 import java.awt.*;
13 import java.awt.event.*;
14 import java.io.*;
15 class MyWindowDemo
16 {
17 public static void main(String[] args)
18 {
19 new Init();
20 }
21 }
22 class Init
23 {
24 private Frame f;
25 private Button b;
26 private TextField tf;
27 private TextArea ta;
28 Init()
29 {
30 myFrame();
31 }
32 public void myFrame()
33 {
34 f=new Frame("my frame");
35 f.setBounds(500,500,500,500);
36 f.setLayout(new FlowLayout());
37 tf=new TextField(50);
38 f.add(tf);
39 b=new Button("button");
40 f.add(b);
41 ta=new TextArea(25,60);
42 f.add(ta);
43 myEvent();
44 f.setVisible(true);
45 }
46 public void myEvent()
47 {
48 f.addWindowListener(new WindowAdapter(){
49 public void windowClosing(WindowEvent e)
50 {
51 System.exit(0);
52 }
53 });
54 b.addMouseListener(new MouseAdapter(){
55 public void mouseClicked(MouseEvent e)
56 {
57 //String text = tf.getText(); //文本框获取文本内容，这个getText方法属于textField的父类textComponent
58 //ta.setText(text); //文本区域设置文本，这个setText方法也属于textArea的父类textComponent
59 //现在要求在文本框输入一个地址按了Button键之后获取地址中的文件以及文件夹的名字到文本区域
60 String dir = tf.getText();
61 File f = new File(dir);
62 if(f.exists()&&f.isDirectory())
63 {
64 //2013/6/25tf.setText(""); //如果f存在并且是目录则清空文本框
65 ta.setText(""); //在第二次获取时清空原来的文本区域
66 String[] file = f.list();
67 for(String name : file)
68 ta.append(name+"\r\n"); //textArea的方法，不断追加文本
69 }
70
71 }
72 });
73 }
74 }
1 //java基础视频教程第22天-10-GUI(对话框Dialog)
2 /*
3 本节课在上上一节课的基础上添加了一个错误提示对话框,并且但你输入一个错误的地址时，无轮用鼠标点击还是用回车键都可以调出错误提示对话框
4 首先明白对话框也是一个窗体，它有三部分，标题，内容，按钮
5 public Dialog(Dialog owner,String title,boolean modal),Dialog其中一个构造函数，第一个参数表示这个对话框所属于那个窗体，第二个参数表示对话框的名称，第三个boolean参数表示当对话框出现后是否还能够操作对话框所属窗体
6 */
7 import java.awt.*;
8 import java.awt.event.*;
9 import java.io.*;
10 class MyWindowDemo1
11 {
12 public static void main(String[] args)
13 {
14 new Init();
15 }
16 }
17 class Init
18 {
19 //窗体组件变量
20 private Frame f;
21 private Button b;
22 private TextField tf;
23 private TextArea ta;
24 //对话框的组件变量
25 private Dialog d;
26 private Label l;
27 private Button bn;
28 Init()
29 {
30
31 myFrame();
32 }
33 public void myFrame()
34 {
35 f=new Frame("my frame");
36 f.setBounds(500,500,500,500);
37 f.setLayout(new FlowLayout());
38 tf=new TextField(50);
39 f.add(tf);
40 b=new Button("button");
41 f.add(b);
42 ta=new TextArea(25,60);
43 f.add(ta);
44 myDialog();
45 myEvent();
46 f.setVisible(true);
47 }
48 public void myDialog()
49 {
50 d=new Dialog(f,"my dialog",false); //true表示当对话框出现时不能操作所属窗体
51 d.setBounds(500,500,200,200);
52 d.setLayout(new FlowLayout());
53 l=new Label(); //在窗体上的文字其实就是标签(Label)，这里标签没有设置初始化内容
54 d.add(l);
55 bn = new Button("确定");
56 d.add(bn);
57 }
58 public void myEvent()
59 {
60 d.addWindowListener(new WindowAdapter(){
61 public void windowClosing(WindowEvent e)
62 {
63 d.setVisible(false); //当按了对话框上的x就不显示对话框
64 }
65 });
66 bn.addMouseListener(new MouseAdapter(){
67 public void mouseClicked(MouseEvent e)
68 {
69 d.setVisible(false); //但点击对话框中的按钮则不显示对话框
70 }
71 });
72 f.addWindowListener(new WindowAdapter(){
73 public void windowClosing(WindowEvent e) //注意参数
74 {
75 System.exit(0);
76 }
77 });
78 b.addMouseListener(new MouseAdapter(){
79 public void mouseClicked(MouseEvent e)
80 {
81 myDir();
82 }
83 });
84 tf.addKeyListener(new KeyAdapter(){ //当按回车键时就相当于点击按钮
85 public void keyPressed(KeyEvent e)
86 {
87 if(e.getKeyCode()==KeyEvent.VK_ENTER)
88 myDir();
89
90 }
91 });
92
93 }
94 public void myDir() //把地址单独分离出来
95 {
96 String dir = tf.getText();
97 File f = new File(dir);
98 if(f.exists()&&f.isDirectory())
99 {
100 ta.setText("");
101 String[] file = f.list();
102 for(String name : file)
103 ta.append(name+"\r\n");
104 }
105 else
106 {
107 l.setText("你输入的："+dir+"不存在或者不是目录"); //注意这句话一点要放在setVisible的前面
108 d.setVisible(true); //当输入的dir不是目录或者不存在则显示对话框
109
110 }
111 }
112 }
1 //java基础视频教程第22天-11-GUI（菜单）
2 /*
3 本节课主要学习了菜单栏（MenuBar）,菜单（Menu），菜单项（MenuItem）
4 这节课主要分清楚这三个的关系就好办事
5 public void setMenuBar(MenuBar mb),将此窗体的菜单栏设置为指定的菜单栏，注意窗体是没有add（菜单栏）这个方法的
6 public MenuItem add(MenuItem mi),这个是Menu的添加属性，参数是它的父类，就是说它可以添加菜单，形成层层嵌套
7 */
8 import java.awt.*;
9 import java.awt.event.*;
10 class MemuDemo
11 {
12 public static void main(String[] args)
13 {
14 new MyMenu();
15 }
16 }
17 class MyMenu
18 {
19 private Frame f;
20 private MenuBar mb;
21 private Menu m1,m2;
22 private MenuItem mi1,mi2;
23 MyMenu()
24 {
25 myFrame();
26 }
27 public void myFrame()
28 {
29 f=new Frame("Frame");
30 f.setBounds(500,500,500,500);
31 f.setLayout(new FlowLayout());
32 mb = new MenuBar();
33 f.setMenuBar(mb);
34 m1 = new Menu("(menu)文件"); //参数为菜单的名字
35 mb.add(m1); //将菜单添加到菜单栏中
36 m2 = new Menu("(menu)子目录");
37 m1.add(m2); //将子目录添加到菜单上
38 mi1 = new MenuItem("(menuItem)退出");
39 m1.add(mi1); //将目录项添加到菜单上
40 mi2 = new MenuItem("(menuItem)子目录项");
41 m2.add(mi2); //在子目录上添加一个子目录项
42 myEvent();
43 f.setVisible(true);
44 }
45 public void myEvent()
46 {
47 f.addWindowListener(new WindowAdapter(){
48 public void windowClosing(WindowEvent e)
49 {
50 System.exit(0);
51 }
52 });
53 mi1.addActionListener(new ActionListener(){ //当按菜单项退出时，就结束
54 public void actionPerformed(ActionEvent e)
55 {
56 System.exit(0);
57 }
58 });
59 }
60 }
1 //java基础视频教程第22天-12-GUI（练习-打开文件）
2 /*
3 本节课主要讲解了打开文本对话框
4 主要的就是文件对话框
5 public FileDialog(Frame parent,String title,int mode)，第一个参数表示属于哪个窗体，第二个参数表示这个文件对话框的名称，
6 第三个参数表示模式，模式有两种：FileDialog.LOAD表示打来，FileDialog.SAVE表示保存
7 FileDialog里面获取地址的方法public String getDirectory(),
8 FileDialog里面获取文件名的方法public String getFile()
9 */
10 import java.awt.*;
11 import java.awt.event.*;
12 import java.io.*;
13 class MyMenuDemo
14 {
15 public static void main(String[] args)
16 {
17 new Init();
18 }
19 }
20 class Init
21 {
22 private Frame f;
23 private MenuBar fileBar;
24 private Menu fileMenu;
25 private MenuItem openItem,saveItem,closeItem;
26 private TextArea ta;
27 private FileDialog fdg;
28 Init()
29 {
30 myFrame();
31 }
32 public void myFrame()
33 {
34 f=new Frame("my frame");
35 f.setBounds(500,500,500,500);
36 fileBar = new MenuBar(); //创建菜单栏
37 fileMenu = new Menu("文件"); //创建菜单
38 f.setMenuBar(fileBar); //设置fileBar为窗体的菜单
39 fileBar.add(fileMenu); //将菜单添加到菜单栏上
40 openItem = new MenuItem("打开");
41 saveItem = new MenuItem("保存");
42 closeItem = new MenuItem("关闭");
43 fileMenu.add(openItem);
44 fileMenu.add(saveItem);
45 fileMenu.add(closeItem);
46 ta = new TextArea(); //这里没有设置文本区域的大小，也没有设置窗体的布局，所以窗体布局为默认的边界布局，文本区域会占据所有的窗体
47 f.add(ta);
48 fdg = new FileDialog(f,"打开文件",FileDialog.LOAD); //表示这个打开文件对话框属于f窗体，名称为打开文件
49 myEvent();
50 f.setVisible(true);
51
52 }
53 public void myEvent()
54 {
55 f.addWindowListener(new WindowAdapter(){
56 public void windowClosing(WindowEvent e)
57 {
58 System.exit(0);
59 }
60 });
61 openItem.addActionListener(new ActionListener(){
62 public void actionPerformed(ActionEvent e)
63 {
64 fdg.setVisible(true);
65
66 File file = new File(fdg.getDirectory(),fdg.getFile());
67 if(!(file.exists()||file.isDirectory()))
68 {
69 return;
70 }
71 ta.setText("");
72 /* //代替
73 String dirPath = fdg.getDirectory();
74 String fileName = fdg.getFile();
75 if(dirPath==null || fileName==null) //防止没点选的情况下出现空指针情况，当你没有点选文件直接就点击取消，则文件名字就不会存在，File里面就会报空指针异常
76 return;
77 ta.setText("");
78 File file = new File(dirPath,fileName);
79 */
80 try
81 {
82 BufferedReader br = new BufferedReader(new FileReader(file));
83 String line =null;
84 while((line=br.readLine())!=null)
85 {
86 ta.append(line+"\r\n");
87 }
88 br.close();
89 }
90 catch (IOException ex)
91 {
92 throw new RuntimeException("读取失败");
93 }
94 }
95 });
96 }
97 }
1 //java基础视频教程第22天-13-GUI（练习-保存文件）
2 /*
3 这节课在上节课的基础上添加一个功能保存功能
4 */
5 import java.awt.*;
6 import java.awt.event.*;
7 import java.io.*;
8 class MyMenuDemo1
9 {
10 public static void main(String[] args)
11 {
12 new Init();
13 }
14
15 }
16 class Init
17 {
18 private Frame frame;
19 private MenuBar frameBar;
20 private Menu frameMenu;
21 private MenuItem openItem,saveItem,closeItem;
22 private TextArea textArea;
23 private FileDialog openDialog,saveDialog;
24 private File file;
25
26 Init()
27 {
28 myFrame();
29 }
30 public void myFrame()
31 {
32 frame = new Frame("记事本");
33 frame.setBounds(500,500,500,500);
34 frameBar = new MenuBar();
35 frameMenu = new Menu("文件");
36 openItem = new MenuItem("打开");
37 saveItem = new MenuItem("保存");
38 closeItem = new MenuItem("关闭");
39 openDialog = new FileDialog(frame,"打开文件",FileDialog.LOAD);
40 saveDialog = new FileDialog(frame,"保存文件",FileDialog.SAVE);
41 textArea = new TextArea();
42
43 frame.setMenuBar(frameBar);
44 frameBar.add(frameMenu);
45 frameMenu.add(openItem);
46 frameMenu.add(saveItem);
47 frameMenu.add(closeItem);
48 frame.add(textArea);
49
50 myEvent();
51 frame.setVisible(true);
52 }
53 public void myEvent()
54 {
55 frame.addWindowListener(new WindowAdapter(){
56 public void windowClosing(WindowEvent e)
57 {
58 System.exit(0);
59 }
60 });
61 closeItem.addActionListener(new ActionListener(){
62 public void actionPerformed(ActionEvent e)
63 {
64 System.exit(0);
65 }
66 });
67 openItem.addActionListener(new ActionListener(){ //打开文件
68 public void actionPerformed(ActionEvent e)
69 {
70 openDialog.setVisible(true);
71 String dir = openDialog.getDirectory();
72 String name = openDialog.getFile();
73 //System.out.println(dir+name);
74 if(name==null || dir==null)
75 return;
76 file= new File(dir,name);
77 try
78 {
79 BufferedReader br = new BufferedReader(new FileReader(file));
80 String text = null;
81 while((text=br.readLine())!=null)
82 {
83 textArea.append(text+"\r\n");
84 }
85 }
86 catch (IOException ex)
87 {
88 throw new RuntimeException();
89 }
90 }
91 });
92 saveItem.addActionListener(new ActionListener(){ //保存文件
93 public void actionPerformed(ActionEvent e)
94 {
95 if(file==null)
96 {
97 saveDialog.setVisible(true);
98 String dir = saveDialog.getDirectory();
99 String name = saveDialog.getFile();
100 if(name==null || dir==null)
101 return;
102 file = new File(dir,name);
103 }
104 try
105 {
106 BufferedWriter bw = new BufferedWriter(new FileWriter(file));
107 String text = textArea.getText();
108 bw.write(text);
109 bw.close();
110 }
111 catch (IOException ex)
112 {
113 throw new RuntimeException();
114 }
115 }
116 });
117 }
118
119 }
1 //java基础视频教程第22天-14-GUI（双击执行jar）
2 /*
3 本节课主要是打包,命令为：
4 javac -d 保存地址 编译的java文件 //打包命令
5 jar -cvfm note.jar list.txt mynote //做成一个jar文件
6
7 */
8 package mynote;
9 import java.awt.*;
10 import java.awt.event.*;
11 import java.io.*;
12 public class MyMenuTest
13 {
14 public static void main(String[] args)
15 {
16 new Init();
17 }
18
19 }
20 class Init
21 {
22 private Frame frame;
23 private MenuBar frameBar;
24 private Menu frameMenu;
25 private MenuItem openItem,saveItem,closeItem;
26 private TextArea textArea;
27 private FileDialog openDialog,saveDialog;
28 private File file;
29
30 Init()
31 {
32 myFrame();
33 }
34 public void myFrame()
35 {
36 frame = new Frame("记事本");
37 frame.setBounds(500,500,500,500);
38 frameBar = new MenuBar();
39 frameMenu = new Menu("文件");
40 openItem = new MenuItem("打开");
41 saveItem = new MenuItem("保存");
42 closeItem = new MenuItem("关闭");
43 openDialog = new FileDialog(frame,"打开文件",FileDialog.LOAD);
44 saveDialog = new FileDialog(frame,"保存文件",FileDialog.SAVE);
45 textArea = new TextArea();
46
47 frame.setMenuBar(frameBar);
48 frameBar.add(frameMenu);
49 frameMenu.add(openItem);
50 frameMenu.add(saveItem);
51 frameMenu.add(closeItem);
52 frame.add(textArea);
53
54 myEvent();
55 frame.setVisible(true);
56 }
57 public void myEvent()
58 {
59 frame.addWindowListener(new WindowAdapter(){
60 public void windowClosing(WindowEvent e)
61 {
62 System.exit(0);
63 }
64 });
65 closeItem.addActionListener(new ActionListener(){
66 public void actionPerformed(ActionEvent e)
67 {
68 System.exit(0);
69 }
70 });
71 openItem.addActionListener(new ActionListener(){ //打开文件
72 public void actionPerformed(ActionEvent e)
73 {
74 openDialog.setVisible(true);
75 String dir = openDialog.getDirectory();
76 String name = openDialog.getFile();
77 //System.out.println(dir+name);
78 if(name==null || dir==null)
79 return;
80 file= new File(dir,name);
81 try
82 {
83 BufferedReader br = new BufferedReader(new FileReader(file));
84 String text = null;
85 while((text=br.readLine())!=null)
86 {
87 textArea.append(text+"\r\n");
88 }
89 }
90 catch (IOException ex)
91 {
92 throw new RuntimeException();
93 }
94 }
95 });
96 saveItem.addActionListener(new ActionListener(){ //保存文件
97 public void actionPerformed(ActionEvent e)
98 {
99 if(file==null)
100 {
101 saveDialog.setVisible(true);
102 String dir = saveDialog.getDirectory();
103 String name = saveDialog.getFile();
104 if(name==null || dir==null)
105 return;
106 file = new File(dir,name);
107 }
108 try
109 {
110 BufferedWriter bw = new BufferedWriter(new FileWriter(file));
111 String text = textArea.getText();
112 bw.write(text);
113 bw.close();
114 }
115 catch (IOException ex)
116 {
117 throw new RuntimeException();
118 }
119 }
120 });
121 }
122
123 }
浙公网安备 33010602011771号