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

创建图形化界面：
1，创建frame窗体。
2，对窗体进行基本设置。比如大小，位置，布局。
3，定义组件。
4，将组件通过窗体的add方法添加到窗体中。
5，让窗体显示，通过setVisible(true)

事件监听机制的特点：
1，事件源：就是awt包或者swing包中的那些图形界面组件。
2，事件：每一个事件源都有自己特有的对应事件和共性事件。
3，监听器：将可以触发某一个事件的动作（不只一个动作）都已经封装到了监听器中。
4，事件处理。
我们要做的事情是，就是对产生的动作进行处理。

窗体和按钮结合：

import java.awt.*;
import java.awt.event.*;
class AwtDemo 
{
    public static void main(String[] args) 
    {
        Frame f = new Frame("我的窗体");
        f.setSize(500,400);//设置大小
        f.setLocation(300,150);//设置位置
        f.setLayout(new FlowLayout());//设置布局

        Button b = new Button("按钮");//添加组件
        f.add(b);

        //给窗体添加一个监听器，通过匿名内部类的形式，监听器里面封装的是不同的动作，不同的动作都会对应不同的处理方式
        f.addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)//监听关闭的动作，当这个动作出现后，就会按照定义好的方式处理
            {
                System.out.println("closing");
                System.exit(0);
            }
            public void windowOpened(WindowEvent e)
            {
                System.out.println("opened");
            }
            public void windowActivated(WindowEvent e)
            {
                System.out.println("activated");
            }

        });
        //给按钮添加一个活动监听
        b.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                System.exit(0);
            }
        });
        //这步的设置一定不能忘
        f.setVisible(true);
    }
}

窗体和鼠标，键盘，文本框相结合

import java.awt.*;
import java.awt.event.*;
class MouseAndKeyDemo
{
    public static void main(String[] args) 
    {
        new MouseAndKey().init();
    }
}
class MouseAndKey
{
    private Frame f ;
    private Button b ;
    private TextField tf ;

    public void init()
    {
        f = new Frame("窗体");
        f.setBounds(300,150,500,400);//设置大小和位置
        f.setLayout(new FlowLayout());

        b = new Button("按钮");
        tf = new TextField(30);
        f.add(b);
        f.add(tf);//添加一个文本框

        //可以将对事件的处理封装到一个函数中，方便调用
        event();

        f.setVisible(true);
    }
    public void event()
    {
        f.addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)
            {
                System.exit(0);
            }
        });
        //添加一个鼠标监听，处理点击的动作
        b.addMouseListener(new MouseAdapter()
        {
            int count = 1 ;
            public void mouseClicked(MouseEvent e)
            {
                if(e.getClickCount()==2)
                    System.out.println("双击次数"+count++);
            }
        });
        //添加键盘监听，处理键盘按下的动作
        b.addKeyListener(new KeyAdapter()
        {
            public void keyPressed(KeyEvent e)
            {
                //如果ctrl键和enter键同时按下，就退出
                if(e.isControlDown() && e.getKeyCode()== KeyEvent.VK_ENTER)
                    System.exit(0);
            }
        });

        tf.addKeyListener(new KeyAdapter()
        {
            public void keyPressed(KeyEvent e)
            {
                int code = e.getKeyCode();
                //如果输入的值不在0-9之间，给出提示，并不录入
                if(!(code>=KeyEvent.VK_0 && code<=KeyEvent.VK_9))
                {
                    System.out.println(e.getKeyText(e.getKeyCode())+"字符是非法的");
                    e.consume();
                }
            }
        });
    }
}

做一个自己的窗体：窗体和文本框，文本区域，按钮，标签相结合
在一个文本框中输入目录，点击按钮后，遍历目录并将目录中的内容存放到另一个文本区域中若目录不存在，给出提示
思路：监听按钮，当点击按钮时，将目录中的内容遍历并存到另一个文本区域中
当目录不存在时，弹出一个对话框给出提示

import java.awt.*;
import java.awt.event.*;
import java.io.*;
class MyWindowDemo
{
    private Frame f ;
    private TextField tf ;
    private TextArea ta ;
    private Button b ;
    private Dialog d ;
    private Label l ;
    private Button okb ;

    MyWindowDemo()
    {
        init();
    }
    public void init()
    {
        f = new Frame("窗体");
        f.setBounds(300,150,500,400);
        f.setLayout(new FlowLayout());

        tf = new TextField(30);
        ta = new TextArea(15,60);
        b = new Button("转到");

        f.add(tf);
        f.add(b);
        f.add(ta);

        event();

        f.setVisible(true);
    }

    public void event()
    {
        //按enter键就会将目录遍历
        tf.addKeyListener(new KeyAdapter()
        {
            public void keyPressed(KeyEvent e)
            {
                if(e.getKeyCode()==KeyEvent.VK_ENTER)
                    showDir();
            }
        });
        //点击按钮遍历目录
        b.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                showDir();
            }

        });

        f.addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)
            {
                System.exit(0);
            }
        });
    }
    //会多次用到遍历目录的方法，所以将其封装在函数中
    public 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");
            }
        }
        else // 在目录不存在时，再建立对话框的对象
        {
            //对话框的参数为true，代表不做处理，对话框就不会消失
            d = new Dialog(f,"错误提示",true);
            okb = new Button("确认");
            l = new Label("找不到"+dirPath+"目录，请重输");

            d.setBounds(300,150,300,150);
            d.setLayout(new FlowLayout());

            d.add(l);
            d.add(okb);

            //按确认键（按钮）就会将对话框隐藏
            okb.addActionListener(new ActionListener()
            {
                public void actionPerformed(ActionEvent e)
                {
                    //设置为false，对话框隐藏
                    d.setVisible(false);
                }
            });
            d.addWindowListener(new WindowAdapter()
            {
                public void windowClosing(WindowEvent e)
                {
                    d.setVisible(false);
                }
            });

            d.setVisible(true);//这句话要放在最后
        }   
    }
    public static void main(String[] args) 
    {
        new MyWindowDemo();
    }
}

做一个类似于记事本的软件，它可以双击执行，并可以打开文件，保存文件和关闭
如何制作可以双击执行的jar包呢？
1，将多个类封装到了一个包(package)中。
2，定义一个jar包的配置信息。
定义一个文件a.txt 文件内容内容为：Main-Class:(空格)包名.类名(回车)
3，打jar包。jar -cvfm my.jar a.txt 包名
4，双击jar文件。
注意：打包成jar文件，一定要定义一个包，将class文件都编译到mymenu包中
因为打包为jar文件，是将一个包中的文件连带包一起打包的，所以双击运行时要先找到包，然后再找文件，所以要定义一个包
思路：
文件的打开，保存和关闭
1.创建菜单栏
2.有三个功能，打开，保存，退出
3.做成双击可执行的文件
在保存和关闭时，需要弹出一个对话框，通过查阅API文档，找到了一个对象FileDialog
通过在其创建构造函数时，设置其参数列表可以实现这些功能

import java.io.*;
import java.awt.*;
import java.awt.event.*;
public class MyMenuDemo 
{
    private Frame f ;
    private MenuBar bar ;
    private Menu fileMenu ;
    private MenuItem openItem,saveItem,closeItem ;
    private TextArea ta ;
    private FileDialog openDiag,saveDiag;
    private File file ;

    MyMenuDemo()
    {
        init();
    }
    public void init ()
    {
        f = new Frame("窗体");
        f.setBounds(300,100,800,600);

        bar = new MenuBar();

        fileMenu = new Menu("文件");
        openItem = new MenuItem("打开");
        saveItem = new MenuItem("保存");
        closeItem = new MenuItem("关闭");

        ta = new TextArea();

        f.setMenuBar(bar);//在窗体上创建菜单栏
        bar.add(fileMenu);//添加文件这个菜单
        //添加子菜单
        fileMenu.add(openItem);
        fileMenu.add(saveItem);
        fileMenu.add(closeItem);

        f.add(ta);

        //设置对话框的属性
        openDiag = new FileDialog(f,"打开文件",FileDialog.LOAD);
        saveDiag = new FileDialog(f,"保存文件",FileDialog.SAVE);

        event();

        f.setVisible(true);

    }
    public void event()
    {
        saveItem.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                //保存文件时首先要判断这个文件是否存在，若不存在，需要弹出对话框，然后保存，若存在，则直接保存
                if(file==null)
                {
                    saveDiag.setVisible(true);
                    //弹出对话框后，选择具体的文件保存
                    String dirPath = saveDiag.getDirectory();
                    String fileName = saveDiag.getFile();

                    if(dirPath==null || fileName==null)
                        return ;
                    //将文件和路径封装成对象
                    file = new File(dirPath,fileName);
                }
                BufferedWriter bufw = null ;
                try
                {
                    bufw = new BufferedWriter(new FileWriter(file));
                    //获取文本区域的内容
                    String line = ta.getText();
                    bufw.write(line);
                }
                catch (Exception e2)
                {
                    throw new RuntimeException("写入失败");
                }
                finally
                {
                    try
                    {
                        if(bufw!=null)
                            bufw.close();
                    }
                    catch (Exception e3)
                    {
                        throw new RuntimeException("资源关闭失败");
                    }
                }
            }

        });

        openItem.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                //触发监听器，就会弹出一个可以打开文件的对话框，基于windows
                openDiag.setVisible(true);
                //通过对话框获取具体文件和目录
                String fileName = openDiag.getFile();
                String dirPath = openDiag.getDirectory();
                //若不选择具体的文件和目录直接返回
                if(fileName==null || dirPath==null)
                    return ;
                //选择具体的文件后，将指定目录下的文件封装成文件对象，进行读取
                ta.setText("");//选择了具体的文件后需要把以前的文本区域清空
                file = new File(dirPath,fileName);
                BufferedReader bufr = null;
                try
                {
                    bufr = new BufferedReader(new FileReader(file));
                    String line = null ;
                    while((line=bufr.readLine())!=null)
                    {
                        ta.append(line+"\r\n");
                    }
                }
                catch (Exception e1)
                {
                    throw new RuntimeException("读取失败");
                }
                finally
                {
                    try
                    {
                        if(bufr!=null)
                            bufr.close();
                    }
                    catch (Exception e2)
                    {
                        throw new RuntimeException("资源关闭失败");
                    }
                }
            }
        });
        //退出程序
        closeItem.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                System.exit(0);
            }
        });

        f.addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)
            {
                System.exit(0);
            }

        });
    }
    public static void main(String[] args) 
    {
        new MyMenuDemo();
    }
}

总结：对于图形化界面的操作，我们理解了其基本的思想后，其实就是通过查阅API文档找对象来实现我们想要的功能，这也充分体现了java中面向对象思想的重要性。
对于图形化界面，我们重点要理解事件的监听机制，什么时候需要监听，对于监听的动作我们应该怎样去处理，这个才是重要的。
图形化界面相比Dos命令行对程序的书写较为的复杂，但是操作方便。
其实图形化界面就是把我们需要实现功能的代码封装到了事件的处理中。