java基础学习_GUI_如何让Netbeans的东西Eclipse能访问、GUI(图形用户接口)

java基础学习_GUI_如何让Netbeans的东西Eclipse能访问、GUI(图形用户接口)_day25总结

=============================================================================
=============================================================================
涉及到的知识点有：
    1:如何让Netbeans的东西Eclipse能访问?
    2:GUI(图形用户接口)(了解)
        (1)GUI的概述
        (2)两个包：
        (3)GUI的继承体系图
        (4)事件监听机制(理解)
        (5)适配器模式(理解)
        (6)案例：
        (7)Netbeans的概述和使用
=============================================================================
=============================================================================
1:如何让Netbeans的东西Eclipse能访问?
    在Eclipse中创建项目，把Netbeans项目的src下的东西给拿过来即可。
    注意：修改项目编码为UTF-8
-----------------------------------------------------------------------------    
2:GUI(图形用户接口)(了解)
    (1)GUI的概述
        GUI：Graphical User Interface(图形用户接口)
            用图形的方式，来显示计算机操作的界面，这样更方便更直观。
        CLI：Command line User Interface(命令行用户接口）
        
        GUI：方便直观。
        CLI：需要记忆一些命令，麻烦不直观。
        
        Java为GUI提供的对象都存在java.awt和javax.swing两个包中。
            java：为java的标准包。
            javac：为java的扩展包。
--------------------------------------
    (2)两个包：
        java.awt：Abstract Window ToolKit(抽象窗口工具包)，需要调用本地系统方法实现功能，属重量级控件。(和系统关联较强)
        javax.swing：在AWT的基础上，建立的一套图形界面系统，其中提供了更多的组件，而且完全由Java实现。增强了移植性，属轻量级控件。(纯Java编写)
    (3)GUI的继承体系图
        组件：组件就是对象。
            容器组件：是可以存储基本组件和容器组件的组件。
            基本组件：是可以使用的组件，但必须依赖容器组件。
            
        注意：
            由于Component、Container、Window类的方法太多太多了，
            所以我们学习Frame、Dialog、FileDialog类。
            
        Java中GUI的继承体系图如下图所示：
--------------------------------------
    (4)事件监听机制(理解)
        A:事件源　　　　　事件发生的地方
        B:事件　　　　　　要发生的事情
        C:事件处理　　　　针对发生的事情做出的处理方案
        D:事件监听　　　　把事件源和事件关联起来
    (5)适配器模式(理解)
        当你自己写的类中想用某个接口中个别方法的时候(注意：不是所有的方法)，肿么办？
        那么你就可以用一个抽象类先实现这个接口(注意：仅仅是空实现:方法体为空)，然后再用你的类继承这个抽象类，在你的类中用哪个方法就实现哪个方法，这样就可以达到目的了；
        如果你直接用类实现接口，那接口的所有方法都必须实现的。
        A:接口
        B:抽象适配器类
        C:实现类

 1 package cn.itcast_03;
 2 
 3 /*
 4  * 针对用户操作的四种功能的接口
 5  */
 6 public interface UserDao {
 7     public abstract void add();
 8 
 9     public abstract void delete();
10 
11     public abstract void update();
12 
13     public abstract void find();
14 }

接口

 1 package cn.itcast_03;
 2 
 3 public abstract class UserAdapter implements UserDao {
 4 
 5     @Override
 6     public void add() {
 7     }
 8 
 9     @Override
10     public void delete() {
11     }
12 
13     @Override
14     public void update() {
15     }
16 
17     @Override
18     public void find() {
19     }
20 
21 }

抽象适配器类

1 package cn.itcast_03;
2 
3 public class UserDaoImpl2 extends UserAdapter {
4     @Override
5     public void add() {
6         System.out.println("添加功能");
7     }
8 
9 }

实现类

 1 package cn.itcast_03;
 2 
 3 /*
 4  * 问题：
 5  *         接口(方法比较多) --> 实现类(我仅仅是使用其中的一个方法，也得把其他的方法给实现了，哪怕是空实现)
 6  *         太麻烦了。
 7  * 解决方案：
 8  *         接口(方法比较多) --> 适配器类(实现接口，仅仅是空实现:方法体为空) --> 实现类(用哪个方法就重写哪个方法)
 9  */
10 public class UserDaoTest {
11     public static void main(String[] args) {
12         UserDao ud = new UserDaoImpl();
13         ud.add();
14         // 该实现类里面实现了四种功能，我仅仅使用一种功能，可是我并不需要实现这么多功能啊！肿么办？
15         
16         UserDao ud2 = new UserDaoImpl2();
17         ud2.add();
18     }
19 }

测试类

    (6)案例：
        A:创建窗体案例
        B:窗体关闭案例
            示例代码如下：

 1 package cn.itcast_02;
 2 
 3 import java.awt.Frame;
 4 import java.awt.event.WindowAdapter;
 5 import java.awt.event.WindowEvent;
 6 import java.awt.event.WindowListener;
 7 
 8 public class FrameDemo {
 9     public static void main(String[] args) {
10         // 创建窗体对象
11         Frame f = new Frame("窗体关闭案例");
12 
13         // 设置窗体属性(位置和大小)
14         f.setBounds(400, 200, 400, 300);
15 
16         // 让窗体关闭
17         // 事件源：窗体
18         // 事件：对窗体的处理(接口)
19         // 事件处理：关闭窗口(System.exit(0));
20         // 事件监听
21         
22         /*
23         f.addWindowListener(new WindowListener() {
24             @Override
25             public void windowOpened(WindowEvent e) {
26             }
27             
28             @Override
29             public void windowIconified(WindowEvent e) {
30             }
31             
32             @Override
33             public void windowDeiconified(WindowEvent e) {
34             }
35             
36             @Override
37             public void windowDeactivated(WindowEvent e) {
38             }
39             
40             @Override
41             public void windowClosing(WindowEvent e) {
42                 System.exit(0);
43             }
44             
45             @Override
46             public void windowClosed(WindowEvent e) {
47             }
48             
49             @Override
50             public void windowActivated(WindowEvent e) {
51             }
52         });
53         */
54         
55         // WindowListener接口 --> WindowAdapter抽象实现类(适配器类) --> 具体的实现类(WindowAdapter抽象实现类的匿名内部类)
56         // 用适配器类改进
57         f.addWindowListener(new WindowAdapter() {
58             @Override
59             public void windowClosing(WindowEvent e) {
60                 System.exit(0);
61             }
62         });
63 
64         // 设置窗体可显示
65         f.setVisible(true);
66     }
67 }

窗体关闭案例

        C:窗体添加按钮并对按钮添加事件案例
            窗体布局方案如下图所示：
            示例代码如下：

 1 package cn.itcast_04;
 2 
 3 import java.awt.Button;
 4 import java.awt.FlowLayout;
 5 import java.awt.Frame;
 6 import java.awt.event.ActionEvent;
 7 import java.awt.event.ActionListener;
 8 import java.awt.event.WindowAdapter;
 9 import java.awt.event.WindowEvent;
10 
11 /*
12  * 需求：把按钮添加到窗体，并对按钮添加一个点击事件。
13  *         A:创建窗体对象
14  *         B:创建按钮对象
15  *         C:把按钮添加到窗体
16  *         D:设置窗体可关闭
17  *         E:设置按钮可点击
18  *         F:设置窗体可显示
19  */
20 public class FrameDemo {
21     public static void main(String[] args) {
22         // 创建窗体对象
23         Frame f = new Frame("添加按钮");
24         // 设置窗体属性(位置和大小)
25         f.setBounds(400, 200, 400, 300);
26         // 设置窗体布局为流式布局(Frame窗体布局默认为边界布局)
27         f.setLayout(new FlowLayout());
28 
29         // 创建按钮对象
30         Button bu = new Button("clock me");
31         
32         // 把按钮添加到窗体
33         f.add(bu);
34 
35         // WindowListener接口 --> WindowAdapter抽象实现类(适配器类) --> 具体的实现类(WindowAdapter抽象实现类的匿名内部类)
36         // 设置窗体可关闭
37         f.addWindowListener(new WindowAdapter() {
38             @Override
39             public void windowClosing(WindowEvent e) {
40                 System.exit(0);
41             }
42         });
43 
44         // ActionListener接口 --> 具体的实现类(ActionListener接口的匿名内部类)    因为该接口中只有一个方法
45         // 对按钮添加事件
46         bu.addActionListener(new ActionListener() {
47             @Override
48             public void actionPerformed(ActionEvent e) {
49                 System.out.println("你再点试试");
50             }
51         });
52 
53         // 设置窗体可显示
54         f.setVisible(true);
55     }
56 }

把按钮添加到窗体，并对按钮添加一个点击事件

        D:把文本框里面的数据转移到文本域
            示例代码如下：

 1 package cn.itcast_05;
 2 
 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;
12 
13 public class FrameDemo {
14     public static void main(String[] args) {
15         // 创建窗体对象
16         Frame f = new Frame("数据转移");
17         // 设置窗体属性和布局
18         f.setBounds(400, 200, 400, 300);
19         f.setLayout(new FlowLayout());
20 
21         // 创建文本框对象
22         final TextField tf = new TextField(20);
23         // 创建按钮对象
24         Button bu = new Button("database move");
25         // 创建文本域对象
26         final TextArea ta = new TextArea(10, 40);
27 
28         // 把组件添加到窗体
29         f.add(tf);
30         f.add(bu);
31         f.add(ta);
32 
33         // 设置窗体可关闭
34         f.addWindowListener(new WindowAdapter() {
35             @Override
36             public void windowClosing(WindowEvent e) {
37                 System.exit(0);
38             }
39         });
40 
41         // 对按钮添加事件
42         bu.addActionListener(new ActionListener() {
43             @Override
44             public void actionPerformed(ActionEvent e) {
45                 // 获取文本框数据(去前后空格)
46                 String tf_str = tf.getText().trim(); // 局部内部类访问局部变量，局部变量需要用final修饰
47                 // 清空文本框数据
48                 tf.setText("");
49 
50                 // 把文本框数据设置给文本域
51                 // ta.setText(tf_str);
52                 // 追加和换行
53                 ta.append(tf_str + "\r\n");
54                 
55                 // 获取光标
56                 tf.requestFocus();
57             }
58         });
59 
60         // 设置窗体可显示
61         f.setVisible(true);
62     }
63 }

把文本框里面的数据转移到文本域

        E:更改背景色
            示例代码如下：

  1 package cn.itcast_06;
  2 
  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.MouseAdapter;
  8 import java.awt.event.MouseEvent;
  9 import java.awt.event.WindowAdapter;
 10 import java.awt.event.WindowEvent;
 11 
 12 public class FrameDemo {
 13     public static void main(String[] args) {
 14         // 创建窗体对象
 15         final Frame f = new Frame("更改背景色");
 16         // 设置窗体属性和布局
 17         f.setBounds(400, 200, 400, 300);
 18         f.setLayout(new FlowLayout());
 19 
 20         // 创建四个按钮对象
 21         Button redButton = new Button("red");
 22         Button greenButton = new Button("green");
 23         Button buleButton = new Button("blue");
 24 
 25         // 把按钮添加到窗体
 26         f.add(redButton);
 27         f.add(greenButton);
 28         f.add(buleButton);
 29 
 30         // 设置窗体可关闭
 31         f.addWindowListener(new WindowAdapter() {
 32             @Override
 33             public void windowClosing(WindowEvent e) {
 34                 System.exit(0);
 35             }
 36         });
 37 
 38         /*
 39         // 对按钮添加动作事件
 40         redButton.addActionListener(new ActionListener() {
 41             @Override
 42             public void actionPerformed(ActionEvent e) {
 43                 f.setBackground(Color.RED);
 44             }
 45         });
 46 
 47         // 对按钮添加鼠标点击事件
 48         redButton.addMouseListener(new MouseAdapter() {
 49             @Override
 50             public void mouseClicked(MouseEvent e) {
 51                 f.setBackground(Color.RED);
 52             }
 53         });
 54         */
 55 
 56         // 对按钮添加鼠标进入和离开事件
 57         redButton.addMouseListener(new MouseAdapter() {
 58             @Override
 59             public void mouseEntered(MouseEvent e) {
 60                 f.setBackground(Color.RED);
 61             }
 62         });
 63 
 64         redButton.addMouseListener(new MouseAdapter() {
 65             @Override
 66             public void mouseExited(MouseEvent e) {
 67                 f.setBackground(Color.WHITE);
 68             }
 69         });
 70         
 71         // 对按钮添加鼠标进入和离开事件
 72         greenButton.addMouseListener(new MouseAdapter() {
 73             @Override
 74             public void mouseEntered(MouseEvent e) {
 75                 f.setBackground(Color.GREEN);
 76             }
 77         });
 78 
 79         greenButton.addMouseListener(new MouseAdapter() {
 80             @Override
 81             public void mouseExited(MouseEvent e) {
 82                 f.setBackground(Color.WHITE);
 83             }
 84         });
 85         
 86         // 对按钮添加鼠标进入和离开事件
 87         buleButton.addMouseListener(new MouseAdapter() {
 88             @Override
 89             public void mouseEntered(MouseEvent e) {
 90                 f.setBackground(Color.BLUE);
 91             }
 92         });
 93 
 94         buleButton.addMouseListener(new MouseAdapter() {
 95             @Override
 96             public void mouseExited(MouseEvent e) {
 97                 f.setBackground(Color.WHITE);
 98             }
 99         });
100 
101         // 设置窗体可显示
102         f.setVisible(true);
103     }
104 }

更改背景色

        F:设置文本框里面不能输入非数字字符
            示例代码如下：

 1 package cn.itcast_07;
 2 
 3 import java.awt.FlowLayout;
 4 import java.awt.Frame;
 5 import java.awt.Label;
 6 import java.awt.TextField;
 7 import java.awt.event.KeyAdapter;
 8 import java.awt.event.KeyEvent;
 9 import java.awt.event.WindowAdapter;
10 import java.awt.event.WindowEvent;
11 
12 /*
13  * 你输入的如果是非数字字符，就取消你键盘录入的效果。
14  */
15 public class FrameDemo {
16     public static void main(String[] args) {
17         // 创建窗体对象并设置属性和布局
18         Frame f = new Frame("不能输入非数字字符");
19         f.setBounds(400, 200, 400, 300);
20         f.setLayout(new FlowLayout());
21 
22         // 创建标签对象和文本框对象
23         Label label = new Label("请输入你的QQ号码，不能是非数字，不信你试试");
24         TextField tf = new TextField(40);
25 
26         // 把标签和文本框添加到窗体
27         f.add(label);
28         f.add(tf);
29 
30         // 设置窗体可关闭
31         f.addWindowListener(new WindowAdapter() {
32             @Override
33             public void windowClosing(WindowEvent e) {
34                 System.exit(0);
35             }
36         });
37 
38         // 对文本框添加事件
39         tf.addKeyListener(new KeyAdapter() {
40             @Override
41             public void keyPressed(KeyEvent e) {
42                 // 思路：先获取字符，再判断字符，取消事件
43                 // KeyEvent类的方法：public char getKeyChar()  
44                 char ch = e.getKeyChar();
45                 if(!(ch>='0' && ch<='9')){
46                     e.consume(); // 取消事件
47                 }
48             }
49         });
50 
51         // 设置窗体可显示
52         f.setVisible(true);
53     }
54 }

设置文本框里面不能输入非数字字符

        G:一级菜单
            菜单组件图：
            示例代码如下：

 1 package cn.itcast_08;
 2 
 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 
13 /*
14  * 一级菜单
15  */
16 public class FrameDemo {
17     public static void main(String[] args) {
18         // 创建窗体对象并设置属性和布局
19         Frame f = new Frame("一级菜单");
20         f.setBounds(400, 200, 400, 300);
21         f.setLayout(new FlowLayout());
22 
23         // 创建菜单栏对象
24         MenuBar mb = new MenuBar();
25         // 创建菜单对象
26         Menu m = new Menu("File");
27         // 创建菜单项对象
28         MenuItem mi = new MenuItem("Exit");
29 
30         // 把菜单项添加到菜单，把菜单添加到菜单栏
31         m.add(mi);
32         mb.add(m);
33 
34         // 把菜单栏添加到窗体
35         f.setMenuBar(mb);
36 
37         // 设置窗体可关闭
38         f.addWindowListener(new WindowAdapter() {
39             @Override
40             public void windowClosing(WindowEvent e) {
41                 System.exit(0);
42             }
43         });
44 
45         // 对菜单项添加事件
46         mi.addActionListener(new ActionListener() {
47             @Override
48             public void actionPerformed(ActionEvent e) {
49                 System.exit(0);
50             }
51         });
52 
53         // 设置窗体可显示
54         f.setVisible(true);
55     }
56 }

一级菜单

        H:多级菜单
            示例代码如下：

  1 package cn.itcast_09;
  2 
  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;
 13 
 14 /*
 15  * 多级菜单
 16  */
 17 public class FrameDemo {
 18     public static void main(String[] args) {
 19         // 创建窗体对象并设置属性和布局
 20         final Frame f = new Frame("多级菜单");
 21         f.setBounds(400, 200, 400, 300);
 22         f.setLayout(new FlowLayout());
 23         
 24         final String name = f.getTitle(); // 获取窗体标题(该量多处使用)
 25 
 26         // 创建菜单栏对象
 27         MenuBar mb = new MenuBar();
 28         // 创建菜单对象
 29         Menu m1 = new Menu("文件");
 30         Menu m2 = new Menu("更改名称");
 31         // 创建菜单项对象
 32         final MenuItem mi1 = new MenuItem("好好学习");
 33         final MenuItem mi2 = new MenuItem("天天向上");
 34         MenuItem mi3 = new MenuItem("恢复标题");
 35         MenuItem mi4 = new MenuItem("打开记事本");
 36         MenuItem mi5 = new MenuItem("退出系统");
 37 
 38         // 把菜单项添加到菜单，把菜单添加到菜单栏
 39         m2.add(mi1);
 40         m2.add(mi2);
 41         m2.add(mi3);
 42         
 43         m1.add(m2);
 44         m1.add(mi4);
 45         m1.add(mi5);
 46         
 47         mb.add(m1);
 48 
 49         // 把菜单栏添加到窗体
 50         f.setMenuBar(mb);
 51 
 52         // 设置窗体可关闭
 53         f.addWindowListener(new WindowAdapter() {
 54             @Override
 55             public void windowClosing(WindowEvent e) {
 56                 System.exit(0);
 57             }
 58         });
 59         
 60         mi1.addActionListener(new ActionListener() {
 61             @Override
 62             public void actionPerformed(ActionEvent e) {
 63                 f.setTitle(mi1.getLabel()); // 获取此菜单项的标签    局部内部类访问局部变量，局部变量需要用final修饰
 64             }
 65         });
 66         
 67         mi2.addActionListener(new ActionListener() {
 68             @Override
 69             public void actionPerformed(ActionEvent e) {
 70                 f.setTitle(mi2.getLabel()); // 获取此菜单项的标签    局部内部类访问局部变量，局部变量需要用final修饰
 71             }
 72         });
 73         
 74         mi3.addActionListener(new ActionListener() {
 75             @Override
 76             public void actionPerformed(ActionEvent e) {
 77                 f.setTitle(name); // 局部内部类访问局部变量，局部变量需要用final修饰
 78             }
 79         });
 80         
 81         mi4.addActionListener(new ActionListener() {
 82             @Override
 83             public void actionPerformed(ActionEvent e) {
 84                 Runtime r = Runtime.getRuntime(); // 可以通过getRuntime()方法获取当前运行时对象
 85                 try {
 86                     r.exec("notepad");
 87                 } catch (IOException e1) {
 88                     e1.printStackTrace();
 89                 }
 90             }
 91         });
 92         
 93         // 对菜单项添加事件
 94         mi5.addActionListener(new ActionListener() {
 95             @Override
 96             public void actionPerformed(ActionEvent e) {
 97                 System.exit(0);
 98             }
 99         });
100 
101         // 设置窗体可显示
102         f.setVisible(true);
103     }
104 }

多级菜单




(7)Netbeans的概述和使用
        A:Netbeans的概述
            是可以做Java开发的另一个IDE工具。
        B:Netbeans的使用
            1:四则运算
                a:修改窗体图标
                b:设置窗体居中
                c:设置窗体皮肤
                d:数据校验
            2:登录注册GUI版
=============================================================================