java基础GUI

最新推荐文章于 2024-06-15 08:47:22 发布

搬砖小弟

最新推荐文章于 2024-06-15 08:47:22 发布

阅读量609

点赞数 1

分类专栏： java基础文章标签： gui

本文链接：https://blog.csdn.net/u012954195/article/details/46553165

版权

java基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

第一部分 GUI（用户图形界面）
一、概述
1、GUI：GraphicalUser Interface，即图形用户界面，用于计算机与用户交互的一种方式。
2、计算机与用户交互的两种方式：GUI和CLI
GUI： Graphical User Interface，图形用户接口，用图形方式，来显示计算机操作界面，方便直观。
CLI： Command LineUser Interface，命令行用户接口，即常见的Dos命令行操作，须记住一些命令，操作不直观。
3、java也将这种界面封装为对象，其中的对象都放在了两个包中：java.Awt包和javax.Swing包。
java.Awt包：Abstract Window Toolkit，即抽象窗口工具包。要调用本地系统方法实现功能，属重量级控件。
javax.Swing包：在AWT的基础上建立的一套图形界面系统，其中提供了更多的组件，且完全由java实现，增强了移植性，属轻量级控件。
二、继承关系图
这里写图片描述
Container：为容器，是一个特殊的组件，该组件中可以通过add方法添加其他组件进来。
Container常用子类：Window Panel（面板，不能单独存在。）
Window常用子类：Frame Dialog
三、布局管理器
1、布局：容器中的组件排列方式
2、常见的布局管理器：
1）FlowLayout：流式布局管理器。从左向右排列，是Panel默认的布局管理器
2）BorderLayout：边界式布局管理器，东南西北中的排列方式，是Frame的默认布局管理器。如果窗体中只有一个组件，将会覆盖整个窗体。
3）GridLayout：网格式布局管理器，规则的矩阵
4）CardLayout：卡片式布局管理器，即选项卡
5）GridBayLayout：网格包布局管理器，非规则矩阵
3、如果存在多种布局方式，如何创建窗体界面呢？步骤：
1）先将窗体Frame进行大区域的划分，设置其布局管理器，加入面板Panel
2）将组件加入Panel，设置面板的布局管理器。

四、简单的窗体创建过程
1、创建Frame窗体：
Frame f = new Frame(“my Frame”);//可设置标题，即窗体名字
2、对窗体进行基本设置：如大小，位置，布局等：
f.setSize(int wight,int hight);//窗体大小设置
f.setLocation(int x,int y);//窗体显示位置设置，横纵坐标
f.setBounds(int x,int y,int wight,int hight)，也可以直接用这个方法对大小和位置设置
f.setLayout(Layout layout)，参数为指定的布局管理器，如FlowLayout
3、定义组件：
如Button b = new Button(“my Button”);//可设置组件的名称
4、将组件通过窗体的add方法添加到窗体中：
f.add(b);//将按钮组件添加进窗体
5、让窗体显示：
f.setVisible(boolean b);//通过设置参数是true还是false是否显示窗体
示例：

package awt;

import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

/*
 * 创建图形化界面
 * 1、创建frame窗体
 * 2、对窗体进行基本设置
 * 比如大小，位置，布局
 * 3、定义组件
 * 4、将组件通过窗口add方法添加到窗体中
 * 5、让窗体显示，通过setvisible（true）
 */
public class AwtDemo {

    public static void main(String[] args) {
        Frame f=new Frame("my awt");
        f.setSize(500, 400);
        f.setLocation(300,300);//设置窗口位置
        f.setLayout(new FlowLayout());//设置为流布局
        Button b=new Button("按钮");
        f.add(b);
        //添加关闭监视器
        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("我被打开了，哈哈哈");
            }
        });
        //让窗口可视化
        f.setVisible(true);
    }

}

五、事件监听机制
1、组成：
1）事件源（组件）：awt或swing包中的那些图形界面组件
2）事件（Event）：每一个事件源都有自己特有的对应事件和共性事件
3）监听器（Listener）：将可触发某一事件的动作（不只一个动作），都封装到侦听器中。
4）事件处理：引发事件后的处理方式。
这里写图片描述
2、使用说明
组成的前三个在java中都已将定义好了，直接获取其对象来用即可，我们需要做的就是对产生的动作进行处理。
步骤：
1）确定事件源（容器或组件）。通过事件源对象的addXXXListener()方法将监听器注册到该事件源上。该方法中接收XXXListener的子类对象，或者XXXListener的子类XXXAdapter的子类对象。
2）一般用匿名内部类来表示。在覆盖方法的时候，方法的参数一般是XXXEvent类型的变量接收。
示例：

package awt;

import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;


public class FrameDemo {
    //定义该图形中所需的组件引用
    private Frame f;
    private Button but;

    FrameDemo(){
        init();
    }
    public void init(){
        //对frame进行基本设置
        f=new Frame("my frame");
        f.setBounds(300, 200, 500, 400);
        f.setLayout(new FlowLayout());
        //添加组件到Frame
        but=new Button("my button");
        f.add(but);
        //加载窗口事件
        myEvent();
        //显示窗口
        f.setVisible(true);
    }
    public void myEvent(){
        f.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e){
                System.exit(0);
            }
        });
        //让按钮具有退出功能
        but.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                System.out.println("按钮干的");
                System.exit(0);
            }
        });
    }
    public static void main(String[] args) {
        new FrameDemo();
    }
}

说明：
1）事件触发后会把事件打包成对象传递给复写方法中参数的变量。（其中包括事件源对象。通过getSource()或者，getComponent()获取。）
2）若用子类实现WindowListener接口，就需要覆盖其中的7个方法，可只用到其中的关闭动作，其他动作未用到，但却必须重写全部。因为WindowLister的子类WindowAdapter（适配器）已经实现此接口，并覆盖了其中所有方法。那么只需继承WindowAdapter，覆盖需要的方法即可。
3）明确事件，并对事件进行处理，其实，添加什么监听器就需要添加什么事件。
练习：

package awt;
/*
 * 鼠标和键盘
 */
import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class MouseandKeyDemo {
    //定义该图形中所需的组件引用
        private Frame f;
        private Button but;
        private TextField tf;
        MouseandKeyDemo(){
            init();
        }
        public void init(){
            //对frame进行基本设置
            f=new Frame("my frame");
            f.setBounds(300, 200, 500, 400);
            f.setLayout(new FlowLayout());
            //添加组件到Frame
            tf=new TextField(20);
            f.add(tf);
            but=new Button("my button");
            f.add(but);
            //加载窗口事件
            myEvent();
            //显示窗口
            f.setVisible(true);
        }
        public void myEvent(){
            f.addWindowListener(new WindowAdapter() {
                public void windowClosing(WindowEvent e){
                    System.exit(0);
                }
            });
            //给Button加事件监听器
            but.addActionListener(new ActionListener() {

                public void actionPerformed(ActionEvent e) {
                    System.out.println("action ok");
                }
            });
            //给Button加鼠标监听器
            but.addMouseListener(new MouseAdapter() {
                int count=1;
                int clickcount=1;
                public void mouseEntered(MouseEvent e){
                    System.out.println("鼠标进入组件"+count++);
                }
                public void mouseClicked(MouseEvent e){
                    if (e.getClickCount()==2) {
                        System.out.println("鼠标点击两次"+clickcount++);
                    }
                }
            });
            //给Button加键盘监听器
            but.addKeyListener(new KeyAdapter() {
                public void keyPressed(KeyEvent e){
                    if (e.isControlDown()&&e.getKeyCode()==KeyEvent.VK_ENTER) {
                        System.out.println("Ctrl+enter run");
                    }
                }
            });
            //给TextFiled加键盘监听器
            tf.addKeyListener(new KeyAdapter() {
                public void keyPressed(KeyEvent e){
                    int code=e.getKeyCode();
                    if (!(code>=KeyEvent.VK_0&&code<=KeyEvent.VK_9)) {
                        System.out.println("输入非法");
                        e.consume();
                    }
                }
            });
        }
    public static void main(String[] args) {
        new MouseandKeyDemo();
    }

}

第二部分应用
一、对话框：Dialog
何时需要产生对话框：此对象时需要在调用时，才创建对象。如：当在误操作的时候，就需要出现提示错误信息的对话框，此时才创建的这个对象。
示例：
对列出指定目录内容示例的功能增强。
示例：

package awt;

import java.awt.Button;
import java.awt.Dialog;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Label;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;

public class MyWindow {
    //创建一个窗口所需的组件
    private Frame f;
    private TextField tf;
    private Button but;
    private TextArea ta;
    //错误提示窗口组件
    private Dialog d;
    private Label l;
    private Button b;
    //构造器
    public MyWindow() {
        init();
    }
    public void init(){
        //设置窗口
        f=new Frame("my window");
        f.setBounds(300, 100, 600, 500);
        f.setLayout(new FlowLayout());

        d=new Dialog(f, "错误提示：", true);
        d.setBounds(400, 200, 240, 150);
        d.setLayout(new FlowLayout());
        //设置组件
        tf=new TextField(60);
        but=new Button("转到");
        ta=new TextArea(25, 70);

        l=new Label();
        b=new Button("确定");
        //添加组件
        f.add(tf);
        f.add(but);
        f.add(ta);

        d.add(l);
        d.add(b);
        //事件监听
        myEvent();
        //可视化
        f.setVisible(true);
    }
    //添加事件监视器
    public void myEvent(){

        d.addWindowListener(new WindowAdapter() {

            public void windowClosing(WindowEvent e){
                d.setVisible(false);
            }
        });
        b.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                // TODO Auto-generated method stub
                d.setVisible(false);
            }

        });
        tf.addKeyListener(new KeyAdapter() {

            public void keyPressed(KeyEvent e){
                if (e.getKeyCode()==KeyEvent.VK_ENTER) {
                    show();
                }
            }
        });
        //窗口关闭功能
        f.addWindowListener(new WindowAdapter() {

            public void windowClosing(WindowEvent e){
                System.exit(0);
            }
        });
        //Button设置事件监听器
        but.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                 show();
            }
        });

    }

    public void show(){
        String dirpath=tf.getText();
        File f=new File(dirpath);
        if (f.exists()&&f.isDirectory()) {
            ta.setText("");
            String[] names=f.list();
            for (String name : names) {
                ta.append(name+"\r\n");
            }
        }else {
            l.setText(tf.getText()+"输入错误，请重新输入");
            d.setVisible(true);
        }

    }

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

}

二、菜单：Menu
1、菜单继承关系
这里写图片描述
2、说明
1）Menu：菜单，继承MenuItem；有右三角的图标存在，可添加Menu和MenuItem
2）MenuBar：菜单栏，可添加菜单和菜单条目。一般先创建菜单栏，再创建菜单。
3）MenuItem：菜单条目，也称菜单项，无右三角的图标存在，是最终的菜单项。
4）菜单的事件处理和组件一样，可以对类型为MenuItem和Menu的对象这个事件源添加活动监听ActionListener，并进行相关的事件处理。
5）通过setMenuBar()方法，将菜单添加到Frame中。
示例：

package awt;

import java.awt.FileDialog;
import java.awt.Frame;
import java.awt.Menu;
import java.awt.MenuBar;
import java.awt.MenuItem;
import java.awt.TextArea;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class MyMeuneTest {

    private Frame f; 
    private TextArea ta;
    private FileDialog openDialog;
    private FileDialog saveDialog;
    private Menu fileMenu;
    private MenuBar bar;
    private MenuItem openItem,saveItem,closeItem;
    private File file=null;
    private BufferedReader br=null;
    private BufferedWriter bw=null;

    public MyMeuneTest() {
        init();
    }

    public void init(){

        //设置窗口
        f=new Frame("my window");
        ta=new TextArea();
        f.setBounds(300, 100, 650, 600);
        //设置打开对话框
        openDialog=new FileDialog(f, "我要打开", FileDialog.LOAD);
        saveDialog=new FileDialog(f, "我要保存", FileDialog.SAVE);


        //设置菜单栏
        bar=new MenuBar();
        fileMenu=new Menu("文件");
        openItem=new MenuItem("打开");
        saveItem=new MenuItem("保存");
        closeItem=new MenuItem("退出");


        fileMenu.add(openItem);
        fileMenu.add(saveItem);
        fileMenu.add(closeItem);

        bar.add(fileMenu);

        //加载事件
        myEvent();
        //将菜单栏添加到Frame中
        f.setMenuBar(bar);
        f.add(ta);
        f.setVisible(true);

    }

    public void myEvent(){

        saveItem.addActionListener(new ActionListener() {


            public void actionPerformed(ActionEvent e) {

                if (file==null) {
                    saveDialog.setVisible(true);
                    String dirpath=saveDialog.getDirectory();
                    String filename=saveDialog.getFile();
                    if (dirpath==null||filename==null) {
                        return;
                    }

                    file=new File(dirpath, filename);
                }
                try {
                    bw=new BufferedWriter(new FileWriter(file));
                    String text=ta.getText();
                    bw.write(text);
                    bw.flush();
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }finally{
                    try {
                        bw.close();
                    } catch (IOException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                    }
                }
            }
        });

        openItem.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                openDialog.setVisible(true);
                String dirpath=openDialog.getDirectory();
                String filename=openDialog.getFile();
                if (dirpath==null||filename==null) {
                    return;
                }
                ta.setText("");
                file=new File(dirpath, filename);
                try {
                     br=new BufferedReader(new FileReader(file));
                    String line=null;
                    while ((line=br.readLine())!=null) {
                        ta.append(line+"\r\n");
                    }
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }finally{

                    try {
                        br.close();
                    } catch (IOException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                    }
                }
            }
        });

        f.addWindowListener(new WindowAdapter() {

            public void windowClosing(WindowEvent e){
                System.exit(0);
            }
        });

        closeItem.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                System.exit(0);
            }
        });

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

        new MyMeuneTest();
    }

}