AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

GUI相关内容及案例贪吃蛇实现【上】

2022-04-26 126
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 简介 GUI的核心技术：Swing AWT 因为界面不美观 需要jre环境 学习的原因： 写出一些小工具 工作时维护到swing界面的概率极小 了解MVC架构，了解监听！ AWT AWT介绍 包含了很多类和接口！GUI！ 元素：窗口，按钮，文本框 java.awt 组件和容器 创建窗口组件 impo

简介

GUI的核心技术：Swing AWT


  1. 因为界面不美观
  2. 需要jre环境


学习的原因：


  1. 写出一些小工具
  2. 工作时维护到swing界面的概率极小
  3. 了解MVC架构，了解监听！


AWT

AWT介绍


  1. 包含了很多类和接口！GUI！
  2. 元素：窗口，按钮，文本框
  3. java.awt



组件和容器


创建窗口组件


import java.awt.*;
//GUI的第一个界面
public class TestFrame {
    public static void main(String[] args) {
        //Frame对象   看源码
        Frame frame = new Frame("我的第一个Java图形界面窗口");
        //需要设置可见性
        frame.setVisible(true);
        //设置窗口大小
        frame.setSize(400,400);
        //设置背景颜色    Color
        frame.setBackground(new Color(85,150,68));
        //弹出的初始位置
        frame.setLocation(200,200);
        //设置大小固定
        frame.setResizable(false);
    }
}


同时创建多个窗口


回顾封装


import java.awt.*;
public class TestFrame2 {
    public static void main(String[] args) {
        //展示多个窗口    new
        MyFrame myFrame1 = new MyFrame(100, 100, 200, 200, Color.blue);
        MyFrame myFrame2 = new MyFrame(300, 100, 200, 200, Color.yellow);
        MyFrame myFrame3 = new MyFrame(100, 300, 200, 200, Color.red);
        MyFrame myFrame4 = new MyFrame(300, 300, 200, 200, Color.magenta);
    }
}
class MyFrame extends Frame{
    static int id = 0;//可能存在多个窗口，我们需要一个计数器
    public MyFrame(int x,int y,int w,int h,Color color){
        super("Myframe"+(++id));
        setBackground(color);
        setBounds(x,y,w,h);
        setVisible(true);
    }
}


面板Panel


解决了关闭事件！


import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
//Panel 可以看成是一个空间，不能单独存在
public class TestPanel {
    public static void main(String[] args) {
        Frame frame = new Frame();
        //布局的概念
        Panel panel = new Panel();
        //设置布局
        frame.setLayout(null);
        //坐标
        frame.setBounds(300,300,500,500);
        frame.setBackground(new Color(87, 157, 51, 255));
        //设置Panel坐标，相对于frame
        panel.setBounds(50,50,400,400);
        panel.setBackground(new Color(234, 5, 5));
        //frame.add(panel)
        frame.add(panel);
        frame.setVisible(true);
        //监听事件，监听窗口关闭事件 System.exit()
        frame.addWindowListener(new WindowAdapter() {
            //窗口点击关闭的时候需要做的事情
            @Override
            public void windowClosing(WindowEvent e) {
                //结束程序
                System.exit(0);
            }
        });
    }
}


布局管理器


  • 流式布局


import java.awt.*;
public class TestFlowLayout {
    public static void main(String[] args) {
        Frame frame = new Frame();
        //组件-按钮
        Button button1 = new Button("button1");
        Button button2 = new Button("button2");
        Button button3 = new Button("button3");
        //设置为流式布局
        //frame.setLayout(new FlowLayout());
        //frame.setLayout(new FlowLayout(FlowLayout.LEFT));
        frame.setLayout(new FlowLayout(FlowLayout.RIGHT));
        frame.setSize(200,200);
        //把按钮添加上去
        frame.add(button1);
        frame.add(button2);
        frame.add(button3);
        frame.setVisible(true);
    }
}


  • 东西南北中


import java.awt.*;
public class TestBorderLayout {
    public static void main(String[] args) {
        Frame frame = new Frame("TestBorderLayout");
        Button east = new Button("East");
        Button west = new Button("West");
        Button south = new Button("South");
        Button north = new Button("North");
        Button center = new Button("Center");
        frame.add(east,BorderLayout.EAST);
        frame.add(west,BorderLayout.WEST);
        frame.add(south,BorderLayout.SOUTH);
        frame.add(north,BorderLayout.NORTH);
        frame.add(center,BorderLayout.CENTER);
        frame.setSize(200,200);
        frame.setVisible(true);
    }
}


  • 表格布局


import java.awt.*;
public class TestGridLayout {
    public static void main(String[] args) {
        Frame frame = new Frame("TestGridLayout");
        Button btn1 = new Button("btn1");
        Button btn2 = new Button("btn2");
        Button btn3 = new Button("btn3");
        Button btn4 = new Button("btn4");
        Button btn5 = new Button("btn5");
        Button btn6 = new Button("btn6");
        frame.setLayout(new GridLayout(3,2));
        frame.add(btn1);
        frame.add(btn2);
        frame.add(btn3);
        frame.add(btn4);
        frame.add(btn5);
        frame.add(btn6);
        frame.pack();//Java函数，自动布局
        frame.setVisible(true);
    }
}


  • 布局嵌套练习（绘制下图所示结构的布局）



import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class Test {
    public static void main(String[] args) {
        //创建frame
        Frame frame = new Frame("测试练习");
        //设置frame参数及布局
        frame.setBackground(new Color(252, 253, 252));
        frame.setSize(400,300);
        frame.setLocation(300,400);
        frame.setVisible(true);
        frame.setLayout(new GridLayout(2,1));
        //设置4个面板及布局
        Panel panel01 = new Panel(new GridLayout(2, 1));
        Panel panel02 = new Panel(new GridLayout(2, 2));
        Panel panel03 = new Panel(new BorderLayout());
        Panel panel04 = new Panel(new BorderLayout());
        //向面板中添加Button
        panel01.add(new Button("center-n"),BorderLayout.NORTH);
        panel01.add(new Button("center-s"),BorderLayout.SOUTH);
        panel03.add(new Button("west-1"),BorderLayout.WEST);
        panel03.add(new Button("east-1"),BorderLayout.EAST);
        panel03.add(panel01,BorderLayout.CENTER);
        panel04.add(panel02,BorderLayout.CENTER);
        for (int i = 0; i < 4; i++) {
            int m=i;
            panel02.add(new Button("center"+(++m)));
        }
        panel04.add(new Button("east-2"),BorderLayout.EAST);
        panel04.add(new Button("west-2"),BorderLayout.WEST);
        frame.add(panel03);
        frame.add(panel04);
        //设置frame关闭操作
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
}


总结：


  1. Frame是一个顶级窗口
  2. Panel无法单独显示，必须添加到某个容器中
  3. 布局管理器
  1. 流式
  2. 东西南北中
  3. 表格
  1. 大小，定位，背景，颜色，可见性，监听


事件监听


事件监听：当某个事情发生的时候，干什么？


import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class TestActionEvent {
    public static void main(String[] args) {
        //按下按钮，触发一些事件
        Frame frame = new Frame();
        Button button = new Button();
        //因为，addActionListener()需要一个ActionListener，所以我们需要构造一个ActionListener
        MyActionListener myActionListener = new MyActionListener();
        button.addActionListener(myActionListener);
        frame.add(button,BorderLayout.CENTER);
        frame.pack();
        windowClose(frame);//关闭窗口
        frame.setVisible(true);
    }
    //关闭窗体的事件
    private static void windowClose(Frame frame){
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
}
//事件监听
class MyActionListener implements ActionListener{
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("aaa");
    }
}


多个按钮，共享一个事件


import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class TestActionEvent2 {
    public static void main(String[] args) {
        //两个按钮，实现同一个监听
        //开始    停止
        Frame frame = new Frame("开始-停止");
        frame.setBounds(200,200,200,200);
        frame.setVisible(true);
        frame.setLayout(new GridLayout(2,1));
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        Button button1 = new Button("start");
        Button button2 = new Button("stop");
        //可以显示的定义触发会返回的命令，如果不显式定义，则会走默认的值！
        //可以多个按钮只写一个监听类
        button2.setActionCommand("button2-stop");
        MyMonitor myMonitor = new MyMonitor();
        button1.addActionListener(myMonitor);
        button2.addActionListener(myMonitor);
        frame.add(button1);
        frame.add(button2);
    }
}
class MyMonitor implements ActionListener{
    @Override
    public void actionPerformed(ActionEvent e) {
        //e.getActionCommand() 获得按钮的信息
        System.out.println("按钮被点击了：msg"+e.getActionCommand());
        if (e.getActionCommand().equals("start")){
        }
    }


输入框TextField监听


import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class TextText01 {
    public static void main(String[] args) {
        //启动！
        new MyFrame();
    }
}
class MyFrame extends Frame{
    public MyFrame(){
        TextField textField = new TextField();
        add(textField);
        //监听这个文本框输入的文字
        MyActionListener2 myActionListener2 = new MyActionListener2();
        //按下enter就会触发这个输入框的事件
        textField.addActionListener(myActionListener2);
        //设置替换编码
        textField.setEchoChar('*');
        setVisible(true);
        pack();
    }
}
class MyActionListener2 implements ActionListener{
    @Override
    public void actionPerformed(ActionEvent e) {
        TextField field = (TextField) e.getSource();//获得一些资源,返回一个对象
        System.out.println(field.getText());//获得输入框的文本
        field.setText("");//null
    }
}


简易计算器，组合+内部类回顾


oop原则：组合，大于继承


import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
//简易计算器
public class TestCalc {
    public static void main(String[] args) {
        MyFrame01 frame01 = new MyFrame01();
    }
}
//计算器类
class MyFrame01 extends Frame{
    public MyFrame01(){
        //三个文本框
        TextField field01 = new TextField(5);
        TextField field02 = new TextField(5);
        TextField field03 = new TextField(10);
        //一个按钮
        Button button = new Button("=");
        button.addActionListener(new MyActionListener01(field01,field02,field03));
        Panel panel01 = new Panel();
        panel01.add(field01);
        //一个标签
        panel01.add(new Label("+"));
        panel01.add(field02);
        panel01.add(button);
        panel01.add(field03);
        add(panel01);
        pack();
        setVisible(true);
    }
}
class MyActionListener01 implements ActionListener{
    //获取三个变量
    private TextField num1,num2,num3;
    public MyActionListener01(TextField num1,TextField num2,TextField num3){
        this.num1=num1;
        this.num2=num2;
        this.num3=num3;
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        //1.获得加数和被加数
        int n1 = Integer.parseInt(num1.getText());
        int n2 = Integer.parseInt(num2.getText());
        //2.将这个值+法运算后，放到第三个框
        num3.setText(""+(n1+n2));
        //3.清除前两个框
        num1.setText("");
        num2.setText("");
    }
}


完全改造为面向对象


import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
//简易计算器
public class TestCalc {
    public static void main(String[] args) {
        MyFrame01 frame01 = new MyFrame01();
        frame01.loadFrame();
    }
}
//计算器类
class MyFrame01 extends Frame{
    //属性
    TextField field01,field02,field03;
    //方法
    public void loadFrame(){
        //三个文本框
        field01 = new TextField(5);
        field02 = new TextField(5);
        field03 = new TextField(10);
        //一个按钮
        Button button = new Button("=");
        button.addActionListener(new MyActionListener01(this));
        //一个标签
        Label label = new Label("+");
        //布局
        setLayout(new FlowLayout());
        add(field01);
        add(label);
        add(field02);
        add(button);
        add(field03);
        pack();
        setVisible(true);
    }
}
//监听器类
class MyActionListener01 implements ActionListener{
    //获取计算器这个对象,在一个类中组合另外一个类
    MyFrame01 myframe01 = null;
    public MyActionListener01(MyFrame01 myframe01){
        this.myframe01=myframe01;
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        //1.获得加数和被加数
        int n1 = Integer.parseInt(myframe01.field01.getText());
        int n2 = Integer.parseInt(myframe01.field02.getText());
        //2.将这个值+法运算后，放到第三个框
        myframe01.field03.setText(""+(n1+n2));
        //3.清除前两个框
        myframe01.field01.setText("");
        myframe01.field02.setText("");
    }
}


使用内部类优化


import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
//简易计算器
public class TestCalc {
    public static void main(String[] args) {
        MyFrame01 frame01 = new MyFrame01();
        frame01.loadFrame();
    }
}
//计算器类
class MyFrame01 extends Frame{
    //属性
    TextField field01,field02,field03;
    //方法
    public void loadFrame(){
        //三个文本框
        field01 = new TextField(5);
        field02 = new TextField(5);
        field03 = new TextField(10);
        //一个按钮
        Button button = new Button("=");
        button.addActionListener(new MyActionListener01());
        //一个标签
        Label label = new Label("+");
        //布局
        setLayout(new FlowLayout());
        add(field01);
        add(label);
        add(field02);
        add(button);
        add(field03);
        pack();
        setVisible(true);
    }
    //监听器类
    //内部类最大的好处，就是可以畅通无阻地访问外部的属性和方法！
    private class MyActionListener01 implements ActionListener{
        @Override
        public void actionPerformed(ActionEvent e) {
            //1.获得加数和被加数
            int n1 = Integer.parseInt(field01.getText());
            int n2 = Integer.parseInt(field02.getText());
            //2.将这个值+法运算后，放到第三个框
            field03.setText(""+(n1+n2));
            //3.清除前两个框
            field01.setText("");
            field02.setText("");
        }
    }
}


画笔


import java.awt.*;
public class TestPaint {
    public static void main(String[] args) {
        new MyPaint().loadFrame();
    }
}
class MyPaint extends Frame{
    public void loadFrame(){
        setBounds(200,200,600,600);
        setVisible(true);
    }
    //画笔
    @Override
    public void paint(Graphics g) {
        //画笔，需要有颜色，画笔可以画画
        g.setColor(Color.red);
        //g.drawOval(100,100,100,100);
        g.fillOval(100,100,100,100);//实心的圆
        g.setColor(Color.GREEN);
        g.fillRect(100,100,100,100);
        //养成习惯，画笔用完，将其还原到最初的颜色--黑色
    }
}


鼠标监听


目的：想要实现鼠标画画



import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Iterator;
//鼠标监听事件
public class TestMouseListener {
    public static void main(String[] args) {
        new MyFrame("画图");
    }
}
//自己的类
class MyFrame extends Frame{
    //画画需要画笔，需要监听鼠标当前的位置，需要集合来存储这个点
    ArrayList points;
    public MyFrame(String title){
        super(title);
        setBounds(200,200,400,300);
        //存鼠标点击的点
        points = new ArrayList<>();
        setVisible(true);
        //鼠标监听器，正对这个窗口
        this.addMouseListener(new MyMouseListener());
    }
    @Override
    public void paint(Graphics g) {
        //画画，监听鼠标的事件
        Iterator iterator = points.iterator();
        while (iterator.hasNext()){
            Point point = (Point) iterator.next();
            g.setColor(Color.BLUE);
            g.fillOval(point.x,point.y,10,10);
        }
    }
    //添加一个点到界面上
    public void addPaint(Point point){
        points.add(point);
    }
    //适配器模式
    private class MyMouseListener extends MouseAdapter{
        //鼠标 按下，弹起，按住不放
        @Override
        public void mousePressed(MouseEvent e) {
            MyFrame myFrame = (MyFrame) e.getSource();
            //这个我们点击的时候，就会在界面上产生一个点！画
            //这个点就是鼠标的点；
            myFrame.addPaint(new Point(e.getX(),e.getY()));
            //每次点击鼠标都需要重新画一遍
            myFrame.repaint();//刷新
        }
    }
}
文章标签：
Java
前端开发
容器
游客k2gw4fr7y7zie
目录
相关文章
武子康
|
1月前
|
数据采集 前端开发 Python
Python pygame 实现游戏 彩色 五子棋 详细注释 附源码 单机版
Python pygame 实现游戏 彩色 五子棋 详细注释 附源码 单机版
武子康
63 0
土木林森
|
3月前
|
C# UED 开发者
WPF打印功能实现秘籍：从页面到纸张，带你玩转WPF打印技术大揭秘！
【8月更文挑战第31天】在WPF应用开发中，打印功能至关重要，不仅能提升用户体验，还增强了应用的实用性。本文介绍WPF打印的基础概念与实现方法，涵盖页面元素打印、打印机设置及打印预览。通过具体案例，展示了如何利用`PrintDialog`和`PrintDocument`控件添加打印支持，并使用`PrinterSettings`类进行配置，最后通过`PrintPreviewWindow`实现打印预览功能。
土木林森
274 0
老板这功能得加钱
|
6月前
|
程序员 C# Python
100行python代码，轻松完成贪吃蛇小游戏_c#游戏100行代码(2)
100行python代码，轻松完成贪吃蛇小游戏_c#游戏100行代码(2)
老板这功能得加钱
90 2
国中之林
|
6月前
|
编解码 C++
Qt第一课 第一个ui界面
Qt第一课 第一个ui界面
国中之林
83 2
老板这功能得加钱
|
6月前
|
存储 程序员 C#
100行python代码，轻松完成贪吃蛇小游戏_c#游戏100行代码
100行python代码，轻松完成贪吃蛇小游戏_c#游戏100行代码
老板这功能得加钱
90 0
热烈的马
|
6月前
|
Python
【python】pygame实现贪吃蛇小游戏（附源码，带注释）
【python】pygame实现贪吃蛇小游戏（附源码，带注释）
热烈的马
363 1
荷塘月色2
|
C++ Python
Python+Qt抽奖点名工具源码窗体程序
Python+Qt抽奖点名工具源码窗体程序
荷塘月色2
145 0
Python+Qt抽奖点名工具源码窗体程序
HannYang
|
前端开发 Python
Python tkinter库之Canvas按键事件移动物体 (模拟推箱子小游戏)
Python tkinter库之Canvas按键事件移动物体 (模拟推箱子小游戏)
HannYang
188 0
艺述论
|
移动开发 JavaScript 前端开发
第13/90步《前端篇》第2章 编写一个简单的HTML5小游戏：打造游戏界面 第4课
今天学习《前端篇》第2章 编写一个简单的HTML5小游戏：打造游戏界面 第4课 绘制挡板，这节课我们开始练习几何绘制，完成一个基本的游戏元素——挡板的绘制。
艺述论
82 0
艺述论
|
移动开发 前端开发 HTML5
第14/90步《前端篇》第2章 编写一个简单的HTML5小游戏：打造游戏界面 第5课
今天学习《前端篇》第2章 编写一个简单的HTML5小游戏：打造游戏界面 第5课 绘制小球，这节课我们将完成圆的绘制。
艺述论
64 0