Java-GUI

1. Übersicht über die GUI

GUI:

Grafische Benutzeroberfläche.

Verwenden Sie Grafiken, um die Computer-Bedienoberfläche anzuzeigen, was bequemer und intuitiver ist.

CLI:

Befehlszeilen-Benutzeroberfläche

Es handelt sich um eine übliche Dos-Befehlszeilenoperation. Sie müssen sich einige allgemeine Befehle merken, die Operation ist jedoch nicht der Fall intuitiv.

Die von Java für GUI bereitgestellten Objekte sind in den beiden Paketen java.awt und javax.swing vorhanden.

2. Übersicht über awt- und Swing-Pakete

java.awt: Abstract Window ToolKit, abstraktes Fenster-Toolkit, das lokale Systemmethoden aufrufen muss, um Funktionen zu implementieren , gehört zu den Schwergewichtskontrollen.

javax.swing: Ein auf AWT basierendes grafisches Schnittstellensystem, das mehr Komponenten bereitstellt und vollständig in Java implementiert ist, was die Portabilität verbessert und eine leichte Steuerung darstellt.

3. GUI-Vererbungssystem

Container: ist ein Container, eine spezielle Komponente, die andere hinzufügen kann Komponenten über die Add-Methode.

package cn5;
 
import java.awt.Frame;
/**
 * 创建一个最简单的窗体  
 */
public class AWTDemo {
    public static void main(String[] args) {
        //创建一个最初不可见的窗体对象
        Frame f = new Frame();
        //设置窗体标题
        f.setTitle("哈哈 呵呵 嘻嘻 笨笨");
        //设置窗体大小
        f.setSize(400, 300);//单位：默认像素
        //设置窗体坐标
        f.setLocation(400, 200);
        //让窗体可见
        f.setVisible(true);
    }
 
}

Andere Methoden, um den Effekt des obigen Bildes zu erzielen

package cn5;
 
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.Point;
 
public class AWTDemo2 {
    public static void main(String[] args) {
        //创建一个不可见的窗体
        Frame f = new Frame();
        //设置标题
        f.setTitle("哈哈");
        //设置位置
        f.setLocation(new Point(400, 200));
        //设置大小
        f.setSize(new Dimension(400, 300));
        //使得窗体可见
        f.setVisible(true);
    }
 
}

package cn5;
 
import java.awt.Frame;
 
public class AWTDemo2 {
    public static void main(String[] args) {
        //创建一个不可见的窗体
        Frame f = new Frame();
        //设置标题
        f.setTitle("哈哈");
        f.setBounds(400,200,400,300);
        //使得窗体可见
        f.setVisible(true);
    }
 
}

Fenster schließen

package cn5;
 
import java.awt.Frame;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
/**
 * 事件监听机制
 *        事件源：事件发生的地方。
 *        事件：就是要发生的事情。
 *        事件处理：就是针对发生的事情做出的处理方案。
 *        事件监听：就是把事件源和事件关联起来。
 * 
 * 举例：人受伤事件
 *        事件源：人（具体的对象）
 *            Person p1 = new Person("张三");
 *            Person p2 = new Person("李四");
 *        事件：受伤
 *            interface 受伤接口{
 *                一拳();
 *                一脚();
 *                一板砖();
 *            }
 *        事件处理：
 *            事件处理类 implements 受伤接口{
 *                一拳(){
 *                    System.out.println("鼻子流血了，去医院");
 *                }
 *                一脚(){
 *                    System.out.println("晕倒了");
 *                }
 *                一板砖(){
 *                    System.out.println("头破血流");
 *                }
 *            }
 *     事件监听：
 *         p1.注册监听(受伤接口)
 *         p2.注册监听(受伤接口)
 */
public class AWTDemo3 {
    public static void main(String[] args) {
        //创建一个最初不可见的窗体对象
        Frame f = new Frame("窗体关闭");
        //设置窗体属性
        f.setBounds(400, 200, 400, 300);
         
        //让窗体关闭
        //事件源：窗体f
        //事件：对窗体的处理
        //事件处理：关闭窗体(System.exit(0))
        //事件监听：
        f.addWindowListener(new WindowListener() {
             
            @Override
            public void windowOpened(WindowEvent e) {
                 
            }
             
            @Override
            public void windowIconified(WindowEvent e) {
                 
            }
             
            @Override
            public void windowDeiconified(WindowEvent e) {
                 
            }
             
            @Override
            public void windowDeactivated(WindowEvent e) {
            }
             
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
             
            @Override
            public void windowClosed(WindowEvent e) {
                 
            }
             
            @Override
            public void windowActivated(WindowEvent e) {
                 
            }
        });
        //使得窗体可见
        f.setVisible(true);
         
    }
 
}

Gibt es laut obigem Code viel redundanten Code? Schauen wir uns die Aufschlüsselung unten an.

4. Adaptermodus

package cn6;
 
public interface IUserDAO {
    /**
     * 增加用户
     */
    public void add();
    /**
     * 删除用户
     */
    public void delete();
    /**
     * 修改用户
     */
    public void update();
    /**
     * 查询用户
     */
    public void find();
 
}

package cn6;
 
public class UserDAOImpl implements IUserDAO {
 
    @Override
    public void add() {
        System.out.println("用户增加");
    }
 
    @Override
    public void delete() {
        System.out.println("用户删除");
    }
 
    @Override
    public void update() {
        System.out.println("用户修改");
    }
 
    @Override
    public void find() {
        System.out.println("用户查询");
    }
 
}

package cn6;
 
public class Test {
    public static void main(String[] args) {
        IUserDAO userDAO = new UserDAOImpl();
        userDAO.add();
        userDAO.delete();
        userDAO.find();
        userDAO.update();
    }
 
}

Benutzerhinzufügung

Benutzerlöschung

Benutzerabfrage

Benutzer Ändern

Aber wenn ich möchte, dass Benutzer nur Funktionen hinzufügen, werden Sie zu diesem Zeitpunkt denken: Kann ich die Methoden delete (), find () und update () nicht einfach nicht aufrufen?

package cn6;
 
public interface IUserDAO {
    /**
     * 增加用户
     */
    public void add();
    /**
     * 删除用户
     */
    public void delete();
    /**
     * 修改用户
     */
    public void update();
    /**
     * 查询用户
     */
    public void find();
 
}

package cn6;
 
public class UserDAOImpl implements IUserDAO {
 
    @Override
    public void add() {
        System.out.println("用户增加");
    }
 
    @Override
    public void delete() {
        System.out.println("用户删除");
    }
 
    @Override
    public void update() {
        System.out.println("用户修改");
    }
 
    @Override
    public void find() {
        System.out.println("用户查询");
    }
 
}

package cn6;
 
public class Test {
    public static void main(String[] args) {
        IUserDAO userDAO = new UserDAOImpl();
        userDAO.add();
         
    }
 
}

Ja, aber müssen Sie die in der Schnittstelle definierten Methoden trotzdem in der Implementierungsklasse der Schnittstelle überschreiben, auch wenn Sie keine bestimmte Implementierung schreiben? Allerdings hasse ich es einfach, viel überflüssigen Code zu schreiben. Ich habe Mysophobie. Was soll man mit mir machen?

Hmpf, füge eine abstrakte Klasse (Adapterklasse) zwischen der Schnittstelle und der spezifischen Implementierungsklasse hinzu.

Schnittstelle – Adapter (abstrakte Klasse) – konkrete Implementierungsklasse

package cn6;
 
public interface IUserDAO {
    /**
     * 增加用户
     */
    public void add();
    /**
     * 删除用户
     */
    public void delete();
    /**
     * 修改用户
     */
    public void update();
    /**
     * 查询用户
     */
    public void find();
 
}

package cn6;
 
public abstract class UserAdapter implements IUserDAO {
 
    @Override
    public void add() {
         
    }
 
    @Override
    public void delete() {
         
    }
 
    @Override
    public void update() {
         
    }
 
    @Override
    public void find() {
         
    }
     
 
}

package cn6;
 
public class UserDAOAddImpl extends UserAdapter {
 
    @Override
    public void add() {
        System.out.println("用户添加");
    }
     
     
     
     
 
}

Hinweis: Wenn Sie zu diesem Zeitpunkt keine Methode in die UserDAOAddImpl-Klasse schreiben, ist dies der Fall ist nicht Es wird ein Fehler gemeldet, da die abstrakte Klasse UserAdapter die Schnittstelle bereits implementiert hat, obwohl es sich lediglich um eine leere Implementierung handelt.

package cn6;
 
public class UserDAOAddImpl extends UserAdapter {
 
}

Aber weil ich nur möchte, dass Benutzer Funktionen hinzufügen, na und? Ich habe gerade eine Klasse geschrieben, um die Benutzeradditionsfunktion zu implementieren. Ist das nicht sehr problemlos?

package cn6;
 
public class UserDAOAddImpl extends UserAdapter {
    @Override
    public void add() {
        System.out.println("用户增加");
    }
     
     
     
     
 
}

Wenn ich jetzt nur die Benutzerlöschfunktion möchte, schreibe ich einfach eine Klasse, um die Benutzerlöschfunktion zu implementieren. Natürlich muss ich diese abstrakte Klasse erben.

package cn6;
 
public class UserDAODeleteImpl extends UserAdapter {
    @Override
    public void delete() {
        System.out.println("用户删除");
    }
}

Für andere befolgen Sie einfach das gleiche Verfahren.

package cn6;
 
public class Test {
    public static void main(String[] args) {
        //用户增加
        IUserDAO userDAO = new UserDAOAddImpl();
        userDAO.add();
        //用户删除
        userDAO = new UserDAODeleteImpl();
        userDAO.delete();
         
    }
 
}

Aber wenn man sich das ansieht, spürt man, dass es von Anfang an nicht anders ist.

package cn6;
 
public class UserDAOImpl implements IUserDAO {
 
    @Override
    public void add() {
        System.out.println("用户增加");
    }
 
    @Override
    public void delete() {
        System.out.println("用户删除");
    }
 
    @Override
    public void update() {
        System.out.println("用户修改");
    }
 
    @Override
    public void find() {
        System.out.println("用户查询");
    }
 
}

In der Realität ist dies jedoch nicht der Fall. Der obige Code generiert viel Müllcode, da ich nur möchte, dass Benutzer Funktionen hinzufügen, Sie jedoch das Hinzufügen von Benutzern, das Löschen von Benutzern usw. erreicht haben. Zu diesem Zeitpunkt denken Sie vielleicht: Lassen Sie mich gehen, Sie möchten, dass Benutzer Funktionen hinzufügen, oder? Schauen Sie sich den Code unten an.

package cn6;
 
public class UserDAOImpl implements IUserDAO {
 
    @Override
    public void add() {
        System.out.println("用户增加");
    }
 
    @Override
    public void delete() {
    }
 
    @Override
    public void update() {
    }
 
    @Override
    public void find() {
    }
 
}

Aber jetzt möchte ich, dass Benutzer Funktionen hinzufügen und ändern. Ist das nicht sehr nervig? Die Bedürfnisse der Kunden ändern sich ständig, und wir können nur gleich bleiben, um mit den Veränderungen zurechtzukommen. Wenn Sie also den Adaptermodus verwenden, wie möchten Sie die Anforderungen ändern? Ja, ich werde eine Implementierungsklasse für Sie erstellen, die Ihren Funktionen entspricht, sodass Sie nichts zu sagen haben.

[Hinweis] Wenn es nur eine Funktion in der Schnittstelle gibt, besteht keine Notwendigkeit, den Adaptermodus zu verwenden. Gibt es einen Unterschied zwischen der Verwendung und der Nichtverwendung?

5. Verwenden Sie den Adaptermodus, um den redundanten Code des Fensterschließens zu lösen

package cn5;
 
import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
/**
 * 事件监听机制
 *        事件源：事件发生的地方。
 *        事件：就是要发生的事情。
 *        事件处理：就是针对发生的事情做出的处理方案。
 *        事件监听：就是把事件源和事件关联起来。
 * 
 * 举例：人受伤事件
 *        事件源：人（具体的对象）
 *            Person p1 = new Person("张三");
 *            Person p2 = new Person("李四");
 *        事件：受伤
 *            interface 受伤接口{
 *                一拳();
 *                一脚();
 *                一板砖();
 *            }
 *        事件处理：
 *            事件处理类 implements 受伤接口{
 *                一拳(){
 *                    System.out.println("鼻子流血了，去医院");
 *                }
 *                一脚(){
 *                    System.out.println("晕倒了");
 *                }
 *                一板砖(){
 *                    System.out.println("头破血流");
 *                }
 *            }
 *     事件监听：
 *         p1.注册监听(受伤接口)
 *         p2.注册监听(受伤接口)
 */
public class AWTDemo3 {
    public static void main(String[] args) {
        //创建一个最初不可见的窗体对象
        Frame f = new Frame("窗体关闭");
        //设置窗体属性
        f.setBounds(400, 200, 400, 300);
         
        //让窗体关闭
        //事件源：窗体f
        //事件：对窗体的处理
        //事件处理：关闭窗体(System.exit(0))
        //事件监听：
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        //使得窗体可见
        f.setVisible(true);
         
    }
 
}

6. Fügen Sie die Schaltfläche zum Formular hinzu und fügen Sie ein Klickereignis hinzu

package cn7;
 
import java.awt.Button;
import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
 
/**
 * 需求：把按钮添加到窗体，并对按钮添加一个点击事件
 *        1.创建窗体对象
 *      2.创建按钮对象
 *      3.把按钮添加到窗体
 *      4.窗体显示
 *
 */
public class AWTDemo {
    public static void main(String[] args) {
        //创建窗体对象
        Frame f = new Frame("把按钮添加到窗体，并对按钮添加一个点击事件");
        //设置窗体属性
        f.setBounds(400, 200, 400, 300);
        //创建按钮对象
        Button button = new Button("我是按钮");
        button.setSize(20,10);
        //把按钮添加到窗体
        f.add(button);
        //设置窗体可以关闭
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        //窗体显示
        f.setVisible(true);
    }
}

Es ist so hässlich, dass ich Ich kann es nicht essen. Okay, wie kann es einen so großen Knopf geben? Und ich habe die Größe des Knopfes eingestellt, aber warum funktioniert es nicht?

package cn7;
 
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;
 
/**
 * 需求：把按钮添加到窗体，并对按钮添加一个点击事件
 *        1.创建窗体对象
 *      2.创建按钮对象
 *      3.把按钮添加到窗体
 *      4.窗体显示
 *
 */
public class AWTDemo {
    public static void main(String[] args) {
        //创建窗体对象
        Frame f = new Frame("把按钮添加到窗体，并对按钮添加一个点击事件");
        //设置窗体属性
        f.setBounds(400, 200, 400, 300);
        //创建按钮对象
        Button button = new Button("我是按钮");
        //设置点击事件
        button.addActionListener(new ActionListener() {
             
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("你再看试试");
            }
        });
        //Frame的布局默认是边界布局，现在修改为流式布局
        f.setLayout(new FlowLayout());
        //把按钮添加到窗体
        f.add(button);
        //设置窗体可以关闭
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        //窗体显示
        f.setVisible(true);
    }
}

Übung

package cn8;
 
import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
 
public class AWTDemo {
    public static void main(String[] args) {
        //创建窗体对象
        Frame f = new Frame("数据转移");
        //设置窗体属性
        f.setBounds(400, 200, 400, 300);
        //设置窗体布局
        f.setLayout(new FlowLayout());
         
        //创建文本框
        final TextField tf = new TextField(20);
        //创建按钮
        Button bt = new Button("数据转移");
        //创建文本域
        final TextArea tx = new TextArea(10,40);
         
        //把组件添加到窗体
        f.add(tf);
        f.add(bt);
        f.add(tx);
         
        //设置关闭事件
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
         
        //对按钮添加事件
        bt.addActionListener(new ActionListener() {
             
            @Override
            public void actionPerformed(ActionEvent e) {
                //获取文本框的值
                String tf_str = tf.getText().trim();
                //清空数据
                tf.setText("");
                //设置给文本库并换行
                tx.append(tf_str+"\r\n");
                //文本框获取光标
                tf.requestFocus();
            }
        });
        //让窗体显示
        f.setVisible(true);
    }
 
}

package cn9;
/**
*鼠标点击事件
*/
import java.awt.Button;
import java.awt.Color;
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 AWTDemo {
    public static void main(String[] args) {
        final Frame f = new Frame("更改背景色");
        f.setBounds(400, 200, 400, 300);
        f.setLayout(new FlowLayout());
         
        //创建按钮
        Button bt1 = new Button("红色");
        Button bt2 = new Button("黑色");
        Button bt3 = new Button("绿色");
        Button bt4 = new Button("黄色");
         
        //添加按钮
        f.add(bt1);
        f.add(bt2);
        f.add(bt3);
        f.add(bt4);
         
         
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        bt1.addActionListener(new ActionListener() {
             
            @Override
            public void actionPerformed(ActionEvent e) {
                f.setBackground(Color.RED);
            }
        });
        bt2.addActionListener(new ActionListener() {
             
            @Override
            public void actionPerformed(ActionEvent e) {
                f.setBackground(Color.BLACK);
            }
        });
        bt3.addActionListener(new ActionListener() {
             
            @Override
            public void actionPerformed(ActionEvent e) {
                f.setBackground(Color.GREEN);
            }
        });
        bt4.addActionListener(new ActionListener() {
             
            @Override
            public void actionPerformed(ActionEvent e) {
                f.setBackground(Color.YELLOW);
            }
        });
        f.setVisible(true);
    }
}

package cn9;
 
import java.awt.Button;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
/**
 * 鼠标移动事件
 */
public class AWTDemo {
    public static void main(String[] args) {
        final Frame f = new Frame("更改背景色");
        f.setBounds(400, 200, 400, 300);
        f.setLayout(new FlowLayout());
         
        //创建按钮
        Button bt1 = new Button("红色");
        Button bt2 = new Button("黑色");
        Button bt3 = new Button("绿色");
        Button bt4 = new Button("黄色");
         
        //添加按钮
        f.add(bt1);
        f.add(bt2);
        f.add(bt3);
        f.add(bt4);
         
         
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        bt1.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                f.setBackground(Color.RED);
            }
        });
        bt2.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                f.setBackground(Color.BLACK);
            }
        });
        bt3.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                f.setBackground(Color.GREEN);
            }
        });
        bt4.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                f.setBackground(Color.YELLOW);
            }
        });
        f.setVisible(true);
    }
}

package cn10;
 
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Label;
import java.awt.TextField;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
 
public class AWTDemo {
    public static void main(String[] args) {
        Frame f = new Frame("QQ校验");
        f.setBounds(400, 200, 400, 300);
        f.setLayout(new FlowLayout());
         
        Label l = new Label("请输入你的QQ号码,不能是非数字");
        TextField tf = new TextField(30);
        f.add(l);
        f.add(tf);
         
        tf.addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                char c = e.getKeyChar();
                if(!(c >= &#39;0&#39; && c <=&#39;9&#39;)){
                    e.consume();
                }
            }
        });
         
         
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        f.setVisible(true);
    }
 
}

八、菜单组件

菜单组件概述

MenuBar，Menu，MenuItem

先创建菜单条，再创建菜单，每一个菜单中建立菜单项。

也可以菜单添加到菜单中，作为子菜单。

通过setMenuBar()方法，将菜单添加到Frame中。

package cn11;
 
import java.awt.Frame;
import java.awt.Menu;
import java.awt.MenuBar;
import java.awt.MenuItem;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
/**
 * 一级菜单
 */
public class Demo {
    public static void main(String[] args) {
        Frame f = new Frame("一级菜单");
        f.setBounds(400, 200, 400, 300);
         
        //创建菜单栏
        MenuBar bar = new MenuBar();
        //创建菜单
        Menu m = new Menu("文件");
        //创建菜单项
        MenuItem mi = new MenuItem("退出系统");
         
        //设置菜单栏
        f.setMenuBar(bar);
        bar.add(m);
        m.add(mi);
         
         
        mi.addActionListener(new ActionListener() {
             
            @Override
            public void actionPerformed(ActionEvent e) {
                System.exit(0);
                 
            }
        });
         
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        f.setVisible(true);
         
         
    }
 
}