首页 > 代码库 > Java基础---GUI

Java基础---GUI

2024-11-05 15:23:02   209人阅读

第一讲     GUI（用户图形界面）

一、概述

1、GUI：GraphicalUser Interface，即图形用户界面，用于计算机与用户交互的一种方式。

2、计算机与用户交互的两种方式：GUI和CLI

        GUI： Graphical User Interface，图形用户接口，用图形方式，来显示计算机操作界面，方便直观。

        CLI： Command LineUser Interface，命令行用户接口，即常见的Dos命令行操作，须记住一些命令，操作不直观。

3、java也将这种界面封装为对象，其中的对象都放在了两个包中：java.Awt包和javax.Swing包。

        java.Awt包：Abstract Window Toolkit，即抽象窗口工具包。要调用本地系统方法实现功能，属重量级控件。

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

 

二、继承关系图

 技术分享

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

Container常用子类：Window   Panel（面板，不能单独存在。）

Window常用子类：Frame  Dialog

 

三、布局管理器

1、布局：容器中的组件排列方式

2、常见的布局管理器：

        1）FlowLayout：流式布局管理器。从左向右排列，是Panel默认的布局管理器

        2）BorderLayout：边界式布局管理器，东南西北中的排列方式，是Frame的默认布局管理器。如果窗体中只有一个组件，将会覆盖整个窗体。

        3）GridLayout：网格式布局管理器，规则的矩阵

        4）CardLayout：卡片式布局管理器，即选项卡

        5）GridBayLayout：网格包布局管理器，非规则矩阵

3、如果存在多种布局方式，如何创建窗体界面呢？步骤：

        1）先将窗体Frame进行大区域的划分，设置其布局管理器，加入面板Panel

        2）将组件加入Panel，设置面板的布局管理器。

 

四、简单的窗体创建过程

1、创建Frame窗体：

        Frame f = new Frame("my Frame");//可设置标题，即窗体名字

2、对窗体进行基本设置：如大小，位置，布局等：

        f.setSize(int wight,int hight);//窗体大小设置

        f.setLocation(int x,int y);//窗体显示位置设置，横纵坐标

        f.setBounds(int x,int y,int wight,int hight)，也可以直接用这个方法对大小和位置设置

        f.setLayout(Layout layout)，参数为指定的布局管理器，如FlowLayout

3、定义组件：

       如Button b = new Button(“my Button”);//可设置组件的名称

4、将组件通过窗体的add方法添加到窗体中：

        f.add(b);//将按钮组件添加进窗体

5、让窗体显示：

        f.setVisible(boolean b);//通过设置参数是true还是false是否显示窗体

示例：

[java] view plaincopy
 
  1. <span style="font-size:14px;">import java.awt.*;  
  2.   
  3. class AwtFirstDemo   
  4. {  
  5.     public static void main(String[] args)   
  6.     {  
  7.         //创建Frame窗体：  
  8.         Frame f = new Frame("my Frame");//可设置标题  
  9.   
  10.         //对窗体进行基本设置：如大小，位置，布局等：  
  11.         f.setSize(500,100);//窗体大小设置  
  12.         f.setLocation(300,150);//窗体显示位置设置，横纵坐标   
  13.   
  14.        // f.setBounds(int x,int y,int wight,int hight);//也可以直接用这个方法对大小和位置设置  
  15.           
  16.         f.setLayout(new FlowLayout());//参数为指定的布局管理器，如FlowLayout  
  17.           
  18.         //定义组件：  
  19.         Button b = new Button("my Button");//可设置组件的名称  
  20.           
  21.         //将组件通过窗体的add方法添加到窗体中：  
  22.         f.add(b);//将按钮组件添加进窗体  
  23.           
  24.         //让窗体显示：  
  25.         f.setVisible(true);//通过设置参数是true还是false是否显示窗体  
  26.     }  
  27. }  
  28.   
  29. </span>  


五、事件监听机制

1、组成：

        1）事件源（组件）：awt或swing包中的那些图形界面组件

        2）事件（Event）：每一个事件源都有自己特有的对应事件和共性事件

        3）监听器（Listener）：将可触发某一事件的动作（不只一个动作），都封装到侦听器中。

        4）事件处理：引发事件后的处理方式。

 技术分享

2、使用说明

        组成的前三个在java中都已将定义好了，直接获取其对象来用即可，我们需要做的就是对产生的动作进行处理。

步骤：

        1）确定事件源（容器或组件）。通过事件源对象的addXXXListener()方法将监听器注册到该事件源上。该方法中接收XXXListener的子类对象，或者XXXListener的子类XXXAdapter的子类对象。

        2）一般用匿名内部类来表示。在覆盖方法的时候，方法的参数一般是XXXEvent类型的变量接收。

如：

[java] view plaincopy
 
  1. f.addWindowlistener(new WindowAdapter()  
  2. {  
  3.      public void windowClosing(WindowEvent e)  
  4.      {  
  5.           System.exit(0);//表示关闭窗口  
  6.      }  
  7. });  

说明：

        1）事件触发后会把事件打包成对象传递给复写方法中参数的淘宝开店教程变量。（其中包括事件源对象。通过getSource()或者，getComponent()获取。）

        2）若用子类实现WindowListener接口，就需要覆盖其中的7个方法，可只用到其中的关闭动作，其他动作未用到，但却必须重写全部。因为WindowLister的子类WindowAdapter（适配器）已经实现此接口，并覆盖了其中所有方法。那么只需继承WindowAdapter，覆盖需要的方法即可。

        3）明确事件，并对事件进行处理，其实，添加什么监听器就需要添加什么事件。

示例：

[java] view plaincopy
 
  1. /* 
  2. 需求：让窗体的关闭功能实现 
  3.       让按钮也具备退出程序的功能 
  4. */  
  5.   
  6. import java.awt.*;  
  7. import java.awt.event.*;  
  8.   
  9. class  AwtEventDemo  
  10. {  
  11.     //定义该图形界面所需的组件的引用  
  12.     private Frame f=null;  
  13.     private Button but=null;  
  14.   
  15.     //初始构造函数  
  16.     AwtEventDemo()  
  17.     {  
  18.         init();  
  19.     }  
  20.   
  21.     //窗体创建与功能实现  
  22.     public void init()  
  23.     {  
  24.         //实例化组件  
  25.         f=new Frame("my Frame");  
  26.         but=new Button("my Botton");  
  27.   
  28.         //窗口的基本设置  
  29.         //f.setSize(500,300);//设置大小  
  30.         //f.setLocation(300,200);//窗口初始显示位置  
  31.         f.setBounds(350,300,300,200);//一起设置窗体大小和位置  
  32.         f.setLayout(new FlowLayout());//设置为流式布局  
  33.   
  34.         //将按钮组件添加进窗体  
  35.         f.add(but);  
  36.   
  37.         //加载窗体上事件  
  38.         myEvent();  
  39.   
  40.         //显示窗体  
  41.         f.setVisible(true);  
  42.   
  43.     }  
  44.   
  45.     //注册事件  
  46.     private void myEvent()  
  47.     {  
  48.         //窗体的关闭功能  
  49.         f.addWindowListener(new WindowAdapter()  
  50.         {  
  51.             public void windowClosing(WindowEvent e)  
  52.             {  
  53.                 System.out.println("窗口关闭");  
  54.                 System.exit(0);//关闭窗口程序  
  55.             }  
  56.         });  
  57.   
  58.         //让按钮具备退出程序的功能  
  59.         /* 
  60.         按钮就是事件源。 
  61.         那么选择哪个监听器呢？ 
  62.         通过关闭窗体示例了解到，想要知道哪个组件具备什么样的特有监听器。 
  63.         需要查看该组件对象的功能。 
  64.          通过查阅button的描述。发现按钮支持一个特有监听addActionListener。 
  65.          */  
  66.         but.addActionListener(new ActionListener()  
  67.         {  
  68.             public void actionPerformed(ActionEvent e)  
  69.             {  
  70.                 System.out.println("按钮控制窗口关闭");  
  71.                 System.exit(0);//关闭窗口程序  
  72.             }  
  73.         });  
  74.     }  
  75.   
  76.     public static void main(String[] args)   
  77.     {  
  78.         //运行窗体程序  
  79.         new AwtEventDemo();  
  80.     }  
  81. }  

练习： 

[java] view plaincopy
 
  1. /* 
  2. 共性事件：键盘事件和鼠标事件 
  3.  
  4. 需求：在窗体中列出指定目录内容 
  5. */  
  6. import java.awt.*;  
  7. import java.awt.event.*;  
  8. import java.io.*;  
  9.   
  10. class KeyAndMouseEvent   
  11. {  
  12.     //全局变量的界面组件引用  
  13.     private Frame f;  
  14.     private Button but;  
  15.     private TextField tf;  
  16.     private TextArea ta;  
  17.   
  18.     //构造函数  
  19.     KeyAndMouseEvent()  
  20.     {  
  21.         init();  
  22.     }  
  23.   
  24.     //窗体创建与功能实现  
  25.     public void init()  
  26.     {  
  27.         //组件实例化  
  28.         f=new Frame("my fame");  
  29.         but=new Button("跳转");  
  30.         tf=new TextField(50);  
  31.         ta=new TextArea(30,58);  
  32.   
  33.         //窗体基本设置  
  34.         f.setBounds(300,150,500,500);  
  35.         f.setLayout(new FlowLayout());  
  36.   
  37.         //添加组件  
  38.         f.add(tf);  
  39.         f.add(but);  
  40.         f.add(ta);  
  41.   
  42.         //窗体事件  
  43.         myEvent();  
  44.           
  45.         //窗体显示  
  46.         f.setVisible(true);  
  47.     }  
  48.   
  49.     //注册事件  
  50.     public void myEvent()  
  51.     {  
  52.         //窗体关闭功能  
  53.         f.addWindowListener(new WindowAdapter()  
  54.         {  
  55.             public void windowClosing(WindowEvent e)  
  56.             {  
  57.                 System.exit(0);  
  58.             }  
  59.         });  
  60.   
  61.         /* 
  62.         //鼠标活动事件 
  63.         but.addActionListener(new ActionListener() 
  64.         { 
  65.             public void actionPerformed(ActionEvent e) 
  66.             { 
  67.                 System.out.println("按钮在动");  
  68.             } 
  69.         }); 
  70.         */  
  71.   
  72.         //鼠标事件  
  73.         but.addMouseListener(new MouseAdapter()  
  74.         {  
  75.             //int count=0;  
  76.             public void mouseClicked(MouseEvent e)  
  77.             {  
  78.             //  if(e.getClickCount()==2)  
  79.             //      System.out.println("鼠标双击按钮");  
  80.   
  81.             //  System.out.println("鼠标单击按钮");  
  82.                 //System.exit(0);  
  83.   
  84.                 showFile();//显示到文本区中  
  85.             }  
  86.             /* 
  87.             public void mouseEntered(MouseEvent e) 
  88.             { 
  89.                 System.out.println("鼠标放进入按钮范围"+(++count)+"次"); 
  90.             } 
  91.             */  
  92.         });  
  93.   
  94.         /* 
  95.         //按钮键盘事件 
  96.         but.addKeyListener(new KeyAdapter() 
  97.         { 
  98.             public void keyPressed(KeyEvent e) 
  99.             { 
  100.                 //捕获同时按下ctrl+entry 
  101.                 if(e.isControlDown()&&e.getKeyCode()==KeyEvent.VK_ENTER) 
  102.                     System.out.println("Ctrl+Enter.....is Down"); 
  103.                  
  104.                 //System.out.println(e.getKeyText(e.getKeyCode())+"---"+e.getKeyCode());     
  105.             } 
  106.         }); 
  107.         */  
  108.   
  109.         //文本框键盘事件  
  110.         tf.addKeyListener(new KeyAdapter()  
  111.         {  
  112.             public void keyPressed(KeyEvent e)  
  113.             {  
  114.                 /* 
  115.                 //判断输入字符是否是数字 
  116.                 if(e.getKeyCode()<KeyEvent.VK_0||e.getKeyCode()>KeyEvent.VK_9) 
  117.                 { 
  118.                     System.out.println("你输入的数字非法，请重数"); 
  119.                     e.consume();//不显示输入的字符 
  120.                 } 
  121.                 */  
  122.   
  123.                 if(e.getKeyCode()==KeyEvent.VK_ENTER)  
  124.                     showFile();//将目录下的内容显示到文本区中  
  125.             }  
  126.         });  
  127.     }  
  128.   
  129.     //将路径下的目录或文件列出  
  130.     private void showFile()  
  131.     {  
  132.         String path=tf.getText();//获取文本框内容  
  133.         File file=new File(path);//将路径封装成文件对象  
  134.         //判断是否存在  
  135.         if(file.exists())  
  136.         {  
  137.             ta.setText("");//清空文本区中的内容  
  138.             //如果是目录  
  139.             if(file.isDirectory())  
  140.             {  
  141.                 String[] dir=file.list();//列出目录下的文件和目录  
  142.                 //遍历  
  143.                 for (String name : dir)  
  144.                 {  
  145.                     ta.append(name+"\r\n");//添加到文本区中  
  146.                 }  
  147.             }  
  148.             else  
  149.                 ta.append(file.getName());//如果是文件，则只显示该文件的名字  
  150.         }  
  151.         else  
  152.             System.out.println("您输入的路径不存在，请重输或者去医院");  
  153.     }  
  154.       
  155.   
  156.     public static void main(String[] args)   
  157.     {  
  158.         //运行窗体  
  159.         new KeyAndMouseEvent();  
  160.     }  
  161. }  

 

第二讲     应用

一、对话框：Dialog

        何时需要产生对话框：此对象时需要在调用时，才创建对象。如：当在误操作的时候，就需要出现提示错误信息的对话框，此时才创建的这个对象。

人生感悟示例：

        对列出指定目录内容示例的功能增强。

[java] view plaincopy
 
  1. /* 
  2. 列出指定目录下的内容，当输入的路径不正确时，给出错误提示信息。 
  3. */  
  4.   
  5. import java.io.*;  
  6. import java.awt.*;  
  7. import java.awt.event.*;  
  8.   
  9. class MyWindowDemo   
  10. {  
  11.     //定义所需组件引用  
  12.     private Frame f;  
  13.     private Button but,bok;  
  14.     private TextField tf;  
  15.     private TextArea ta;  
  16.     private Dialog d;  
  17.     private Label lab;  
  18.   
  19.     //构造函数  
  20.     MyWindowDemo()  
  21.     {  
  22.         init();  
  23.     }  
  24.   
  25.     //窗体基本设置于功能实现  
  26.     public void init()  
  27.     {  
  28.         //组件实例化  
  29.         f=new Frame("我的Window");  
  30.         but=new Button("跳转");  
  31.         tf=new TextField(50);  
  32.         ta=new TextArea(30,60);  
  33.   
  34.         //基本设置  
  35.         f.setBounds(300,150,500,500);  
  36.         f.setLayout(new FlowLayout());  
  37.   
  38.         //添加组件  
  39.         f.add(tf);  
  40.         f.add(but);  
  41.         f.add(ta);  
  42.   
  43.         //窗体事件  
  44.         myEvent();  
  45.   
  46.         //窗体显示  
  47.         f.setVisible(true);  
  48.     }  
  49.   
  50.     //注册事件  
  51.     public void myEvent()  
  52.     {  
  53.         //窗体关闭功能  
  54.         f.addWindowListener(new WindowAdapter()  
  55.         {  
  56.             public void windowClosing(WindowEvent e)  
  57.             {  
  58.                 System.exit(0);  
  59.             }  
  60.         });  
  61.   
  62.         //“跳转”按钮事件  
  63.         but.addActionListener(new ActionListener()  
  64.         {  
  65.             public void actionPerformed(ActionEvent e)  
  66.             {  
  67.                 showFile();//列出目录内容在文本区中  
  68.             }  
  69.         });  
  70.   
  71.           
  72.   
  73.         //文本框键盘事件  
  74.         tf.addKeyListener(new KeyAdapter()  
  75.         {  
  76.             public void keyPressed(KeyEvent e)  
  77.             {  
  78.                 //如果键盘按下Enter键，就将目录内容显示在文本区中  
  79.                 if(e.getKeyCode()==KeyEvent.VK_ENTER)  
  80.                     showFile();  
  81.             }  
  82.         });  
  83.     }  
  84.   
  85.     //目录内容显示在文本区中方法  
  86.         private void showFile()  
  87.         {  
  88.             String path=tf.getText();//获取输入的路径  
  89.             File dir=new File(path);//将路径封装成对象  
  90.             //判断输入的路径是否存在，且是否是文件夹  
  91.             if (dir.exists()&&dir.isDirectory())  
  92.             {  
  93.                 ta.setText("");//清空文本区中的内容---------  
  94.                   
  95.                 String names[]=dir.list();//列出目录下的内容  
  96.                 //遍历  
  97.                 for (String name : names )  
  98.                 {  
  99.                     ta.append(name+"\r\n");//添加进文本区中  
  100.                 }  
  101.             }  
  102.             else  
  103.             {  
  104.                 //对话框基本设置  
  105.                 d=new Dialog(f,"错误提示",true);  
  106.                 d.setBounds(400,200,280,150);  
  107.                 d.setLayout(new FlowLayout());  
  108.   
  109.                 bok=new Button("确定");  
  110.                 lab=new Label();  
  111.   
  112.                 //添加按钮和文本  
  113.                 d.add(bok);  
  114.                 d.add(lab);  
  115.   
  116.   
  117.                 //对话框关闭事件  
  118.                 d.addWindowListener(new WindowAdapter()  
  119.                 {  
  120.                     public void windowClosing(WindowEvent e)  
  121.                     {  
  122.                         d.setVisible(false);//退出对话框  
  123.                     }  
  124.                 });  
  125.   
  126.                 //“确定”按钮事件  
  127.                 bok.addActionListener(new ActionListener()  
  128.                 {  
  129.                     public void actionPerformed(ActionEvent e)  
  130.                     {  
  131.                         d.setVisible(false);//按确认键，退出对话框  
  132.                     }  
  133.                 });  
  134.   
  135.   
  136.                 String info="您输入的路径："+path+"是错误的，请重输！";  
  137.   
  138.                 lab.setText(info);//设置标签文本内容  
  139.                 d.setVisible(true);//显示对话框  
  140.             }  
  141.         }  
  142.   
  143.     public static void main(String[] args)   
  144.     {  
  145.         //运行窗体  
  146.         new MyWindowDemo();  
  147.     }  
  148. }  


二、菜单：Menu

1、菜单继承关系

       技术分享

2、说明

        1）Menu：菜单，继承MenuItem；有右三角的图标存在，可添加Menu和MenuItem

        2）MenuBar：菜单栏，可添加菜单和菜单条目。一般先创建菜单栏，再创建菜单。

        3）MenuItem：菜单条目，也称菜单项，无右三角的图标存在，是最终的菜单项。

        4）菜单的事件处理和组件一样，可以对类型为MenuItem和Menu的对象这个事件源添加活动监听ActionListener，并进行相关的事件处理。

        5）通过setMenuBar()方法，将菜单添加到Frame中。

示例： 

[java] view plaincopy
 
  1. import java.awt.*;  
  2. import java.awt.event.*;  
  3.   
  4. class MyMenuDemo   
  5. {  
  6.     //定义组件引用  
  7.     private Frame f;  
  8.     private MenuBar mb;  
  9.     private Menu m,subMenu;  
  10.     private MenuItem closeItem,subItem;  
  11.     //构造函数  
  12.     MyMenuDemo()  
  13.     {  
  14.         init();  
  15.     }  
  16. //窗体设置与功能实现   
  17.     public void init()  
  18.     {  
  19.         //窗体设置  
  20. f = new Frame("my window");  
  21.         f.setBounds(300,100,500,600);  
  22.         f.setLayout(new FlowLayout());  
  23.       
  24.         mb = new MenuBar();//创建菜单条  
  25.         m = new Menu("文件");//创建菜单  
  26.         subMenu = new Menu("子菜单");//菜单下面的子菜单  
  27.   
  28.         subItem = new MenuItem("子条目");//子菜单包含的菜单条目  
  29.         closeItem = new MenuItem("退出");//菜单包含的条目  
  30.           
  31. //菜单添加菜单组件  
  32.         subMenu.add(subItem);  
  33.         m.add(subMenu);  
  34.         m.add(closeItem);  
  35.         mb.add(m);  
  36.         //窗体添加菜单组件  
  37.         f.setMenuBar(mb);  
  38.         //窗体上事件  
  39.         myEvent();  
  40.         //窗体显示  
  41.         f.setVisible(true);  
  42.     }  
  43.     private void myEvent()  
  44.     {  
  45.         //关闭菜单具备关闭事件  
  46.         closeItem.addActionListener(new ActionListener()  
  47.         {  
  48.             public void actionPerformed(ActionEvent e)  
  49.             {  
  50.                 System.exit(0);  
  51.             }  
  52.         });  
  53.         //窗体关闭功能  
  54.         f.addWindowListener(new WindowAdapter()  
  55.         {  
  56.             public void windowClosing(WindowEvent e)  
  57.             {  
  58.                 System.exit(0);   
  59.             }  
  60.         });  
  61.     }  
  62.       
  63.     public static void main(String[] args)   
  64.     {  
  65.         new MyMenuDemo();  
  66.     }  
  67. }  

 

三、jar包双击执行

        既然是图形化界面，就需要通过图形化界面的形式运行程序，而不是是用Dos命令行执行，那么如何通过双击程序就执行程序呢？这就需要将程序的class文件打包。

步骤如下：

        1、首先要在java文件中导入一个包，没有则需创建一个包，如package mymenu;

        2、生成包：通过编译javac -d c:\myclass MyMenu.java，此时则在c盘下的myclass文件夹下生成了所有的.class文件

        3、在此目录下新建一个文件，如1.txt或者其他任意名称任意扩展名的文件都可，然后在其中编辑固定的格式：“Main-Class: mymenu.MenuDemo”，只写引号中的内容。需要需要在冒号后有一个空格，在文件末尾要回车。

        4、编译：jar -cvfm my.jar 1.txt mymenu即可。如果想添加其他信息，则直接编译jar即可得出相应的命令

        5、此时双击即可执行。

说明：

        1）在固定格式中：

                a、如果无空格：在编译的时候，就会报IO异常，提示无效的头字段，即invalidheader field。这说明1.txt在被IO流读取。

                b、如果无回车：在列表清单.MF中不会加入相应的加载主类的信息，也就是说配置清单的属性主类名称不会加载进清单中，也就不会执行。

        2）jar文件必须在系统中注册，才能运行。注册方法如下：

        A.对于XP系统：

               a.打开任意对话框，在菜单栏点击工具按钮，选择文件夹选项

               b.选择新建--->扩展名，将扩展名设置为jar，确定

               c.选择高级，可更改图标，然后点击新建，命名为open，

               d.在用于可执行应用程序中，点浏览，将jdk下的bin的整个文件路径添加进来，并在路径后添加-jar即可。

        B.对于win7系统：

               a.改变打开方式：右击.jar文件，点击打开方式，选择默认程序为jdk下bin中的javaw.exe应用程序。

               b.修改关联程序的注册表：打开注册表（win+r），找到注册表路径\HKEY_CLASSES_ROOT\Aplications\javaw.exe\shell\open\command下的字符串值，右击点修改，在原路径的中添加-jar，如："C:\ProgramFiles\Java\jre6\bin\javaw.exe" -jar "%1"，注意-jar两边要有空格，保存。

              c.双击即可执行jar程序，如果仍不能执行，则需下载最新版的jdk。

示例：

[java] view plaincopy
 
    1. /* 
    2. 练习：利用Menu组件完成一个简单的记事本程序。 
    3. 需求：具有文件菜单，文件中有打开，保存和退出功能。将写好的程序变为双击可执行的程序。 
    4. */  
    5.   
    6. package mymenu;  
    7. import java.awt.*;  
    8. import java.awt.event.*;  
    9. import java.io.*;  
    10.   
    11. class MyMenuText  
    12. {  
    13.     //定义组件引用  
    14.     private Frame f;  
    15.     private TextArea ta;  
    16.     private MenuBar mb;  
    17.     private Menu fileMe;  
    18.     private MenuItem openMi,saveMi,otherSaveMi,closeMi;  
    19.   
    20.     private FileDialog openDia,saveDia;  
    21.   
    22.     private File file;  
    23.   
    24.     //构造函数  
    25.     MyMenuText()  
    26.     {  
    27.         init();  
    28.     }  
    29.   
    30.     //功能实现  
    31.     private void init()  
    32.     {  
    33.         //组件实例化  
    34.         f=new Frame("MyText");  
    35.         ta=new TextArea();  
    36.           
    37.         mb=new MenuBar();  
    38.         fileMe=new Menu("文件");  
    39.         openMi=new MenuItem("打开");  
    40.         saveMi=new MenuItem("保存");  
    41.         otherSaveMi=new MenuItem("另存为");  
    42.         closeMi=new MenuItem("退出");  
    43.   
    44.         openDia=new FileDialog(f,"选择打开的文件",FileDialog.LOAD);  
    45.         saveDia=new FileDialog(f,"保存到哪里",FileDialog.SAVE);  
    46.   
    47.         //基本设置  
    48.         f.setBounds(300,150,600,500);  
    49.   
    50.         //添加组件  
    51.         f.add(ta);  
    52.         f.setMenuBar(mb);  
    53.   
    54.         mb.add(fileMe);  
    55.         fileMe.add(openMi);  
    56.         fileMe.add(saveMi);  
    57.         fileMe.add(otherSaveMi);  
    58.         fileMe.add(closeMi);  
    59.   
    60.         //窗体中事件  
    61.         myEvent();  
    62.   
    63.         //窗体显示  
    64.         f.setVisible(true);  
    65.     }  
    66.   
    67.     private void myEvent()  
    68.     {  
    69.         //窗体关闭功能  
    70.         f.addWindowListener(new WindowAdapter()  
    71.         {  
    72.             public void windowClosing(WindowEvent e)  
    73.             {  
    74.                 System.exit(0);  
    75.             }  
    76.         });  
    77.   
    78.         //打开事件  
    79.         openMi.addActionListener(new ActionListener()  
    80.         {  
    81.             public void actionPerformed(ActionEvent e)  
    82.             {  
    83.                 //显示文件对话窗口  
    84.                 openDia.setVisible(true);//------------------  
    85.                 String dir=openDia.getDirectory();//获取目录  
    86.                 String fileName=openDia.getFile();//获取文件名  
    87.                   
    88.                 if(dir==null||fileName==null)//对打开了文件对话框，但未做出操作的处理  
    89.                     return;  
    90.           
    91.                 file=new File(dir,fileName);//文件对象  
    92.                 try  
    93.                 {  
    94.                     ta.setText("");//每打开一个文件时，将文本区的内容清空  
    95.                     //带缓冲技术的读取流  
    96.                     BufferedReader br=new BufferedReader(new FileReader(file));  
    97.                     String line=null;//读一行  
    98.                     while ((line=br.readLine())!=null)  
    99.                     {  
    100.                         //添加到文本区域  
    101.                         ta.append(line+"\r\n");  
    102.                     }  
    103.                     br.close();//关流  
    104.                 }  
    105.                 catch (IOException ie)  
    106.                 {  
    107.                     throw new RuntimeException("文件打开失败");  
    108.                 }  
    109.             }  
    110.         });  
    111.   
    112.         //保存事件  
    113.         saveMi.addActionListener(new ActionListener()  
    114.         {  
    115.             public void actionPerformed(ActionEvent e)  
    116.             {  
    117.                 //如果是第一次保存，则显示文件对话框  
    118.                 if(file==null)//-------------  
    119.                 {  
    120.                     //显示文件对话框  
    121.                     saveDia.setVisible(true);//----------------------  
    122.                     String dir=saveDia.getDirectory();  
    123.                     String filename=saveDia.getFile();  
    124.                       
    125.                     if(dir==null||filename==null)//--------------------  
    126.                         return;  
    127.   
    128.                     file=new File(dir,filename);  
    129.                       
    130.                 }  
    131.                 save();//保存文件方法  
    132.             }  
    133.         });  
    134.           
    135.         //另存为事件  
    136.         otherSaveMi.addActionListener(new ActionListener()  
    137.         {  
    138.             public void actionPerformed(ActionEvent e)  
    139.             {  
    140.                 //不管是不是第一次保存，都显示文件对话框  
    141.                 saveDia.setVisible(true);//----------------------  
    142.                 String dir=saveDia.getDirectory();  
    143.                 String filename=saveDia.getFile();  
    144.   
    145.                 if(dir==null||filename==null)//--------------------  
    146.                     return;  
    147.   
    148.                 file=new File(dir,filename);  
    149.   
    150.                 save();//保存文件方法  
    151.                 //保存时，默认文件对话框位置在打开文件的位置  
    152.                 openDia.setFile(file.getName());  
    153.             }  
    154.         });  
    155.   
    156.         //退出事件  
    157.         closeMi.addActionListener(new ActionListener()  
    158.         {  
    159.             public void actionPerformed(ActionEvent e)  
    160.             {  
    161.                 System.exit(0);  
    162.             }  
    163.         });  
    164.     }  
    165.       
    166.     //保存文件  
    167.     private void save()  
    168.     {             
    169.         try  
    170.         {  
    171.             //带缓冲区的写入流  
    172.             BufferedWriter bw=new BufferedWriter(new FileWriter(file));  
    173.             //获取文本区域中的内容  
    174.             String text=ta.getText();  
    175.             bw.write(text);//写入文件中  
    176.             bw.close();//关流  
    177.   
    178.         }  
    179.         catch (IOException ie)  
    180.         {  
    181.             throw new RuntimeException("文件保存失败");  
    182.         }  
    183.     }  
    184.   
    185.     public static void main(String[] args)   
    186.     {  
    187.         //程序运行  
    188.         new MyMenuText();  
    189.     }  
    190. }  

Java基础---GUI


联系
我们