GUI框架



----------------------------------------------------------------------
人机交互的方式

1.图形用户界面
2.命令行

Java中的GUI对象,都存放在2个包及其子包中:
1.java.Awt   (Abstract Window Tool Kit)
平台依赖性,跨平台性不太好,显示效果会有差异.
Awt的实现原理,实际上还是调用的操作系统底层的实现.
2.javax.Swing
完全基于Awt,所以Swing本身还是离不开Awt.
完全建立自己的样式大小和字体,所以在任何系统下,显示效果都能一模一样.
Swing提供了更多的组件.
3.Swt外观包
也是完全基于Awt,所以Swt本身也是离不开Awt.
可以在eclipse的官网下载.

Awt与Swing的比较:
1.重量级控件,Awt,与系统依赖性较强.
2.轻量级控件,Swing,与系统依赖性较弱.
3.Swing中的类名,一般都在Awt类名的前面加一个J.

VC,C#,Java的图形化界面编程,原理都差不多.

在Java的GUI框架中,常见的没有抽象方法的抽象类:
1.Component抽象类
2.MenuComponent抽象类
3.InputEvent抽象类
-----------------------------------------------------------
---->Component抽象类
所有的可以在屏幕显示出来的图形元素,抽象类.

Component类中的方法:
setBounds
设置窗体的位置和大小,4个参数.
从屏幕的左上角点,开始算起.
setSize
设置大小.
setLocation
设置位置.
setBackground
设置背景颜色
setVisible
设置是否可见

//Component类中的事件监听机制:
addKeyListener
addMouseListener

---->Container类
容器,可以容纳其它Component的元素,实体类.
1.可以容纳Component元素.
2.可以容纳Container元素.
3.可以容纳Container类的子类元素.

Container类中的方法:
add
添加其它的Component对象,可以加索引.
getLayout
setLayout
获取或设置Container对象的布局管理器.

---->Window类
可以独立显示的顶级窗口,
一般使用Window类的子类对象.

Window类中的方法:
setBounds
设置窗体的位置和大小,4个参数,以像素为单位.
setSize
设置大小.
setVisible
设置是否可见

//Window类中的事件监听机制:
addWindowListener
添加指定的窗口监听器

窗体位置和窗体大小的计算方式:
1.从屏幕的左上角点,开始算起.
2.向右是X轴,向下是Y轴(先横坐标,再纵坐标).

---->Frame类
1.可以独立显示的一般窗口.
2.Frame窗体,默认是不可见的.
3.Frame类的默认的布局管理器,是BorderLayout边界布局.

Frame类中的方法:
setTitle
getTitle
设置和获取标题栏中的文字.
setResizable
设置是否可以调整窗口大小.
setMenuBar
窗体添加菜单栏.

---->Color类

Color类中的静态常量(静态字段):
返回Color类的实例对象.
1.颜色字段全都小写,是比较老的jdk版本.
2.颜色字段全都大写,是从jdk1.4版本开始.

---->Dialog类
叫做对话框.
分为模态和非模态对话框.

---->FileDialog类
文件对话框

---->Panel类
不能作为独立的应用程序窗口显示出来,不能独立存在.
Panel如果想显示出来,必须把自己装在Window里面.

Container元素与其它图形元素的区别:
1.Container类及其子类,可以包含其它的图形元素.
2.非Container类,不能包含其它的Component图形元素.
----------------------------------------------
布局管理器

常见的布局管理器
1.流式布局FlowLayout
Panel默认的布局管理器.
水平居中.

2.边界布局BorderLayout
Frame和Dialog默认的布局管理器.
不指定东西南北,居中填充.
水平居中,垂直居中.

3.网格布局GridLayout
规则的矩阵,每个组件都存放在格子中.

4.卡片布局CardLayout
选项卡

5.网格包布局GridBagLayout
非规则的矩阵,可能会占有多个格子.

带有Java GUI画布的开发工具:
1.JBuilder
2.Eclipse+图形化界面插件
把图形化的组件,往画布上拖,布局代码自动生成.
----------------------------------------------
事件监听机制

事件监听机制的组成:
1.事件源(组件)
2.事件(Event)
3.监听器(Listener)
4.事件处理(引发事件后的处理方式)

1.事件源:
就是Awt包或者Swing包中的那些图形界面组件.
2.事件:
里面至少会封装一个事件源,事件源,都有自己的特有事件和共性事件.
3.监听器:
将触发某一个事件的动作,都封装到了对应的监听器中.
注意:
以上3者,在Java中都已经封装好了,开发者直接使用就可以了.
4.事件处理器,一般都会声明为接口,一般也会有对应的适配器抽象类,开发者可以继承并重写适配器抽象类中的某个方法,以简化不必要的代码.

适配器抽象类的特点:
1.适配器抽象类中的所有方法的实现,全都为空,所以设计为抽象类,抽象类,不能实例化.
2.适配器抽象类,是一个没有抽象方法的抽象类.
3.一般当处理器接口中的方法>2时,将配有对应的适配器抽象类.

没有适配器抽象类的处理器接口有:
1.按钮的事件处理器接口ActionListener,接口中只有1个方法,就没有对应的适配器抽象类.
2.复选框的事件处理器接口ItemListener,接口中只有1个方法,也没有对应的适配器抽象类.
3.滚动条的事件处理器接口AdjustmentListener,接口中只有1个方法,没有对应的适配器抽象类.

事件源+监听器<--处理器
1.被动监听机制
2.观察者设计模式

在使用事件处理器的时候,要导包java.awt.event.*;
------------------------------------------------------------------------
案例:搞一个窗体,并处理关闭事件.
代码:
import java.awt.*;
import java.awt.event.*;

class  AwtDemo
{
 public static void main(String[] args)
 {
  Frame f = new Frame("我的第一个窗口");
  f.setBounds(300,100,500,200);
  f.setBackground(Color.BLUE);
  f.setLocation(500,600);
  f.setSize(600,200);
  Button b = new Button("我是一个按钮");
  f.setLayout(new FlowLayout());
  f.add(b);
  //事件监听机制
  f.addWindowListener(new WindowAdapter()
  {
   public void windowClosing(WindowEvent e)  //关闭事件
   {
    System.out.println("关了...");
    System.exit(0);  //正常退出
   }
   public void windowActivated(WindowEvent e)  //活动事件
   {
    System.out.println("窗口活动");
   }
   public void windowOpened(WindowEvent e)  //打开事件
   {
    System.out.println("窗口打开");
   }
  });
  f.setVisible(true);
  System.out.println("Hello World!");
 }
}
-----------------------------------------------------------------------------
案例:让窗体中的按钮具备关闭程序的功能.
代码:
import java.awt.*;
import java.awt.event.*;

class FrameDemo
{
 //定义图形中所需组件的引用.
 private Frame f;
 private Button but;
 FrameDemo()
 {
  init();
 }
 //为了模拟图形化的画布组件.
 public void init()
 {
  f = new Frame("我的窗口");
  //对Frame进行基本设置.
  f.setBounds(300,100,800,300);
  f.setBackground(Color.yellow);
  f.setLayout(new FlowLayout());
  but = new Button("一个按钮");
  f.add(but);
  handleEvent();
  f.setVisible(true);
 }
 //专门添加处理事件的方法
 private void handleEvent()
 {
  f.addWindowListener(new WindowAdapter()
  {
   public void windowClosing(WindowEvent e)
   {
    System.out.println("关了");
    System.exit(0);
   }
  });
  //注意,按钮的事件处理器接口,没有对应的适配器抽象类,接口中只有1个方法.
  //一般,当处理器接口中的方法>2个时,就会有对应的适配器抽象类.
  but.addActionListener(new ActionListener()
  {
   public void actionPerformed(ActionEvent e)
   {
    System.out.println("又关了");
    System.exit(0);
   }
  });
 }
 public static void main(String[] args)
 {
  new FrameDemo();
  System.out.println("Hello World!");
 }
}
-------------------------------------------------------------------------------------
共性事件,鼠标事件.

---->MouseListener接口:

MouseListener接口中的部分方法:
mousePressed
mouseClicked
mouseReleased
鼠标点击
mouseEntered
鼠标进入
mouseExited
鼠标离开
mouseMoved
鼠标移动
mouseWheelMoved
鼠标滚轮旋转

InputEvent(没的抽象方法的,抽象类)
   |--KeyEvent类
   |--MouseEvent类

---->MouseEvent类:

MouseEvent类中的静态字段(全都大写):
BUTTON1
左键
BUTTON2
中键
BUTTON3
右键

MouseEvent类中的方法:
getLocationOnScreen
getXOnScreen
getYOnScreen
返回事件相对于屏幕的x,y坐标
getPoint
getX
getY
返回事件相对于事件源组件的x,y坐标
getClickCount
得到鼠标单击的次数

-------------------------------------------------------------------
案例:鼠标事件的练习
代码:
import java.awt.*;
import java.awt.event.*;

class  TestMouseEvent
{
 private Frame f;
 private Button but;
 public TestMouseEvent()
 {
  init();
 }
 //为了模拟图形化的画布组件.
 private void init()
 {
  f = new Frame("又是一个窗体");
  f.setBackground(Color.green);
  f.setBounds(300,100,600,200);
  f.setLayout(new FlowLayout());
  but = new Button("又是一个按钮");
  f.add(but);
  handleEvent();
  f.setVisible(true);
 }
 private void handleEvent()
 {
  //关闭窗口事件.
  f.addWindowListener(new WindowAdapter()
  {
   public void windowClosing(WindowEvent e)
   {
    System.out.println("关了");
    System.exit(0);  //正常退出.
   }
  });
  f.addMouseListener(new MouseAdapter()
  {
   public void
  })
  //按钮中的鼠标共性事件.
  but.addMouseListener(new MouseAdapter()
  {
   private int count = 0;
   private int clickCount = 0;
   //鼠标进入事件.
   public void mouseEntered(MouseEvent e)
   {
    System.out.println("鼠标进入" + ++count);
   }
   //鼠标点击事件.
   public void mouseClicked(MouseEvent e)
   { //鼠标单击事件
    if(e.getClickCount() == 1 && e.getButton() == MouseEvent.BUTTON1) 
     System.out.println("单击"+ ++clickCount);
    //鼠标双击事件
    if(e.getClickCount() == 2 && e.getButton() == MouseEvent.BUTTON1) 
     System.out.println("双击"+ ++clickCount);
    //鼠标右击事件
    if(e.getButton() == MouseEvent.BUTTON3) 
     System.out.println("右击");
   }
  });
  //按钮专有的活动事件(按空格键,可以触发活动).
  but.addActionListener(new ActionListener()
  {
   private int count = 0;
   public void actionPerformed(ActionEvent e)
   {
    System.out.println("按钮活动事件"+ ++count);
   }
  });
 }
 public static void main(String[] args)
 {
  new TestMouseEvent();
  System.out.println("Hello World!");
 }
}
----------------------------------------------------------------------
共性事件,键盘事件.

---->KeyListener接口:

KeyListener接口中的方法:
keyPressed
按下键
keyTyped
输入键
keyReleased
释放键

---->KeyEvent类:

KeyEvent类中的静态字段:
这些静态字段,分别对应于键盘上的键,都是int类型的.
格式举例(全都大写):VK_SHIFT,VK_A,VK_B,...

KeyEvent类中的方法:
getKeyChar
键所对应字符
1.缺点只能显示1个字符
2.例如shift,control,将显示为?
getKeyCode
键所对应整数
KeyEvent.getKeyText
返回整数对应键名
1.优点,是可以显示键的完整名称
2.静态方法

当DOS命令行被划住时:
1.命令行的显示将不再被刷新了.
2.命令行被划住时,后台程序正常运行.
3.点右键取消,并显示没显示出来的内容.

InputEvent(没的抽象方法的,抽象类)
   |--KeyEvent类
   |--MouseEvent类

---->InputEvent抽象类:
这个类,可以实现一些特定的功能:
1.可以用来监听组合键.
2.可以用来对输入事件的撤消.

InputEvent抽象类中的方法:
isControlDown
isShiftDown
isAltDown
用来监听组合键.
consume
撤消输入事件.

--------------------------------------------------------------------
案例:键盘事件的练习

TextComponent类
   |--TextField类
   |--TextArea类

---->TextField类:
单行文本框,初始化时可以指定列数,以字符为单位.

TextField类中的方法:
setText
设置单行文本框的内容

代码:
import java.awt.*;
import java.awt.event.*;

class  TestKeyEvent
{
 private Frame f;
 private Button but;
 private TextField tf;
 public TestKeyEvent()
 {
  init();
 }
 //为了模拟图形化的画布组件.
 private void init()
 {
  f = new Frame("又是一个窗体");
  f.setBackground(Color.green);
  f.setBounds(300,100,600,200);
  f.setLayout(new FlowLayout());
  //添加一个单行文本框.
  tf = new TextField(20);
  f.add(tf);
  but = new Button("又是一个按钮");
  f.add(but);
  handleEvent();
  f.setVisible(true);
 }
 private void handleEvent()
 {
  //关闭窗口事件.
  f.addWindowListener(new WindowAdapter()
  {
   public void windowClosing(WindowEvent e)
   {
    System.out.println("关了");
    System.exit(0);  //正常退出.
   }
  });
  //单行文本框添加键盘监听器
  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("只能输入非小键盘数字");
     //阻止用户错误录入.
     e.consume();
    }
   }
  });
  //按钮添加键盘监听器
  but.addKeyListener(new KeyAdapter()
  {
   public void keyPressed(KeyEvent e)
   {
    //按Esc,退出程序.
    if(e.getKeyCode()==KeyEvent.VK_ESCAPE)
     System.exit(0);
    System.out.println(e.getKeyChar()+"---"+e.getKeyCode());
    //改进版,显示完整键名
    System.out.println(KeyEvent.getKeyText(e.getKeyCode())+"---"+e.getKeyCode());
    //监听组合键
    if(e.isControlDown() && e.getKeyCode()==KeyEvent.VK_ENTER)
     System.out.println("按下了Ctrl+Enter键");

   }
  });
 }
 public static void main(String[] args)
 {
  new TestKeyEvent();
  System.out.println("Hello World!");
 }
}
-------------------------------------------------------------------------------------------
案例:列出指定目录的内容

思路:
1.先把界面做出来.
2.一般不能把Window对象,添加到Container对象中,报IllegalArgumentException非法参数异常.

排版:
1.以像素为单位的排版,如Window,Frame对象:
先横坐标,再纵坐标.
2.以字符为单位的排版,如TextField,TextArea对象:
先纵坐标,再横坐标.

TextComponent类
   |--TextField类
   |--TextArea类

---->TextComponent类:

TextComponent类中的方法:
getText
得到文本组件中的文本.

---->TextArea类:
多行文本框,在初始化时,可以指定行数和列数,以字符为单位.

TextArea类中的方法:
setText
设置多行文本框的内容.

---->Dialog类:
Dialog类,是一个带标题和边界的顶层窗口,本身不能设置菜单栏.
1.窗体的对话框,分为模态和非模态.
2.Dialog类默认的布局管理器是BorderLayout边界布局.

Dialog类的构造函数,都需要有一个owner所有者对象:
1.Dialog类的所有者,可以是Window对象.
2.Dialog类的所有者,可以是Frame对象.
3.Dialog类的所有者,可以是Dialog对象.

Dialog类中的方法:
getTitle
setTitle
获取和设置对话框的标题.
setVisible
是否可见,相当于开关.

---->Label类:

Label类中的方法:
getText
setText
获取或设置标签中的文本.

代码:
import java.awt.*;
import java.awt.event.*;
import java.io.*;

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

 private Dialog d;
 private Label lab;
 private Button confirmBut;

 MyFileWindow()
 {
  init();
 }
 public void init()
 {
  f = new Frame("我的文件列表");
  //窗体宽高(以像素为单位)
  f.setBounds(300,100,1000,600);
  f.setBackground(Color.blue);
  f.setLayout(new FlowLayout());
  //列宽(以字符为单位)
  tf = new TextField(120);
  but = new Button("转到");
  //先行高,后列宽(以字符为单位)
  ta = new TextArea(30,126);

  //对话框
  d = new Dialog(f,"提示信息",true);  //模态窗口.
  d.setBounds(400,200,260,150);
  d.setLayout(new FlowLayout());
  lab = new Label();
  confirmBut = new Button("确定");
  d.add(lab);
  d.add(confirmBut);

  f.add(tf);
  f.add(but);
  f.add(ta);
  handleEvent();
  f.setVisible(true);
 }
 private void handleEvent()
 {
  //窗体关闭事件.
  f.addWindowListener(new WindowAdapter()
  {
   public void windowClosing(WindowEvent e)
   {
    System.out.println("关了");
    System.exit(0);
   }
  });
  //对话框关闭事件.
  d.addWindowListener(new WindowAdapter()
  {
   public void windowClosing(WindowEvent e)
   {
    d.setVisible(false);
   }
  });
  but.addActionListener(new ActionListener()
  {
   public void actionPerformed(ActionEvent e)
   {
    showDir();
   }
  });
  tf.addKeyListener(new KeyAdapter()
  {
   public void keyPressed(KeyEvent e)
   {
    if(e.getKeyCode()==KeyEvent.VK_ENTER)
    {
     showDir();
    }
   }
  });
 }
 //显示文件目录.
 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");
   }
   tf.setText("");
  }else
  {
   String info = "你输入的信息\""+dirPath+"\"有误!";
   lab.setText(info);
   d.setVisible(true);
  }
 }
 public static void main(String[] args)
 {
  new MyFileWindow();
  //System.out.println("Hello World!");
 }
}
---------------------------------------------------------------------------
菜单的添加与练习

MenuComponent抽象类
    |--MenuBar类
    |--MenuItem类
           |--Menu类

---->MenuBar类:

MenuBar类中的方法:
add
菜单栏里<-添加菜单

---->Menu类:

Menu类中的方法:
add
1.菜单里,可以添加菜单
2.菜单里,可以添加菜单项
3.菜单项里,不可以添加菜单和菜单项

---->MenuItem类:

MenuItem类中的方法:

代码:
import java.awt.*;
import java.awt.event.*;

class  MyMenuFrame
{
 private Frame f;
 private MenuBar mb;
 private Menu m,subMenu;
 private MenuItem closeItem,menuItem,subMenuItem;

 MyMenuFrame()
 {
  init();
 }
 private void init()
 {
  f = new Frame("有菜单的窗口");
  f.setBounds(300,100,600,400);
  f.setBackground(Color.BLUE);
  f.setLayout(new FlowLayout());
  //添加菜单栏,逆序包含
  closeItem = new MenuItem("退出");
  menuItem = new MenuItem("菜单项");
  m = new Menu("文件");
  m.add(closeItem);
  m.add(menuItem);
  subMenuItem = new MenuItem("子菜单项");
  subMenu = new Menu("子菜单");
  subMenu.add(subMenuItem);
  m.add(subMenu);
  mb = new MenuBar();
  mb.add(m);
  f.setMenuBar(mb);
  handleEvent();
  f.setVisible(true);
 }
 private void handleEvent()
 {
  closeItem.addActionListener(new ActionListener()
  {
   public void actionPerformed(ActionEvent e)
   {
    System.exit(0);
   }
  });
 }
 public static void main(String[] args)
 {
  new MyMenuFrame();
 
 }
}
---------------------------------------------------------------------------
打开与保存文件对话框

---->FileDialog类:

FileDialog文件对话框的模式:
1.FileDialog.LOAD加载
2.FileDialog.SAVE保存

FileDialog类的构造函数,都需要有一个parent父窗口对象:
1.FileDialog类的父窗口,不能是Window对象.
2.FileDialog类的父窗口,可以是Frame对象.
3.FileDialog类的父窗口,可以是Dialog对象.

FileDialog类中的方法:
getMode
setMode
获取和设置对话框的模式.
getDirectory
setDirectory
获取和设置对话框中目录的字符串.
getFile
setFile
获取和设置对话框中文件的字符串.

保存对话框的特别之处:
需要判断什么时候弹出

案例:做一个类似于记事本的程序.
代码:
import java.awt.*;
import java.awt.event.*;
import java.io.*;

class MyNotepad
{
 private Frame f;
 private MenuBar mb;
 private Menu m;
 private MenuItem closeItem,openItem,saveItem;
 //打开和保存对话框
 private FileDialog fDialog;
 private TextArea ta;
 //提升到成员变量的级别,以整合打开和保存的过程.
 private File file; 
 MyNotepad()
 {
  init();
 }
 private void init()
 {
  f = new Frame("打开与关闭文件");
  f.setBounds(400,200,500,300);
  f.setBackground(Color.YELLOW);
  mb = new MenuBar();
  m = new Menu("文件");
  closeItem = new MenuItem("退出");
  openItem = new MenuItem("打开");
  saveItem = new MenuItem("保存");
  m.add(openItem);
  m.add(saveItem);
  m.add(closeItem);

  mb.add(m);
  f.setMenuBar(mb);
  fDialog = new FileDialog(f);
  //添加多行文本框,使用默认边界布局管理器.
  ta = new TextArea();
  f.add(ta);
  handleEvent();
  f.setVisible(true);

 }
 private void handleEvent()
 {
  closeItem.addActionListener(new ActionListener()
  {
   public void actionPerformed(ActionEvent e)
   {
    System.exit(0);
   }
  });
  //打开文件的事件处理过程.
  openItem.addActionListener(new ActionListener()
  {
   public void actionPerformed(ActionEvent e)
   {
    fDialog.setTitle("我要打开");
    fDialog.setMode(FileDialog.LOAD);
    fDialog.setVisible(true);
    //通过打开对话框,可以得到打开文件的路径.
    String filePath = fDialog.getDirectory();
    String fileName = fDialog.getFile();
    System.out.println(filePath+"---"+fileName);
    //当点取消按钮时,产生空指针异常,需要判断一下.
    if(filePath==null || fileName==null)
     return;
    ta.setText("");
    file = new File(filePath,fileName);
    BufferedReader br=null; //局部变量,必须初始化.
    try
    {
     br = new BufferedReader(new FileReader(file));
     String line = null;
     while((line=br.readLine())!=null)
     {
      ta.append(line+"\r\n");  //不要忘了写的换行.
     }
    }
    catch (IOException ioE)
    {
     throw new RuntimeException("文件读取失败");
    }finally
    {
     try
     {
     if(br!=null)
      br.close(); 
     }
     catch (IOException ioClose)
     {
      throw new RuntimeException("关闭异常");
     }
     
    }
   }
  });
  //保存文件的事件处理过程.
  saveItem.addActionListener(new ActionListener()
  {
   public void actionPerformed(ActionEvent e)
   {
    //如果已经保存文件了,则不需再弹出保存文件对话框.
    if (file==null)
    {    
     fDialog.setTitle("我要保存");
     fDialog.setMode(FileDialog.SAVE);
     fDialog.setVisible(true);
     String filePath = fDialog.getDirectory();
     String fileName = fDialog.getFile();
     System.out.println(filePath+"---"+fileName);
     //当点取消按钮时,则不作任何处理了.
     if(filePath==null || fileName==null)
      return;
     file = new File(filePath,fileName);
    }
    BufferedWriter bw = null;
    try
    {
     bw = new BufferedWriter(new FileWriter(file));
     //将多行文本框中的内容,写入到文件中.
     String text = ta.getText();
     bw.write(text);  //此处不必一行一行的写了.

    }
    catch (IOException ex)
    {
     throw new RuntimeException("文件写入错误.");
    }finally
    {
     try
     {
      if(bw!=null)
       bw.close();
     }
     catch (IOException exc)
     {
      throw new RuntimeException("文件流关闭失败.");
     }
    }
   }
  });
 }
 public static void main(String[] args)
 {
  new MyNotepad();
 }
}
----------------------------------------------------------------------------------------------------------
双击运行可视化窗体

DOS命令加强:
1.javac命令:
在命令行中输入javac,可得到javac命令的帮助.
-d  这样编译出来的字节码文件,会自动加上与包名对应的,目录层次.
举例:
javac -d 目标目录 源文件
2.jar命令:
在命令行中输入jar,可得到jar命令的帮助.
-c  创建新的压缩文件.
-v  在标准输出中生成详细输出.
-f  指定压缩文件名.
-m  把指定的清单信息包含进jar包.
举例:
jar -cvf 目标文件名.jar 字节码文件目录
jar -cvfm 目标文件名.jar jar包的配置信息文件 字节码文件目录

双击运行jar包的步骤:
1.通过javac -d编译成带包的字节码文件.
2.通过jar -cvfm把字节码文件目录打成jar包,并在打包时指定jar包的配置文件.
3.在Windows中正确关联jar文件到javaw.exe(默认关联的).

jar包的配置文件的书写规范:
1.Main-Class: 包名.类名
2.冒号后必须有空格.
3.类名后必须有回车符.
注意:只要格式正确,手工写入到配置文件中,也行.

在Windows中正确关联jar文件:
1.可以是Java\jdk1.7.0_09\bin\javaw.exe
2.也可以Java\jre7\bin\javaw.exe
------------------------------------------------------------------------