------- android培训、java培训、期待与您交流！----------
导读：GUI—概述，布局，Frame、事件监听机制、窗体事件，Action事件，鼠标事件、键盘事件，练习-列出指定目录内容、对话框Dialog，菜单，练习—打开文件、保存文件，jar包双击执行
1、GUI（概述）
- 操作系统有两种和用户交互的方式，一种是命令行的方式，一种是图形化的用户界面的方式。
- GUI（图形用户界面）
Graphical User Interface(图形用户接口)。
用图形的方式，来显示计算机操作的界面，这样更方便更直观。
- CLI
Command line User Interface (命令行用户接口）
就是常见的Dos命令行操作。
需要记忆一些常用的命令，操作不直观。
- Java为GUI提供的对象都存在java.Awt和javax.Swing两个包中。
- Awt与 Swing的区别
Ø java.Awt：AbstractWindow ToolKit (抽象窗口工具包，具体的方法都在不同的类中)，需要调用本地系统方法实现功能（有点依赖于平台，它的跨平台性不是特别的好，windows的界面拿到Linux下，虽然大致一样，但是有一些细微的差别，如颜色、字体、大小上会有一些不一样）。属重量级控件（对系统的依赖性相对要强一些，它的实现都是调用系统里面的实现方式）。
Ø javax.Swing：（为了进行彻底的跨平台，java对图形化的界面进行了一次升级，javax.Swing完全基于AWT,有些类直接继承了AWT并复写了其中的很多的方法，建立了自己的样式，大小，字体，色彩等，用它开发完的组件，在任何系统下都是一模一样。）在AWT的基础上，建立的一套图形界面系统，其中提供了更多的组件，而且完全由Java实现。增强了移植性，属轻量级控件。（基于Swing之后又有了n多个组件，比AWT的组件多很多,不断升级的是Swing）
Ø eclipse中由java独立编写的，但是它的图形化的界面即不是基于AWT，也不是基于Swing，它有的是SWT界面，这个外观包也是基于AWT的，它是eclipse图形化的小组独立编写的一个外观包。（去eclipse的官网上可以直接下载到这个个外观包）
- 继承关系图：
Container：为容器，是一个特殊的组件，该组件中可以通过add方法添加其他组件进来。
Panel（面板，不能单独存在。）
2、GUI（布局）
- 我们做一个窗体，窗体里面有很多的组件，文本框，按钮，文本区域，单复选框，都要往里放，放的时候涉及到一个问题，这些方式要按照什么样的方式排放，java中就提供了一些组件的排放方式。
- 布局管理器：
容器中的组件的排放方式，就是布局。
- 常见的布局管理器：
Ø FlowLayout（流式布局管理器，默认的方式都是居中的，也可以设置居左，居右）从左到右的顺序排列。Panel默认的布局管理器。
Ø BorderLayout（边界布局管理器）东，南，西，北，中，Frame默认的布局管理器。（如果没有指定是在东西南北的哪个方向，它会以最大的面积填充窗体，如果此时再添加新的窗体它会覆盖）
Ø GridLayout（网格布局管理器）规则的矩阵，每一个组件都放在了格子当中。如，计算器
Ø CardLayout（卡片布局管理器）选项卡。在桌面上右键，属性这些都是卡片式的布局。
Ø GridBagLayout（网格包布局管理器）非规则的矩阵，一个组件会占用多个格子。
- 在做图形化界面之前，最痛苦的也在这，做图形化界面之前要先打一个草稿，把图形化界面先用纸先画一下，否则做出来的东西，虽然功能实现了，但是奇丑无比。功能实现对于程序员来说，易如反掌，就是做图形化的界面，丑就一个字。最叼的布局是组件想放在哪里，就放在哪里，这叫做坐标式的布局。所以开发图形化界面的时候还是要找一些高级的编辑器。比如，JBuilder，eclipse+图形化的插件。（有一个画布，想要什么组件，直接往这里面拖就行了。一切换到代码，代码全生成。
- 如果一个窗体要用到多个布局，那就要先对这个窗体进行大区块的划分，先设置一下窗体的布局，这个时候加入进来的不是组件，而是panal(面板)，在面板中再去设置你想要的布局。
3、GUI（Frame、事件监听机制、窗体事件）
- java.awt中的类Component，public abstract class Component，component 是一个具有图形表示能力的对象，可在屏幕上显示，并可与用户进行交互。典型图形用户界面中的按钮、复选框和滚动条都是组件示例。
- 方法太多了，谁开发这个，都要到这里面现找去。
- public class Container extends Component，它是一个可包含其他 AWT 组件的组件。
Component add(Component comp)：将指定组件追加到此容器的尾部。
Component add(Component comp, int index)：将指定组件添加到此容器的给定位置上。
Container它能添加的组件主要都是对象，它能把组件都添加到窗体中，说明它内部是一个集合。它把组件对象，都添加到了集合当中。
- Frame()：构造一个最初不可见的Frame 新实例（）。
void setVisible(boolean b)：根据参数 b 的值显示或隐藏此组件。（父类Component中的方法）
- 图形化界面是有另外的线程来控制的。只要开启图形化界面就会多一个线程。
- 创建图形化界面：
1，创建frame窗体。
2，对窗体进行基本设置。比如大小，位置，布局。
3，定义组件。
4，将组件通过窗体的add方法添加到窗体中。
5，让窗体显示，通过setVisible(true)
- 事件监听机制的特点：
1，事件源（组件）。
2，事件（Event）。
3，监听器(Listener)。
4，事件处理(引发事件后处理方式)。
事件源：就是awt包或者swing包中的那些图形界面组件。
事件：每一个事件源都有自己特有的对应事件和共性事件。（鼠标，键盘事件，很多类都具备）
监听器：将可以触发某一个事件的动作（不只一个动作）都已经封装到了监听器中。
以上三者，在java中都已经定义好了。直接获取其对象来用就可以了。（在开发中，这三者是不需要写的，完全通过它的图形化界面，画布点点拖拖就全都产生了。）
我们要做的事情是，就是对产生的动作进行处理（处理方式，处理方式由程序员自己定义）。
- 开密码锁，为了安全，密码锁上安装了报警装置，只要锁被砸就会把锁事件通知保安。那么保安就有相应的处理方式。如果锁没有被砸，而是密码输入错误，那么报警装置也会将锁事件通知保安，保安也会处理方式。那么锁就是事件源，报警装置就是监听器，可以用来监听引发事件的动作。但必须要注册到锁上，否则锁被砸保安是不知道的。
- 事件监听机制流程图：
- void addWindowListener(WindowListener l)：（window中的方法）添加指定的窗口侦听器，以从此窗口接收窗口事件。（凡是监听器，它的结尾处都是Listener，都是用来注册到别人身上的东西，而且监听器里面注册的都是动作。）接口WindowListener是一个接口，它中有七个方法。我需要将七个方法都覆盖掉，才能实例化这个对象。那么有没有可以实例化的子类呢？可以找它的子类WindowAdapter，可是publicabstract class WindowAdapter，也是一个抽象类，它把WindowListener中的方法都覆写了。用于接收窗口事件的抽象适配器类。此类中的方法为空，因此创建对象没有意义，所以在前面加一个abstract，不让你创建对象（这就是抽象类中一个抽象方法都没有）。此类存在的目的是方便创建侦听器对象。
- java.awt.event中的接口WindowListener:
void windowActivated(WindowEvent e)：窗口前置
void windowClosed(WindowEvent e)：
void windowClosing(WindowEvent e)：窗口关闭
void windowDeactivated(WindowEvent e)：窗口后置
void windowDeiconified(WindowEvent e)：窗口最大化
void windowIconified(WindowEvent e)：窗口最小化
void windowOpened(WindowEvent e)：窗口打开
- 事件监听机制
Ø 确定事件源（容器或组件）
Ø通过事件源对象的addXXXListener()方法将侦听器注册到该事件源上。
Ø 该方法中接收XXXListener的子类对象，或者XXXListener的子类XXXAdapter的子类对象。
Ø 一般用匿名内部类来表示。
Ø 在覆盖方法的时候，方法的参数一般是XXXEvent类型的变量接收。
Ø 事件触发后会把事件打包成对象传递给该变量。（其中包括事件源对象。通过getSource()或者，getComponent()获取。）
- import java.awt.*; //玩图形化界面要导入的包。
import java.awt.event.*;
class AwtDemo
{
publicstatic void main(String[] args)
{
Framef = new Frame("my awt");
//它有一个默认的布局管理器，叫做边界式布局。
f.setSize(500,400); //500走的是横坐标，400走的是纵坐标。（规律，传坐标的时候，第一个参数传的是横的坐标，第二个参数传的是纵的坐标）
f.setLocation(300,200); //每次出来的时候，不是在左上角。
f.setLayout(newFlowLayout()); 设置布局的方式。
Buttonb = new Button("我是一个按钮");
f.add(b);
//出来的窗体可以最小化，也可以最大化，但是没有关的动作。
f.addWindowListener(newWindowAdapter() //这里的WindowListener可能写成一个内部类。
{
publicvoid windowClosing(WindowEvent e) //一引发动作就直接把对象传给了e
{
System.out.println("我关");
System.exit(0);
}
publicvoid windowActivated(WindowEvent e)
{
System.out.println("我活了。");
}
publicvoid windowOpened(WindowEvent e)
{
System.out.println("我被打开了,hahahhahah");
}
});
f.setVisible(true);
//System.out.println("HelloWorld!");
}
}
/*
class MyWin implements WindowListener
{
//覆盖7个方法。可以我只用到了关闭的动作。
//其他动作都没有用到，可是却必须复写。
}
//因为WindowListener的子类WindowAdapter已经实现了WindowListener接口。并覆盖了其中的所有方法。那么我只要继承自Windowadapter覆盖我需要的方法即可。
class MyWin extends WindowAdapter //有了接口WindowListener的子类对象的子类Mywin，后，可以将Mywin传进去就可以了。
{
publicvoid windowClosing(WindowEvent e)
{
//System.out.println("windowclosing---"+e.toString());
System.exit(0);
}
}
*/
4、GUI（Action事件）
import java.awt.*;
import java.awt.event.*;
class FrameDemo
{
//定义该图形中所需的组件的引用。
privateFrame f; //在这里建立引用，这个引用可以作用于整个类。
privateButton but;
FrameDemo()
{
init(); //在构造函数中调用一下init()函数，一初始化，就有了图形化界面，并具备了一些基本事件。
}
publicvoid init() //对于图形化界面进行初始化动作。这里面不要加事件，要将事件和图形化界面分离出来。
{
f= new Frame("my frame");
//对frame进行基本设置。
f.setBounds(300,100,600,500); //写两个方法来设置可以，写一个方法来统一来设置也没有问题。setBounds(int x, int y, int width, intheight)
f.setLayout(new FlowLayout());
but= new Button("my button");
//将组件添加到frame中
f.add(but);
//加载一下窗体上事件。
myEvent();
//显示窗体;
f.setVisible(true);
}
privatevoid myEvent() //把事件都写到这里面来。
{
f.addWindowListener(newWindowAdapter()
{
publicvoid windowClosing(WindowEvent e)
{
System.exit(0);
}
});
//让按钮具备退出程序的功能
/*
按钮就是事件源。
那么选择哪个监听器呢？
通过关闭窗体示例了解到，想要知道哪个组件具备什么样的特有监听器。
需要查看该组件对象的功能。
通过查阅button的描述。发现按钮支持一个特有监听addActionListener。
*/
but.addActionListener(newActionListener() //添加一个活动监听器
{
privateint count = 1;
publicvoid actionPerformed(ActionEvent e) //因为添加的是活动监听，所以返回的是活动事件。（添加什么监听，返回什么事件）
{
//System.out.println("退出，按钮干的");
//System.exit(0);
//f.add(newButton("Button-"+(count++)));
//f.setVisible(true);
//f.validate();
//System.out.println(e.getSource());
Buttonb = (Button)e.getSource();
Framef1 = (Frame)b.getParent();
f1.add(newButton("button-"+count++));
f1.validate();
}
});
}
publicstatic void main(String[] args)
{
newFrameDemo();
}
}
- 适配器的出现目的只有一个，就是方便创建监听器对象（窗口监听器中有多个方法，而我只用其中的一个，我覆盖所有的很麻烦，所以它给我提供了一个已有的子类。），ActionListener中只的一个方法，不需要适配器了（它是少数没有适配器中的一个，无适配器的只有三个）。几乎是Listener的都有适配器，凡是方法超过三个的，它们都有Adapter。
5、GUI(鼠标事件、键盘事件)
- 共性的事件：鼠标，键盘事件。鼠标和键盘事件，几乎所有的事件都具备，找Component
- void addKeyListener(KeyListener l)
- void addMouseListener(MouseListener l)
- MouseListener中的方法：
Ø void mouseClicked(MouseEvent e)：鼠标按键在组件上单击（按下并释放）时调用。
Ø void mouseEntered(MouseEvent e)：鼠标进入到组件上时调用。
Ø void mouseExited(MouseEvent e)：鼠标离开组件时调用。
Ø void mousePressed(MouseEvent e)：鼠标按键在组件上按下时调用。
Ø void mouseReleased(MouseEvent e)：鼠标按钮在组件上释放时调用。
- 按钮只要被活动，它就能执行。而鼠标键盘都能让键盘活动。所以按钮上加事件的时候，可以的话，尽量加ActionEvent，如果加mouseClicked()的话，Click会先执行。因为鼠标事件会比活动事件更具体一些。
- 当鼠标事件产生的时候，我是不是可能以获取到鼠标的按键，或者被点击之后，鼠标的点击次数是不是可以获取到。这些都是鼠标事件内的东西。只有鼠标事件产生之后，它才会产生这样的信息。MouseEvent中的方法：intgetClickCount()：返回与此事件关联的鼠标单击次数。
- java.awt.event中的接口KeyListener，方法：
void keyPressed(KeyEvent e)：按下某个键时调用此方法。
void keyReleased(KeyEvent e)：释放某个键时调用此方法。
void keyTyped(KeyEvent e)：键入某个键时调用此方法。
- KeyEvent：为了方便使用，把键盘上的键，都变成了常量，封装成了字段。
char getKeyChar()：返回与此事件中的键关联的字符。
int getKeyCode()：返回与此事件中的键关联的整数 keyCode。
static String getKeyText(int keyCode)：返回描述 keyCode 的 String，如 "HOME"、"F1"
- java.io.event.InputEvent中的方法：
void consume()：如果是一个文本框的话，当按下的时候字母会出现在文本框中，为了不让他进入到文本框中，可以用这个方法。
- import java.awt.*;
import java.awt.event.*;
class MouseAndKeyEvent
{
privateFrame f;
privateButton but;
privateTextField tf;
MouseAndKeyEvent()
{
init();
}
publicvoid init()
{
f= new Frame("my frame");
f.setBounds(300,100,600,500);
f.setLayout(newFlowLayout());
tf= new TextField(20); //这里指定的是文本框的列数。
but= new Button("my button");
f.add(tf);
f.add(but);
myEvent();
f.setVisible(true);
}
privatevoid myEvent()
{
f.addWindowListener(newWindowAdapter()
{
publicvoid windowClosing(WindowEvent e)
{
System.exit(0);
}
});
tf.addKeyListener(newKeyAdapter()
{
publicvoid keyPressed(KeyEvent e)
{
intcode = e.getKeyCode();
if(!(code>=KeyEvent.VK_0&& code<=KeyEvent.VK_9))
{
System.out.println(code+".....是非法的");
e.consume(); //按下键一判断不符合条件，把事件给取消掉。屏障键，无论是在网页上，还是应用程序上都很常见。
}
}
});
//给But添加一个键盘监听。
but.addKeyListener(newKeyAdapter()
{
publicvoid keyPressed(KeyEvent e)
{
if(e.isControlDown()&&e.getKeyCode()==KeyEvent.VK_ENTER)
//System.exit(0); //当按回车的时候结束，如果用组合键的时候，isControlDown()是KeyListener的父类java.io.event.InputEvent中的方法，可在用它来实现和Ctrl键的组合，它用来判断Ctrl键是否被按下。
System.out.println("ctrl+enteris run");
//System.out.println(KeyEvent.getKeyText(e.getKeyCode())+"...."+e.getKeyCode());
}
});
/*
but.addActionListener(newActionListener()
{
publicvoid actionPerformed(ActionEvent e)
{
System.out.println("actionok");
}
});
*/
/*
but.addMouseListener(newMouseAdapter() //鼠标监听先。按钮监听后。
{
privateint count = 1;
privateint clickCount = 1;
publicvoid mouseEntered(MouseEvent e)
{
System.out.println("鼠标进入到该组件"+count++);
}
publicvoid mouseClicked(MouseEvent e)
{
if(e.getClickCount()==2) //双击动作的表示方式。
System.out.println("双击动作"+clickCount++);
}
});
*/
}
publicstatic void main(String[] args)
{
newMouseAndKeyEvent();
}
}
- Java.awt.event中除了监听器，就是适配器对象。
- 确定事件源，确定事件，确定监听器，确定要操作谁。
6、GUI(练习-列出指定目录内容、对话框Dialog)
- TextField和TestArea中没有get方法，但是要记着，它有一个爹叫TextComponent，在它中有publicString getText()方法。
- 对话框一般不单独存在，它是在窗体中操作，误操作的时候才出现，是在有事情的时候才蹦出来。它一般要依赖于一个窗体。
- Dialog(Dialog owner)
Dialog(Frame owner , boolean modal)
Dialog(Frame owner, String title)
- import java.awt.*;
import java.awt.event.*;
import java.io.*;
class MyWindowDemo //在这也可以这们写：classMyWindowDemo extends Frame，好处是Frame中的方法，可以直接拿过来用。
{
privateFrame f;
privateTextField tf;
privateButton but;
privateTextArea ta;
privateDialog d;
privateLabel lab;
privateButton okBut;
MyWindowDemo()
{
init();
}
publicvoid 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); //25代表行数，70代表列数。
d= new Dialog(f,"提示信息-self",true); //窗体加载完，不该有的对象，不让他先存在。点了半天都没有出现误操作的话，这个对话框没有必要让他在内存中产生。在这里写了，是为了方便阅读程序，按理说是不应该的。如果model为true的话，你不操作对话框的话，它所属的窗体你操作不了。为false的话，可以将对话框仍在一边接着操作。
d.setBounds(400,200,240,150); //对话框也要设置窗口大小和布局。
d.setLayout(newFlowLayout());
lab= new Label(); //组件里面不能直接写文本，初始化的时候还不知道要写什么信息，所以不定义信息。可以通过setText(String text)往这里面设置信息。
okBut= new Button("确定");
d.add(lab);
d.add(okBut);
f.add(tf); //不要把Dialog加在窗体中，因为窗体一出现，Dialog就出现不合适。
f.add(but);
f.add(ta);
myEvent();
f.setVisible(true);
}
privatevoid myEvent()
{
okBut.addActionListener(newActionListener()
{
publicvoid actionPerformed(ActionEvent e)
{
d.setVisible(false);
}
});
d.addWindowListener(newWindowAdapter()
{
publicvoid windowClosing(WindowEvent e)
{
d.setVisible(false); //一点关闭让对话框不显示。
}
});
tf.addKeyListener(newKeyAdapter() //按下回车也能实现点按钮转到的功能。
{
publicvoid keyPressed(KeyEvent e)
{
if(e.getKeyCode()==KeyEvent.VK_ENTER)
showDir();
}
});
but.addActionListener(newActionListener() //事件源是but,它即操作文本框中的数据，又操作文本区域中的数据
{
publicvoid actionPerformed(ActionEvent e)
{
showDir();
}
});
f.addWindowListener(newWindowAdapter()
{
publicvoid windowClosing(WindowEvent e)
{
System.exit(0);
}
});
}
privatevoid showDir() //将功能函数提取
{
StringdirPath = tf.getText(); //获取TextField中的数据
Filedir = new File(dirPath); //只有封装成一个对象才能用list。要导入java.io.*;包
if(dir.exists()&& dir.isDirectory()) //存在且是目录
{
ta.setText(""); //在按下按钮的时候，先将上一次的目录数据清空。
String[]names = dir.list();
for(Stringname : names)
{
ta.append(name+"\r\n");//追加文本。如果用setText(name+”\r\n’);写进去的名字会被覆盖。
}
}
else
{
Stringinfo = "您输入的信息："+dirPath+"是错误的。请重输";
lab.setText(info); //将信息设置进来。对于话框实际上要随着字自动的变长，要先获取到组件的大小。
d.setVisible(true); //直接蹦出来一个对话框，你不点对话框不让你操作，你如果点了的话，说明你已经知道这个信息了。
}
}
publicstatic void main(String[] args)
{
newMyWindowDemo();
}
}
- 图形化界面仅仅是一种和用户交互的一种方式，你最终操作的具体的细节上还是当年写的代码。
7、GUI(菜单)
- l MenuBar,Menu,MenuItem
先创建菜单条，再创建菜单，每一个菜单中建立菜单项。
- java.awt中的类MenuBar，MenuBar 类封装绑定到框架的菜单栏的平台概念。为了将该菜单栏与 Frame 对象关联，可以调用该框架的setMenuBar 方法。
- 方法：
Ø Menu add(Menu m)：将指定的菜单添加到菜单栏。
java.awt中的类Menu，它中有方法MenuItem add(MenuItem mi)，将指定的菜单项添加到此菜单。（Menu本身是MenuItem中的一员，子类）。菜单中可以添加菜单条，菜单中还可以添加菜单（子菜单）。
- Menu extends MenuItem
Menu add(MenuItem) //Menu可以添加MenuItem，若再加上上面的那句话，则还可以添加Menu.
- 菜单继承体系
- import java.awt.*;
import java.awt.event.*;
class MyMenuDemo
{
privateFrame f;
privateMenuBar mb;
privateMenu m,subMenu;
privateMenuItem closeItem,subItem;
MyMenuDemo()
{
init();
}
publicvoid 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("子条目");
closeItem= new MenuItem("退出");
subMenu.add(subItem);//如果没有这句话，没有子条目，但是菜单上还是会显示“小黑三角”，不要三角的话，要把它new成Item.
m.add(subMenu); //菜单栏中可以添加菜单
m.add(closeItem);
mb.add(m);
f.setMenuBar(mb); //将MenuBar设进窗口中
myEvent();
f.setVisible(true);
}
privatevoid myEvent()
{
closeItem.addActionListener(newActionListener()
{
publicvoid actionPerformed(ActionEvent e)
{
System.exit(0);
}
});
f.addWindowListener(newWindowAdapter()
{
publicvoid windowClosing(WindowEvent e)
{
System.exit(0);
}
});
}
publicstatic void main(String[] args)
{
newMyMenuDemo();
}
}
8、GUI（练习—打开文件、保存文件）
- Dialog的直接子类：FileDialog，FileDialog 类显示一个对话框窗口，用户可以从中选择文件。
Ø FileDialog(Frame parent, String title)：创建一个具有指定标题的文件对话框窗口，用于加载文件。Ø FileDialog(Frame parent, String title, intmode)：创建一个具有指定标题的文件对话框窗口，用于加载或保存文件。
parent - 对话框的所有者
title - 对话框的标题
mode - 对话框的模式，可以是FileDialog.LOAD 或 FileDialog.SAVE（怎么区分打开，保存，就这两个属性完成的。不指定模式的话，默认就是打开。）
- FieldDialog中的方法：
Ø String getDirectory()：获取此文件对话框的目录。
Ø String getFile()：获取此文件对话框的选定文件。
- 保存的时候，对话框弹不弹出来，看的是文件存不存在，另存为的话，都要弹出来。
- package mymenu;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
public class MyMenuTest
{
privateFrame f;
privateMenuBar bar;
privateTextArea ta;
privateMenu fileMenu;
privateMenuItem openItem,saveItem,closeItem;
privateFileDialog openDia,saveDia;
privateFile file;
MyMenuTest()
{
init();
}
publicvoid 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);
}
privatevoid myEvent()
{
saveItem.addActionListener(newActionListener()
{
publicvoid actionPerformed(ActionEvent e)
{
if(file==null)
{
saveDia.setVisible(true);
StringdirPath = saveDia.getDirectory();
StringfileName = saveDia.getFile();
//下面这句话的作用是保证点取消按钮的时候，不会出现空指针异常。
if(dirPath==null|| fileName==null) return;
file= new File(dirPath,fileName); //将目录和文件封装成一个文件
}
try
{
BufferedWriterbufw = new BufferedWriter(newFileWriter(file));
Stringtext = ta.getText();
bufw.write(text);
//bufw.flush();
bufw.close();
}
catch(IOException ex)
{
thrownew RuntimeException();
}
}
});
openItem.addActionListener(newActionListener()
{
publicvoid actionPerformed(ActionEvent e)
{
openDia.setVisible(true);
StringdirPath = openDia.getDirectory();
StringfileName = openDia.getFile();
// System.out.println(dirPath+"..."+fileName);
if(dirPath==null|| fileName==null)
return;
ta.setText(""); //当选择的是有效的文件的时候，先将数据清空。
file= new File(dirPath,fileName);
try
{
BufferedReaderbufr = new BufferedReader(new FileReader(file));
Stringline = null;
while((line=bufr.readLine())!=null)
{
ta.append(line+"\r\n");
}
bufr.close();
}
catch(IOException ex)
{
thrownew RuntimeException("读取失败");
}
}
});
closeItem.addActionListener(newActionListener()
{
publicvoid actionPerformed(ActionEvent e)
{
System.exit(0);
}
});
f.addWindowListener(newWindowAdapter()
{
publicvoid windowClosing(WindowEvent e)
{
System.exit(0);
}
});
}
publicstatic void main(String[] args)
{
newMyMenuTest();
}
}
9、jar包双击执行
- 如何制作可以双击执行的jar包呢？
1，将多个类封装到了一个包(package)中。
2，定义一个jar包的配置信息。
定义一个文件a.txt 。文件内容内容为：Main-Class:(空格)包名.类名(回车)
（IO流会读a.txt中的头字段，必须要加上一个空格，固定的格式。如果没有回车的话，不能将a.txt中的内容写到jar文件的配置文件中去，它认为a.txt文件还没有结束）
3，打jar包。
jar-cvfm my.jar a.txt 包名
4，通过winrar程序进行验证，查看该jar的配置文件中是否有自定义的配置信息。
5，通过工具--文件夹选项--文件类型--jar类型文件，通过高级，定义该jar类型文件的打开动作的关联程序。（新建一个jar类型的文件，选择好一个图标，点高级，新建一个open操作，编辑的open操作所用到的应用程序内容如下：）
jdk\bin\javaw.exe–jar（后面跟的有一个参数-jar）
6，双击试试！。哦了。
- jar文件必须在本地注册过才能用。如果JDK是双击安装版的，而不是直接拷贝过去用的，就会自动注册jar的文件类型。
- Jar包中的多个class类，凭什么非要执行某一个。n个类中只有一个是带有主函数的类，要把这个主函数的类，告诉这个jar包。告诉jar包之后，一双击就自动找你说的那一个类去执行。可是怎样把带有主函数的类名告诉jar包呢？每一个jar包都有一个配置文件。
- javaw专门用来执行图形化界面的工具。如果只是一个输出语句的话，不可以，因为没有控制台。
------- android培训、java培训、期待与您交流！----------
364
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
