黑马程序员________Java中GUI编程学习笔记

来源：互联网发布：15套java架构师百度云编辑：程序博客网时间：2024/06/05 12:50

------- android培训、java培训、期待与您交流！ ----------

GUI是Graphical User interface的简写。是用图形的方式，来显示计算机操作的界面，这样更方便直观。Java为GUI提供的对象都存在于java.Awt和移植性更强的Javax.Swing。

容器中的组件以下是他们的继承关系

Container容器： Window窗口：    Frame窗体
                                Dialog对话框： FileDialog文本对话框
                Panel面板
基本组件：      Button按钮
                Label标签
                CheckText复选框
                TextComponent文本组件：     TextField文本框，单行文本
                                            TextArea文本域，多行文本

Container：
   Container类是所有容器类得父类，Container.add()方法用于将组件添加到容器中。
   Container也是Component的子类，因此也可以作为组件增加到其他容器上。

Frame：
    创建一个窗体，建立窗体面板需要用一些方法来设置
    setVisible()设置是否可见
  setSize()设置大小
setLocation()设置位置
setLayout()设置窗体布局

Dialog与FileDialog类：
    Dialog类用于产生对话框，分为模态对话框和非模态对话框。
    public Dialog(Frame owner,String title)
    public Dialog(Frame owner,Stringtitle,boolean modal)

    FileDialog为Dialog的子类，是标准的文件存取对话框。
Panel类是一个容器类，用于产生一种特殊的空白面板，可以容纳其他的组件，但不能独立存在，必须被添加到其他容器中。


TextField类是允许编辑单行文本的文本组件：
    public TextField(int columns) 构造具有指定列数的新空文本字段。
    public TextField(String text) 构造使用指定文本初始化的新文本字段。
    public TextField(String text,int columns) 构造使用要显示的指定文本初始化的新文本    字段，宽度足够容纳指定列数。
TextArea类为多行文本输入框：


容器中的组件的排放方式，就是布局。常见的布局管理器都有FlowLayout（流式布局）、BorderLayout（边界布局）、GridLayout(网络布局)、CardLayout(卡片布局)、GridBagLayout（网格包布局）。

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


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

window事件
处理窗体的事件监听，如右上角的叉号按钮，程序被打开的事件监听。

class AwtDemo
{
public static void main(String[] args)
{
Frame f = new Frame("my awt");
f.setSize(500,400);
f.setLocation(300,200);
f.setLayout(new FlowLayout());

f.addWindowListener(newWindowAdapter()//window适配器覆盖了window监听器的所有方法，我们使用的时候只需要将我们要用到的方法覆盖即可
{
public void windowClosing(WindowEvent e)
   {
    System.out.println("窗口被关闭事件被监听到");
    System.exit(0);
   }

   ublic void windowOpened(WindowEvent e)
   {
    System.out.println("窗口被打开事件事件被监听到");
   }

});

f.setVisible(true);
}
}

Action事件。
处理按钮被菜单被执行的事件监听

importjava.awt.*;
importjava.awt.event.*;

class FrameDemo
{

private Frame f;
private Button but;

FrameDemo()
{
init();//初始设置
}

public void init()
{
f = new Frame("my frame");

f.setBounds(300,100,600,500);//设置窗体位置及大小
f.setLayout(new FlowLayout());

but = new Button("按钮");
f.add(but);//将组件添加到frame中

myEvent();//加载一下窗体上事件。
f.setVisible(true);

}
private void myEvent()
{
f.addWindowListener(new WindowAdapter()//右上角叉号的关闭功能
{
   public void windowClosing(WindowEvent e)
   {
    System.exit(0);
   }
});

but.addActionListener(new ActionListener()
{
   private int count = 1;
   public void actionPerformed(ActionEvent e)
   {
    System.out.println("按钮事件被监听");
    System.exit(0);

   }
});
}

public static void main(String[] args)
{
new FrameDemo();
}
}
运行以上程序，我们可以在控制台上看到程序被关闭我们可以有两种操作方式。按钮的监听器只有一个方法，所以不需要适配器。

鼠标事件和键盘事件。
处理鼠标左键右键，移动位置，离开位置等事件。
以及键盘的按键事件

importjava.awt.*;
importjava.awt.event.*;

classMouseAndKeyEvent
{
private Frame f;
private Button but;
private TextField tf;

MouseAndKeyEvent()
{
init();
}

public void init()
{
f = new Frame("我的窗口");

f.setBounds(300,100,600,500);
f.setLayout(new FlowLayout());
tf = new TextField(20);
but = new Button("我的按钮");
f.add(tf);
f.add(but);

myEvent();

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

tf.addKeyListener(new KeyAdapter()
{
public void keyPressed(KeyEvent e)
{
    int code = e.getKeyCode();
    if(!(code>=KeyEvent.VK_0 &&code<=KeyEvent.VK_9))//KeyCode的值在java中已经定义好了，并且被final修饰，我们直接拿来用就可以
//判断按键是否为0-9之间的数
    {
     System.out.println(code+"是非法的");
     e.consume();//API上解释是不会按照默认的方式由此事件的源代码来处理此事，即不会再tf上显示非法字符
    }
   }
});

but.addKeyListener(new KeyAdapter()//给按钮添加键盘事件监听，这样直接对按钮按回车键就可以触发事件
{
   public void keyPressed(KeyEvent e)
   {
    if(e.isControlDown()&&e.getKeyCode()==KeyEvent.VK_ENTER)
    System.out.println("按回车键了");

   }
});

but.addMouseListener(new MouseAdapter()//鼠标事件，方法较多所以也有适配器
   {
   private int count = 1;
   private int clickCount = 1;
   public void mouseEntered(MouseEvent e) //这个是监听鼠标进入该区域的事件监听
{
    System.out.println("鼠标进入到该组件"+count++);
   }
   public void mouseClicked(MouseEvent e)//监听鼠标点击次数
   {
if(e.getClickCount()==2)//如果是2两次
     System.out.println("双击动作"+clickCount++);
   }
});

}

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

    以下是自己课后写的一个记事本程序。虽然很入门很简单，能正常运行，比较有成就感。

packagemytext;
importjava.awt.*;
importjava.awt.event.*;
importjava.io.*;
publicclass TextDemo
{
    public static void main(String[] args)
    {
        MyText mt=new MyText();
    }
}

classMyText
{
    MyText()
    {
        init();
    }


    private File fileMain;//用来记录所执行的文件，以便保存时是否要弹出对话框输入保存目录
    private Frame fra;
    private TextArea ta;
    private MenuBar mb;
    private Menu menu;
    private MenuItem createItem,loadItem,saveItem,saveMoreItem,exitItem;//四个条目
    private FileDialog loadDialog,saveDialog;

    private void init()
    {
        fra=new Frame("我的记事本");//初始化窗体
            fra.setVisible(true);
            fra.setBounds(30,30,800,600);
            fra.setLayout(new BorderLayout());
        ta=new TextArea();
        mb=new MenuBar();
        menu=new Menu("文件");
        createItem=new MenuItem("新建");//给每个条目在栈内存中分配空间并赋名
        loadItem=new MenuItem("我的打开");
        saveItem=new MenuItem("我的保存");
        saveMoreItem=new MenuItem("我的另存为");
        exitItem=new MenuItem("退出");
        loadDialog=new FileDialog(fra,"我的打开",FileDialog.LOAD);
        saveDialog=new FileDialog(fra,"我的保存",FileDialog.SAVE);

        fra.setMenuBar(mb);// 从属关系
        fra.add(ta);
        mb.add(menu);
        menu.add(createItem);
        menu.add(loadItem);
        menu.add(saveItem);
        menu.add(saveMoreItem);
        menu.add(exitItem);

        setEvent();
    }

    private void setEvent()//添加事件函数
    {


        fra.addWindowListener(newWindowAdapter()//窗体右上角的叉号事件监听用来关闭程序
        {
            public voidwindowClosing(WindowEvent e)
            {
                System.exit(0);
            }
        });

        createItem.addActionListener(newActionListener()//新建条目事件监听
        {
            public voidactionPerformed(ActionEvent e)
            {
                ta.setText("");
            }
        });

        loadItem.addActionListener(newActionListener()//打开条目事件监听
        {
            public voidactionPerformed(ActionEvent e)
            {
                loadDialog.setVisible(true);//打开对话框
                StringdirPath=loadDialog.getDirectory();//将输入信息获取地址
                StringfileName=loadDialog.getFile();//将输入信息获取文件名
                if(dirPath!=null&&fileName!=null)//如果不为空的话避免空指针异常
                {
                    fileMain=newFile(dirPath,fileName);
                    if(fileMain.exists())
                    {
                        ta.setText("");//先将窗体的文本域内字符清空
                        try
                        {
                            BufferedReaderbr=new BufferedReader(new FileReader(fileMain));//用字符流来读取文件中的数据
                            String line=null;
                            while((line=br.readLine())!=null)
                                ta.append(line+"\r\n");
                            br.close();
                        }
                        catch (Exception ex)
                        {
                            throw newRuntimeException ("读取错误");
                        }

                    }
                }
            }
        });

        saveItem.addActionListener(newActionListener()//保存条目的事件监听
        {
            public voidactionPerformed(ActionEvent e)
            {
                if(fileMain==null) //如果所操作的文件没有被操作过的话则fileMain为空
                {
                    loadDialog.setVisible(true);//这样才需要弹出保存对话框，否则直接存储到已知地址
                    StringdirPath=loadDialog.getDirectory();//获取信息
                    StringfileName=loadDialog.getFile();
                    if(dirPath!=null&&fileName!=null)//避免空指针异常
                    {
                        fileMain=newFile(dirPath,fileName);//根据信息创建文件对象
                        try
                        {
                            BufferedWriterbw=new BufferedWriter(new FileWriter(fileMain));// 用字符流在存储到文件中
                            Stringinfo=ta.getText();//获取文本域中的字符串
                            bw.write(info);
                            bw.close();
                        }
                        catch (IOException ex)
                        {
                            throw newRuntimeException("存储错误");
                        }
                    }
                }
                else//否则的话直接存在已知的文件目录中
                {

                    try
                    {
                        BufferedWriter bw=new BufferedWriter(new FileWriter(fileMain));
                        Stringinfo=ta.getText();
                        bw.write(info);
                        bw.close();
                    }
                    catch (IOException ex)
                    {
                        throw newRuntimeException("存储错误");
                    }
                }
            }
        });

        saveMoreItem.addActionListener(newActionListener()//另存为条目的事件监听
        {
            public voidactionPerformed(ActionEvent e)
//其实就是保存条目事件监听中的if(fileMain==null)的情况，就是无论是否该文件目录已被指定，都弹出保存对话框
            {
                loadDialog.setVisible(true);
                StringdirPath=loadDialog.getDirectory();
                StringfileName=loadDialog.getFile();
                if(dirPath!=null&&fileName!=null)
                {
                    File file=newFile(dirPath,fileName);
                    try
                    {
                        BufferedWriter bw=newBufferedWriter(new FileWriter(file));
                        Stringinfo=ta.getText();
                        bw.write(info);
                        bw.close();
                    }
                    catch (IOException ex)
                    {
                        throw newRuntimeException("存储错误");
                    }
                }
            }
        });

        exitItem.addActionListener(newActionListener()//退出条目的事件监听
        {
            public voidactionPerformed(ActionEvent e)
            {
                System.exit(0);
            }
        });

    }

}