[关闭]
@w460461339 2016-11-16T07:10:00.000000Z 字数 8502 阅读 921

Java学习Day14 （GUI）

Java基础

今天终于可以告别无聊的控制台，也不用像C/C++那样看小黑屏了，我们可以利用GUI（Graphical User Interface）来制作图形界面了！

1.GUI简介

GUI：

Graphical User Interface(图形用户接口)。
用图形的方式，来显示计算机操作的界面，这样更方便更直观。

所依赖的包：

java.awt：Abstract Window ToolKit (抽象窗口工具包)，需要调用本地系统方法实现功能。属重量级控件。
javax.swing：在AWT的基础上，建立的一套图形界面系统，其中提供了更多的组件，而且完全由Java实现。增强了移植性，属轻量级控件。

因为swing包下的图形界面是用Java实现的，所以用它会有比较高的可移植性，用它比较好。

GUI集成体系图

图中container是容器类，我们目前使用Frame比较多。右边主要是功能按钮类（忘记怎么描述了），是往容器中添加，并实现某个功能用的。

2.GUI功能

由于方法太对，没办法一个个的学习过来，这里就简单说一些功能。

2.1创建窗口，设置标题，设置大小，设置位置
  1. package GUI_01;
  3. import java.awt.Frame;
  5. public class FrameDemo {
  6.     public static void main(String[] args) {
  7.         //创建Frame对象（就是窗口）
  8.         Frame fr=new Frame();
  9.         //设置窗口名字，也可以在创建的时候给
  10.         fr.setTitle("helloWorld");
  11.         //设置窗口大小
  12.         fr.setSize(300, 400);
  13.         //设置窗口初始位置
  14.         fr.setLocation(100, 200);
  15.         //令窗口可视。
  16.         fr.setVisible(true);
  17.     }
  18. }

但这个时候我们发下我们没办法用单击 x 的方式将窗口关掉，只能用停止程序的方式，因此，就需要下面的知识了~！

2.2事件监听功能

（宝宝快来呀…下雪天好冷的~）
方法一

  1. package GUI_01;
  3. import java.awt.Frame;
  4. import java.awt.event.WindowAdapter;
  5. import java.awt.event.WindowEvent;
  6. import java.awt.event.WindowListener;
  8. public class FrameDemo {
  10.     public static void main(String[] args) {
  11.         Frame fr=new Frame();
  13.         fr.setTitle("helloWorld");
  14. //      fr.setSize(300, 400);
  15. //      fr.setLocation(100, 200);
  16.         //效果和直接上面两句话合在一起一样
  17.         fr.setBounds(100, 200, 300, 400);
  18.         //匿名内部类实现windowsListener接口
  19.         //需要实现每个方法，太麻烦= - 
  20.         fr.addWindowListener(new WindowListener() {
  21.             @Override
  22.             public void windowOpened(WindowEvent e) {
  23.                 // TODO Auto-generated method stub
  25.             }
  27.             @Override
  28.             public void windowIconified(WindowEvent e) {
  29.                 // TODO Auto-generated method stub
  31.             }
  33.             @Override
  34.             public void windowDeiconified(WindowEvent e) {
  35.                 // TODO Auto-generated method stub
  37.             }
  39.             @Override
  40.             public void windowDeactivated(WindowEvent e) {
  41.                 // TODO Auto-generated method stub
  43.             }
  45.             @Override
  46.             public void windowClosing(WindowEvent e) {
  47.                     System.exit(0);
  48.             }
  50.             @Override
  51.             public void windowClosed(WindowEvent e) {
  52.                 // TODO Auto-generated method stub
  54.             }
  56.             @Override
  57.             public void windowActivated(WindowEvent e) {
  58.                 // TODO Auto-generated method stub
  60.             }
  61.         });
  64.         fr.setVisible(true);    
  65.     }
  66. }

方法二

  1. package GUI_01;
  3. import java.awt.Frame;
  4. import java.awt.event.WindowAdapter;
  5. import java.awt.event.WindowEvent;
  6. import java.awt.event.WindowListener;
  8. public class FrameDemo {
  10.     public static void main(String[] args) {
  11.         Frame fr=new Frame();
  13.         fr.setTitle("helloWorld");
  14.         fr.setBounds(100, 200, 300, 400);
  15.         //利用适配器。
  16.         //适配器对接口中所有方法空实现
  17.         //之后只要继承适配器，重写所需要的方法就可以了。
  18.         fr.addWindowListener(new WindowAdapter() {
  19.             public void windowClosing(java.awt.event.WindowEvent e)
  20.             {
  21.                 System.exit(0);
  22.             };
  23.           }
  24.         );
  25.         fr.setVisible(true);    
  26.     }
  27. }

所以，有适配器的情况下，还是请使用适配器会比较好。

2.3往窗口中添加按钮对象。
  1. package GUI_01;
  3. import java.awt.Button;
  4. import java.awt.Color;
  5. import java.awt.FlowLayout;
  6. import java.awt.Frame;
  7. import java.awt.event.ActionEvent;
  8. import java.awt.event.ActionListener;
  9. import java.awt.event.MouseAdapter;
  10. import java.awt.event.MouseEvent;
  11. import java.awt.event.WindowAdapter;
  13. /**
  14.  * 需求：
  15.  *      往窗口中添加按钮。
  16.  *      并设置按钮的移入事件,更改背景颜色
  17.  *      设置单击事件，回复背景颜色。
  18.  */
  20. public class ButtonDemo {
  22.     public static void main(String[] args) {
  23.         //创建窗口
  24.         final Frame fr=new Frame("按钮测试");
  25.         //设置窗口参数
  26.         fr.setBounds(200, 300, 400, 300);
  27.         //设置窗口布局
  28.         fr.setLayout(new FlowLayout());
  30.         //创建按钮
  31.         Button bu1=new Button();
  32.         bu1.setLabel("红色");
  34.         Button bu2=new Button();
  35.         bu2.setLabel("绿色");
  37.         Button bu3=new Button();
  38.         bu3.setLabel("复原");
  40.         //添加按钮
  41.         fr.add(bu1);
  42.         fr.add(bu2);
  43.         fr.add(bu3);
  45.         //添加对按钮的鼠标进入事件
  46.         //所以用的是鼠标监听器，添加鼠标适配器
  47.         bu1.addMouseListener(new MouseAdapter() {
  48.             @Override
  49.             public void mouseEntered(MouseEvent e) {
  50.                 fr.setBackground(Color.RED);
  51.             }
  52.         });
  54.         bu2.addMouseListener(new MouseAdapter() {
  55.             @Override
  56.             public void mouseEntered(MouseEvent e) {
  57.                 fr.setBackground(Color.GREEN);
  58.             }
  59.         });
  60.         //添加对按钮本身的事件监听
  61.         //所以添加的是对按钮本身的监听器
  62.         bu3.addActionListener(new ActionListener() {
  64.             @Override
  65.             public void actionPerformed(ActionEvent e) {
  66.                 fr.setBackground(Color.WHITE);
  67.             }
  68.         });
  70.         //设置窗口关闭
  71.         fr.addWindowListener(new WindowAdapter() {
  72.             public void windowClosing(java.awt.event.WindowEvent e) 
  73.             {
  74.                     System.exit(0);
  75.                 };
  76.             }
  77.         );
  78.         //设置窗口可见
  79.         fr.setVisible(true);
  80.     }
  81. }

这里需要注意，对鼠标的动作监听，就需要调用方法，添加鼠标适配器（addMouseListener（new MouseAdapter））；对按下按钮本身而言，是按钮发生了变化，因此需要对鼠标本身做监听。

这里另外解释下addActionListener以及其中创建的ActionListener 对象。
它用于监听组件的特定动作。比如对于按钮就是被按下，对于下拉条就是被滑动等等。就是这个用于监听这个时间发生与否。这与鼠标事件明确是进入还是离开有点不一样，它是默认的，所以在此特别说明。

2.4将文本框数据移入文本域
  1. package GUI_01;
  3. import java.awt.Button;
  4. import java.awt.FlowLayout;
  5. import java.awt.Frame;
  6. import java.awt.TextArea;
  7. import java.awt.TextField;
  8. import java.awt.event.ActionEvent;
  9. import java.awt.event.ActionListener;
  10. import java.awt.event.WindowAdapter;
  11. import java.awt.event.WindowEvent;
  13. /**
  14.  * 需求：
  15.  *      在文本框中输入任意字符；
  16.  *      单击按钮；
  17.  *      将文本框中内容转入文本域
  18.  *      下一次时添加在末尾。
  19.  */
  20. public class TextDemo {
  22.     public static void main(String[] args) {
  23.         //创建窗口
  24.         Frame fr=new Frame("文本框文本域转换");
  25.         //设置窗口属性
  26.         fr.setBounds(200, 300, 400, 300);
  27.         //设置窗口布局
  28.         fr.setLayout(new FlowLayout());
  29.         //创建文本框,可以输入1行（默认一行），20列
  30.         final TextField tf=new TextField(20);
  31.         //创建文本域,可以输入20行，40列
  32.         final TextArea ta=new TextArea(20, 40);
  33.         //创建按钮
  34.         Button bu=new Button("转换");
  35.         //添加组件
  36.         fr.add(tf);
  37.         fr.add(bu);
  38.         fr.add(ta);
  39.         //对按钮添加事件
  40.         bu.addActionListener(new ActionListener() { 
  41.             @Override
  42.             public void actionPerformed(ActionEvent e) {
  43.                 //获取文本框中内容
  44.                 String tfstr=tf.getText();
  45.                 //往文本域中追加内容
  46.                 ta.append(tfstr+"\r\n");
  47.                 //清空文本框
  48.                 tf.setText("");
  49.                 //给文本框光标
  50.                 tf.requestFocus();
  51.             }
  52.         });
  54.         //添加窗口关闭事件
  55.         fr.addWindowListener(new WindowAdapter() {
  56.             @Override
  57.             public void windowClosing(WindowEvent e) {
  58.                 System.exit(0);
  59.             }
  60.         });
  61.         //显示窗口
  62.         fr.setVisible(true);
  63.     }
  64. }
2.5多级菜单

这里首相要明确各级包含顺序：
最大的是菜单条（MenuBar），就是菜单背景那个灰色的区域，它只能包含菜单；
其次是菜单（Menu），就是文件，编辑之类的，点开之后又下拉内容的，它能包含菜单和菜单项。
最小的是菜单项（MenuItem），就是点开菜单，并且之后没有进一级内容的选项。

  1. package GUI_01;
  3. import java.awt.FlowLayout;
  4. import java.awt.Frame;
  5. import java.awt.Menu;
  6. import java.awt.MenuBar;
  7. import java.awt.MenuItem;
  8. import java.awt.event.ActionEvent;
  9. import java.awt.event.ActionListener;
  10. import java.awt.event.WindowAdapter;
  11. import java.awt.event.WindowEvent;
  12. import java.io.IOException;
  14. /**
  15.  * 需求：
  16.  *      创建多级菜单
  17.  * 预先知识：
  18.  *      先创立菜单条（灰色的背景部分）
  19.  *      在创立菜单（上面的文件，编辑之类的）
  20.  *      最后创立菜单项（每个菜单的下拉列表）
  21.  *
  22.  */
  23. public class MenuDemo {
  25.     public static void main(String[] args) {
  26.         //最后一遍联系窗口的创建以及关闭
  27.         //创建窗口
  28.         Frame fr=new Frame("多级菜单");
  29.         //设置窗口参数
  30.         fr.setBounds(200, 300, 300, 400);
  31.         //设置布局
  32.         fr.setLayout(new FlowLayout());
  33.         //创建菜单条
  34.         MenuBar mb=new MenuBar();
  35.         //创建菜单
  36.         Menu me1=new Menu("文件");
  37.         Menu me2=new Menu("编辑");
  38.         //这个菜单在文件菜单下
  39.         Menu me3=new Menu("新建");
  40.         //创建菜单项
  41.         MenuItem mi1=new MenuItem(".txt");
  42.         MenuItem mi2=new MenuItem(".doc");
  43.         MenuItem mi3=new MenuItem("Quit");
  44.         MenuItem mi4=new MenuItem("CopyALL");
  45.         MenuItem mi5=new MenuItem("DeleAll");
  46.         //往菜单中添加菜单项
  47.         //往“新建”菜单中添加菜单项
  48.         me3.add(mi1);
  49.         me3.add(mi2);
  50.         //往“文件”菜单中添加菜单和菜单项
  51.         me1.add(me3);
  52.         me1.add(mi3);
  53.         //往“编辑”菜单中添加菜单项
  54.         me2.add(mi4);
  55.         me2.add(mi5);
  56.         //往菜单条中添加菜单
  57.         mb.add(me1);
  58.         mb.add(me2);
  59.         //窗口中添加菜单条
  60.         fr.setMenuBar(mb);
  61.         //添加点击.txt打开记事本事件
  62.         mi1.addActionListener(new ActionListener() {    
  63.             @Override
  64.             public void actionPerformed(ActionEvent e) {
  65.                 try {
  66.                     Runtime.getRuntime().exec("notepad");
  67.                 } catch (IOException e1) {
  68.                     e1.printStackTrace();
  69.                 }
  70.             }
  71.         });
  72.         //添加点击QUIT关闭事件
  73.         mi3.addActionListener(new ActionListener() {
  74.             @Override
  75.             public void actionPerformed(ActionEvent e) {
  76.                 System.exit(0);
  77.             }
  78.         });
  79.         //添加点击X关闭事件
  80.         fr.addWindowListener(new WindowAdapter() {
  81.             @Override
  82.             public void windowClosing(WindowEvent e) {
  83.                 System.exit(0);
  84.             }   
  85.         });
  86.         //设置窗口可见
  87.         fr.setVisible(true);
  88.     }
  89. }
2.6计算器

说明：

1、由于在Java中排版比较困难，所以这里不用Label了。想要好的排版，请用NetBeans
2、目前只是简单版本，还没有进行数据校验，运算规则校验，小数运算等等内容。
3、同时，更改图标功能也没有完成= - 

  1. package _GUI_01;
  3. import java.awt.Button;
  4. import java.awt.Choice;
  5. import java.awt.FlowLayout;
  6. import java.awt.Frame;
  7. import java.awt.Label;
  8. import java.awt.List;
  9. import java.awt.TextField;
  10. import java.awt.event.ActionEvent;
  11. import java.awt.event.ActionListener;
  12. import java.awt.event.WindowAdapter;
  14. public class CalculatorDemo {
  15.     public static void main(String[] args) {
  16.         //创建窗口
  17.         final Frame fr=new Frame("按钮测试");
  18.         //设置窗口参数
  19.         fr.setBounds(200, 300, 400, 300);
  20.         //设置窗口布局
  21.         fr.setLayout(new FlowLayout());
  22.         //创建标签
  23.         Label firstLabel=new Label("FirstNumber");
  24.         Label secondLabel=new Label("SecondNumber");        
  25.         Label resultLabel=new Label("resultNumber");
  26.         Label equals=new Label("=");
  27.         //创建文本框
  28.         final TextField firstNumber=new TextField();
  29.         final TextField secondNumber=new TextField();
  30.         final TextField result=new TextField();
  32.         //创建下拉框,测试后，这里用Choice，不用List
  33.         final Choice ch=new Choice();
  34.         ch.add("+");
  35.         ch.add("-");
  36.         ch.add("*");
  37.         ch.add("/");
  38.         //创建按钮
  39.         Button bu=new Button();
  40.         bu.setLabel("计算");
  41. //      //添加标签
  42. //      fr.add(firstLabel);
  43. //      fr.add(secondLabel);
  44. //      fr.add(resultLabel);
  45.         //添加文本框
  46.         fr.add(firstNumber);
  47.         //添加Choice
  48.         fr.add(ch);
  49.         //添加文本框
  50.         fr.add(secondNumber);
  51.         //添加标签
  52.         fr.add(equals);
  53.         //添加文本框
  54.         fr.add(result);
  55.         //添加按钮
  56.         fr.add(bu);
  58.         bu.addActionListener(new ActionListener() {
  60.             @Override
  61.             public void actionPerformed(ActionEvent e) {
  62.                 //获取第一个和第二个运算数
  63.                 String first=firstNumber.getText();
  64.                 int thefirstNumber=Integer.parseInt(first);
  65.                 String second=secondNumber.getText();
  66.                 int thesecondNumber=Integer.parseInt(second);
  68.                 int sum=0;
  69.                 //由于是JDK1.6，不能直接判断字符串，只能判断索引
  70.                 switch(ch.getSelectedIndex()){
  71.                 case 0:
  72.                     sum=thefirstNumber+thesecondNumber;
  73.                     result.setText(Integer.toString(sum));
  74.                     break;
  75.                 case 1:
  76.                     sum=thefirstNumber-thesecondNumber;
  77.                     result.setText(Integer.toString(sum));
  78.                     break;
  79.                 case 2:
  80.                     sum=thefirstNumber*thesecondNumber;
  81.                     result.setText(Integer.toString(sum));
  82.                     break;
  83.                 case 3:
  84.                     sum=thefirstNumber/thesecondNumber;
  85.                     result.setText(Integer.toString(sum));
  86.                     break;                  
  87.                 }
  88.             }
  89.         });
  91.         //设置窗口关闭
  92.         fr.addWindowListener(new WindowAdapter() {
  93.             public void windowClosing(java.awt.event.WindowEvent e) 
  94.             {
  95.                     System.exit(0);
  96.                 };
  97.             }
  98.         );
  99.         //设置窗口可见
  100.         fr.setVisible(true);
  101.     }
  102. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注