黑马程序员——Java基础——GUI

-----------android培训、java培训、java学习型技术博客、期待与您交流！-----------

第一讲　　图形化用户界面

GUI(图形用户界面)
GUI
• Graphical User Interface(图形用户接口)。
• 用图形的方式，来显示计算机操作的界面，这样更方便更直观
CLI
• Command line User Interface (命令行用户接口）
• 就是常见的Dos命令行操作。
• 需要记忆一些常用的命令，操作不直观。

Java为GUI提供的对象都存在java.Awt和javax.Swing两个包中

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

Container常用的子类：Window 　　Panel

Window常用子类：Frame 　　Dialog

二、布局管理器

容器中的组件的排放方式，就是布局。
常见的布局管理器：
• FlowLayout（流式布局管理器）从左到右的顺序排列。flow嘛，跟着走就是流水
　　　　　　　　　　　　　　　　• 　Panel默认的布局管理器。
• BorderLayout（边界布局管理器）board嘛就是打麻将，所以是东西南北中布局
　　　　　　　　　　　　　　　　•      Frame默认的布局管理器。
• GridLayout（网格布局管理器）Brid网格状的
• CardLayout（卡片布局管理器）
• 选项卡
• GridBagLayout（网格包布局管理器）
• 非规则的矩阵

 1 import java.awt.*;
 2 /*创建步骤：
 3  * 1、用Frame创建窗口
 4  * 2、对窗口进行进本操作
 5  *     大小setSize（），位置setLocation（）、布局setLayout
 6  * 3、定义组件（如Button按钮 、Label标签、Checkbox复选框等）
 7  * 4、setVisible(boolean)；显示窗口与否
 8  */
 9 public class AwtDemo {
10     public static void main(String[] args){
11         Frame f=new Frame("水音");//创建
12         f.setSize(500,400);//大小
13         f.setLocation(300,200);//位置
14         f.setLayout(new FlowLayout());//边界布局（桌子打麻将不仅）是默认的，这里改成流式跟班布局
15         
16         Button b=new Button("有压力");
17         f.add(b);//按钮添加在窗口
18         f.setVisible(true);//显示窗口
19     }
20 }

五、事件监听机制：

1、组合：

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

　　2）事件（Event）:每件时间有都有自己特有的对应事件；

　　3）监听器：将可触发某一事件的动作，都封装在监听器中

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

2、使用方法

　　1）确定事件源（容器或组件）。通过事件源对象的addXXXlistener（）方法将监听器注册到该事件源上

如：

f.addWindowListener(new mylis());//主函数引用的方法


//定义一个监听器基础WindowAdapter,并复写7大方法
class mylis extends WindowAdapter {
    public void WindowClosing(){
        System.out.println("关闭按钮被按下");
        System.exit(0);
    }
}

2）然而一般是使用你们匿名内部类方法：

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("开启");
　　}
});

练习：面向对象的思想做一次按钮关闭窗口的监听

 1 import java.awt.*;
 2 import java.awt.event.*;
 3 
 4 class EvenDemo {
 5 //    定义组件按钮和界面
 6     private Frame f=null;
 7     private Button but=null;
 8 //    构造函数让他一new就执行
 9     EvenDemo(){
10         win();
11     }
12 //    定义窗口
13     public void win(){
14         f=new Frame("我是窗口");
15         but=new Button("我是按钮");
16         f.setBounds(250,250,250,250);//设置大小位置
17         f.setLayout(new FlowLayout());//改成流式布局
18 //        f加入but
19         f.add(but);
20         myEvent();
21         f.setVisible(true);
22     }
23 //    定义时间
24     public void myEvent(){
25 //        窗口时间
26         f.addWindowListener(new WindowAdapter() {
27             public void windowClosing(WindowEvent e){
28                 System.exit(0);
29             }    
30         });
31         /*
32          * 那么现在让按钮做时间源的话，选择哪个监听器呢？
33          * 应该在API查阅button的描述，最后找到addActionListener
34          * 
35          */
36         but.addActionListener(new ActionListener(){
37 
38             public void actionPerformed(ActionEvent arg0) {
39                 System.out.println("按钮搞上你");
40                 System.exit(0);
41             }
42         });
43     }    
44     public static void main(String[] args){
45         new EvenDemo();
46     }
47 }

 

练习大全：鼠标（进入、双击、点击），键盘（点击，组合件），文本框（输入，非法输入）的监听

 1 import java.awt.*;
 2 import java.awt.event.*;
 3 class MouseEvent {
 4 //    定义组件按钮和界面
 5     private Frame f=null;
 6     private Button but=null;
 7     private TextField tf;
 8 //    构造函数让他一new就执行
 9     MouseEvent(){
10         win();
11     }
12 //    定义窗口
13     public void win(){
14         f=new Frame("我是窗口");
15         but=new Button("我是按钮");
16         f.setBounds(250,250,250,250);//设置大小位置
17         f.setLayout(new FlowLayout());//改成流式布局
18 //        f加入but
19         tf=new TextField(20);
20         
21         f.add(tf);
22         f.add(but);
23         myEvent();
24         f.setVisible(true);
25     }
26 //    定义时间
27     public void myEvent(){
28 //        窗口时间
29         f.addWindowListener(new WindowAdapter() {//比较多的时候是Adapter
30             public void windowClosing(WindowEvent e){
31                 System.exit(0);
32             }    
33         });
34 //        按钮监听
35         but.addActionListener(new ActionListener(){
36 
37             public void actionPerformed(ActionEvent arg0) {
38                 System.out.println("按钮搞上你");
39 //                System.exit(0);
40             }
41         });
42 //        文本框注意使用的键盘监听
43         tf.addKeyListener(new KeyAdapter() {
44             public void keyPress(KeyEvent e){
45                 int code=e.getKeyCode();
46                 if(!(code>=KeyEvent.VK_0&&code<=KeyEvent.VK_9)){
47                     System.out.println(code+"--非法的");
48                     e.consume();//改变原来的形式，不能输进数据
49                 }
50             }
51         });
52 //        鼠标时需要加装在按钮上的
53         but.addMouseListener(new MouseAdapter(){
54             private int cnt=1;
55             private int cot=1;
56 //            鼠标进入按钮but
57             public void mouseEntered(MouseEvent e){
58                 System.out.println();
59             }
60 //        双击
61             public void mouseClicked(MouseEvent e){
62                 if(e.getClickCount()==2){
63                     System.out.println("双击"+cot++);
64                 }
65             }
66         
67         });
68 //            键盘监听
69         but.addKeyListener(new KeyAdapter(){
70             public void keyPressed(KeyEvent e){
71 //                同时按下这两键发生KeyEvent.VK_ENTER
72                 if(e.isControlDown()&&e.getKeyCode()==KeyEvent.VK_ENTER){
73                     System.out.println("ctrl+enter is run");
74                 }//ctrl被按下且按下另一个键时keyEvent.VK_ENTER就执行xx
75 //                System.out.println(e.getKeyChar()+"--"+e.getKeyCode());            
76             }
77         })    ;
78         
79         
80     }    
81     protected int getClickCount() {
82         // TODO Auto-generated method stub
83         return 0;
84     }
85     public static void main(String[] args){
86         new MouseEvent();
87     }
88 }

 

练习：当文本框出现误操作时，出现提醒的机制

  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.io.*;
  4 
  5 import javax.swing.Action;
  6 
  7 public class MyWindowDemo {
  8 
  9     private Frame f;
 10     private Button b;
 11     private TextField tf;//文本框
 12     private TextArea ta;//文本域
 13     
 14     private Button okb;
 15     private Dialog d;//出错的对话框
 16     private Label lab;//出错的警示语标签
 17     MyWindowDemo(){
 18         win();
 19     }
 20 //    先做窗口
 21     public void win(){
 22         f=new Frame("窗口");
 23         f.setBounds(200,200,600,300);
 24         f.setLayout(new FlowLayout());
 25         
 26         b=new Button("按钮");
 27         
 28         tf=new TextField(30);//30长的文本框
 29 //        
 30         ta=new TextArea(10,40);//高和长
 31         
 32 //        各种添加
 33         f.add(b);
 34         f.add(tf);
 35         f.add(ta);
 36 //        事件发生
 37         event();
 38 //        显示窗口
 39         f.setVisible(true);
 40     }
 41     
 42 //    自定义事件
 43     public void event(){
 44         f.addWindowListener(new WindowAdapter() {
 45             public void windowClosing(WindowEvent e){
 46                 System.exit(0);
 47             }            
 48         });
 49 
 50 //    按钮文本框内容搜索
 51         b.addActionListener(new ActionListener() {
 52             public void actionPerformed(ActionEvent e) {
 53                 showFile();
 54             }            
 55         });
 56 //    文本框按钮enter后事件
 57         tf.addKeyListener(new KeyAdapter(){
 58             public void keyPressed(KeyEvent e){
 59                 if(e.getKeyCode()==KeyEvent.VK_ENTER)
 60                     showFile();
 61             }
 62         });
 63     }    
 64 //    定义一个查看文件的方法
 65     private void showFile(){
 66         ta.setText("");//每次清屏
 67         String str=tf.getText();//得到文本框的值
 68         File dir=new File(str);//创建一个文本框值对应的文件
 69         if(dir.exists()&&dir.isDirectory()){//如果文件且有目录
 70             String[] names=dir.list();//那就遍历下存好
 71             for(String name:names){
 72                 ta.append(name+"\r\n");
 73             }
 74         }else{
 75 //            对话框设置
 76             d=new Dialog(f,"错误信息",true);
 77             d.setBounds(400,200,180,150);
 78             d.setLayout(new FlowLayout());
 79 //            按钮盒标签
 80             okb=new Button("确定");
 81             lab=new Label("输入的信息："+str+"是错误的");
 82             
 83             d.add(okb);
 84             d.add(lab);
 85 //            对话框关闭
 86             d.addWindowListener(new WindowAdapter(){
 87                 public void windowClosing(WindowEvent e){
 88                     d.setVisible(false);//窗体不显示
 89                 }
 90             });
 91 //            对话框的确定按钮
 92             okb.addActionListener(new ActionListener() {
 93                 public void actionPerformed(ActionEvent e) {
 94                     d.setVisible(false);//okb按下后窗体不显示            
 95                 }
 96             });
 97             
 98             d.setVisible(true);
 99         }
100     }
101     
102     public static void main(String[] args){
103         new MyWindowDemo();
104     }
105 }

 

菜单：MenuBar

MenuComponent

　　|-MenuBar:菜单栏，可添加菜单和菜头子条目

　　|-MenuItem：是最终的条目，没有三角标

　　　　|-Menu：菜单，可添加菜单和MenuItem,有三角标

一般对Menu和MenuItem的对象作为事件源添加获得监听ActionListener，并进行事件处理

 

 1 import java.awt.*;
 2 import java.awt.event.*;
 3 
 4 //练习菜单的使用并制作退出时间
 5 public class myMubuDemo {
 6 //定义组件
 7     private Frame fra;
 8     private MenuBar mb;
 9     private Menu m1,m2;
10     private MenuItem close1,subI;
11 //    初始化
12     myMubuDemo(){
13         win();
14     }
15     private void win(){
16 //        窗体
17         fra=new Frame("xxx");
18         fra.setBounds(300,100,500,600);
19         fra.setLayout(new FlowLayout());
20 //        菜单的设置
21         mb=new MenuBar();
22         m1=new Menu("选项1");
23         m2=new Menu("子菜单");
24         
25         close1=new MenuItem("退出");
26         subI=new MenuItem("子条目");
27 //        从小开始添加
28         m2.add(subI);
29         m1.add(m2);
30         m1.add(close1);
31         
32         mb.add(m1);
33 //    注意不是add    窗体添加菜单bar
34         fra.setMenuBar(mb);
35 //        时间发生
36         myEvent();
37         
38         fra.setVisible(true);
39     }
40     private void myEvent() {
41 //        x关闭功能
42         fra.addWindowListener(new WindowAdapter(){
43             public void windowClosing(WindowEvent e){
44                 System.exit(0);
45             }
46         });
47 //        点击MenuItem关闭功能
48         close1.addActionListener(new ActionListener(){
49             public void actionPerformed(ActionEvent arg0) {
50                 System.exit(0);
51             }
52         });
53     }
54     public static void main(String[] args){
55         new myMubuDemo();
56     }
57 }

 

 

以下是j制作一个文本软件和制作Jar包的练习

先制作一个简易的文本软件：

package Menu;
/*需求：制作一个简易的记事本程序
 * 要求：有菜单，文件有打开、保存、退出的功能。还将协会的程序变为可双击执行的程序
 * 
 * 步骤：    一、代码部分
 *            1、我需要new一下构造函数就执行功能，所以各种组件定义在主函数外，由构造
 *              函数启动个功能窗口myWin，有功能窗口启动时间myEvent
 *            2、文件的打开、保存功能由FileDialog实现
 *
 *        二、jar包部分 
 *             以图列展现
 */
import java.awt.*;
import java.awt.event.*;
import java.io.*;

public class MenuText {
//    定义个组件
//    基本组件
    private Frame fra;
    private    MenuBar bar;
    private    Menu fileMe;
    private MenuItem openI,saveI,otherSave,closeI;
    private TextArea ta;//文本域
//    用于保存于另存组件
    private    FileDialog openDia,saveDia,saveDiaa;     
    private    File file;
//    构造函数
    MenuText(){
        myWin();
    }
//    窗口实现
    private void myWin(){
//        搞组件啦
        fra=new Frame("简易文本");
        fra.setBounds(300,150,600,500);
        
        ta=new TextArea();
        bar=new MenuBar();
        fileMe=new Menu("文件");
        openI=new MenuItem("打开");
        saveI=new MenuItem("保存");
        otherSave=new MenuItem("另存为");
        closeI=new MenuItem("退出");
//        用于打开保存文件的组件FileDialog
        openDia = new FileDialog(fra,"选择打开的文件",FileDialog.LOAD);//注意打开的最后参数
        saveDia = new FileDialog(fra,"选择存的文件",FileDialog.SAVE);//注意打开的最后参数
        saveDiaa = new FileDialog(fra,"选择存的文件",FileDialog.SAVE);//注意打开的最后参数
        
        myEvent();
        
//        添加组件
        fileMe.add(openI);
        fileMe.add(saveI);
        fileMe.add(otherSave);
        fileMe.add(closeI);
        
        bar.add(fileMe);
        fra.add(ta);
        fra.setMenuBar(bar);
        
        fra.setVisible(true);
    }
//    事件监听
    private void myEvent(){
//        窗口关闭功能退出关闭和x关闭
        fra.addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                System.out.println("x关闭");
                System.exit(0);
            }
        });
        closeI.addActionListener(new ActionListener(){

            public void actionPerformed(ActionEvent e) {
                System.out.println("退出关闭");
                System.exit(0);
            }
        });
//        打开事件,打开需要使用FileDialog,需要知道文件目录，文件名，需要使用IO
        openI.addActionListener(new ActionListener(){

            public void actionPerformed(ActionEvent e) {
//        显示文件对话框                
                openDia.setVisible(true);
//                需要文件目录与名字
                String di=openDia.getDirectory();
                String fileName=openDia.getFile();
                
                if(di==null||fileName==null)//打开了对话框却没有做操作
                    return;
//                就可以搞一个文件了
                file =new File(di,fileName);//这个就是我们打开的文件
//                一下是使用IO缓冲流惊醒文件传输
                try {
                    ta.setText("");//情况我现在窗口的文字
//                需要用缓冲流读取file在放弃ta里
                    BufferedReader br=
                            new BufferedReader(new FileReader(file));
                    String line=null;
                    while((line=br.readLine())!=null){
                        ta.append(line+"\r\n");
                    }
                    br.close();
                } catch (IOException e2) {
                    throw new RuntimeException("文件打开失败"); 
                }
    
            }            
        });
        
//        保存事件
        saveI.addActionListener(new ActionListener(){

            public void actionPerformed(ActionEvent e1) {
//                如果第一次保存会显示对话框
                if(file==null){
//                    显示对话框
                    saveDia.setVisible(true);
                    String di=saveDia.getDirectory();
                    String fileName=saveDia.getFile();
                    if(di==null||fileName==null)//打开了对话框却没有做操作
                        return;
                    file =new File(di,fileName);//这个就是我们保存的文件
                    
                }
                    save();//保存文件的方法
            }
        });
//        另存事件
        otherSave.addActionListener(new ActionListener(){

            public void actionPerformed(ActionEvent e2) {
//                另存一定有对话框
//                    显示对话框
                saveDiaa.setVisible(true);
//                目录和文件名来自对话框，就是
                String di=saveDiaa.getDirectory();
                String fileName=saveDiaa.getFile();
                
                file =new File(di,fileName);//这个就是我们保存的文件
                
                save();
//                保存时,默认上次打开对话框文件位置
                openDia.setFile(file.getName());
            }
        });
    }
//    保存文件使用IO技术,将窗口的内容写入新的文件中
    private void save(){
        try {
            BufferedWriter bw=//写入file，所以保存和另存的区别在于file的不同
                    new BufferedWriter(new FileWriter(file));
            String line=ta.getText();
            bw.write(line);
//            bw.flush();应该close写在try所以不刷，一般close写在finally就需要刷
            bw.close();
        } catch (IOException e) {
            throw new RuntimeException("文件保存失败");
        }
    }
    
    public static void main(String[] args){
        new MenuText();
    }
    
}

导入Jar的步骤

1、我已经生成了一个包：D:\Java520s\GUI\src\Menu

2、

 

转载于:https://www.cnblogs.com/shuiyinmeizi/p/4180008.html