狂神说Java-GUI编程入门 ( 笔记 )

最新推荐文章于 2023-07-17 11:59:18 发布

elapsed sat

最新推荐文章于 2023-07-17 11:59:18 发布

阅读量340

点赞数 4

文章标签： java 游戏程序

本文链接：https://blog.csdn.net/m0_60694716/article/details/127736785

版权

GUI编程入门

简介

GUI组件

窗口
弹窗
面板
文本框
列表框
按钮
图片
监听事件
鼠标
键盘事件
破解工具

GUI核心技术

AWT
Swing

为什么要学习？

可以写出自己心中想要的一些小工具
工作时候，可能需要维护到Swing界面，概率极小
了解MVC架构、了解监听

第一章 AWT

1.1 AWT介绍
在这里插入图片描述
1.2 组件和容器
1.2.1 Frame

package Frame_;
import java.awt.*;

//GUI的第一个界面
public class TestFrame {
    public static void main(String[] args) {

        Frame frame = new Frame("我的第一个java图形界面窗口！");
        //设置可见性
        frame.setVisible(true);
        //设置窗口大小
        frame.setSize(400,400);
        //设置背景颜色
        frame.setBackground(new Color(1,1,1));
        //弹出的初始位置
        frame.setLocation(540,360);
        //设置大小固定
        frame.setResizable(false);
    }
}

在这里插入图片描述

package Frame_;
import java.awt.*;

public class TestFrame02 {
    public static void main(String[] args) {

        //展示多个窗口
        MyFrame myFrame = 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.green);


    }
}

class MyFrame extends Frame { //注意继承的是Frame,不是TestFrame
    static int id = 0;//可能存在多个窗口,我们需要一个计数器

    public MyFrame(int x, int y, int w, int h, Color color) {

        super("MyFrame" + (++id));

        //因为继承了Frame,所以不用Frame.setBounds什么的
        setBackground(color);
        setBounds(x, y, w, h);
        setVisible(true);

    }
}

在这里插入图片描述

1.2.2 面板 Panel

package Frame_;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

//可以看做成一个空间,但是不能单独存在
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(38, 221, 24));

        //Panel设置坐标：相对于frame
        panel.setBounds(50, 50, 400, 400);
        panel.setBackground(new Color(193, 15, 60));

        //frame添加面板 frame.add(panel)
        frame.add(panel);

        frame.setVisible(true);

        //监听事件,监听窗口关闭事件,System.exit(0)
        //适配器模式：
        frame.addWindowListener(new WindowAdapter() {
            //窗口点击关闭的时候需要做的事情
            @Override
            public void windowClosing(WindowEvent e) {
                //结束程序
                System.exit(0);
            }
        });
    }
}

在这里插入图片描述

1.2.3 布局管理器
1.2.3.1 流式布局

package lesson01;
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.setSize(200, 200);

        //把按钮添加上去
        frame.add(button1);
        frame.add(button2);
        frame.add(button3);

        frame.setVisible(true);
    }
}

在这里插入图片描述

1.2.3.2 东西南北中

package lesson01;
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);
    }
}

在这里插入图片描述

1.2.3.3 表格布局

package lesson01;
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);

    }
}

在这里插入图片描述
1.2.3.4 课堂练习题

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.setLayout(new GridLayout(2, 1));

        //四个面板
        //上整部分
        Panel p1 = new Panel(new BorderLayout());
        //上中部分
        Panel p2 = new Panel(new GridLayout(2, 1));
        //下整部分
        Panel p3 = new Panel(new BorderLayout());
        //下中部分
        Panel p4 = new Panel(new GridLayout(2, 2));

        //上部分
        p1.add(new Button("East-1"), BorderLayout.EAST);
        p1.add(new Button("West-1"), BorderLayout.WEST);
        //已经有布局，无需再次设置
        p2.add(new Button("p2-btn-1"));
        p2.add(new Button("p2-btn-2"));
        //把p2放到p1中间部分
        p1.add(p2, BorderLayout.CENTER);

        //下部分
        p3.add(new Button("East-1"), BorderLayout.EAST);
        p3.add(new Button("West-1"), BorderLayout.WEST);
        //中间四个
        for (int i = 0; i < 4; i++) {
            p4.add(new Button("for-" + i));
        }
        p3.add(p4, BorderLayout.CENTER);

        //两个大面板还没有放到布局里
        frame.add(p1);
        frame.add(p3);

        frame.setSize(400, 200);
        frame.setVisible(true);

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

1.2.3.5 总结
在这里插入图片描述

1.4 事件监听
1.4.1 实现点击按钮输出aaa

package lesson02;
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");
    }
}

1.4.2 两个按钮共用一个监听

package lesson02;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class TestActionTwo {
    public static void main(String[] args) {
        //两个按钮，实现同一个监听
        //开始 停止

        Frame frame = new Frame("开始-停止");
        Button button1 = new Button("开始");
        Button button2 = new Button("停止");

        //可以显示的定义触发会返回的命令，如果不走定义，则会走默认的值
        //可以多个按钮只写一个监听类
        button2.setActionCommand("button2-stop");

        MyMonitor myMonitor = new MyMonitor();

        button1.addActionListener(myMonitor);
        button2.addActionListener(myMonitor);

        frame.add(button1, BorderLayout.NORTH);
        frame.add(button2, BorderLayout.SOUTH);

        frame.pack();
        frame.setVisible(true);

    }
}

//写监听事件
class MyMonitor implements ActionListener {
    //监听就要实现重写里面的方法
    @Override
    public void actionPerformed(ActionEvent e) {
        // e.getActionCommand() 获得按钮的信息
        System.out.println("按钮被点击了: msg" + e.getActionCommand());
    }
}

1.5 输入框 TextField 监听

package lesson02;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class TestText01 {
    public static void main(String[] args) {
        //main方法只管启动！！！！！！！！！
        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);//继承了就不用frame.setVisible()了
        pack();

    }
}

//有监听就需要自己写监听,有可能重名
class MyActionListener2 implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        TextField field = (TextField) e.getSource();//获得一些资源,返回一个Object对象，所以可以向下转型接收
        System.out.println(field.getText());//获得输入框中的文本

        field.setText("");//null是对象，""是字符串，''是字符
    }
}

在这里插入图片描述
1.6 实现简易计算器，组合+内部类回顾复习！

面向过程的写法:

package lesson02;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

//简易计算器
public class TestCalc {
    public static void main(String[] args) {
        new Calculator();
    }
}

//计算器类
class Calculator extends Frame {
    public Calculator() {
        //三个文本框
        TextField num1 = new TextField(10);//最大字符数
        TextField num2 = new TextField(10);//最大字符数
        TextField num3 = new TextField(20);//最大字符数

        //一个按钮
        Button button = new Button("=");
        //给按钮加监听
        button.addActionListener(new MyCalculatorListener(num1, num2, num3  ));

        //一个标签(无用)
        Label label = new Label("+");

        //布局
        setLayout(new FlowLayout());

        add(num1);
        add(label);
        add(num2);
        add(button);
        add(num3);

        pack();
        setVisible(true);
    }
}

//监听器类
class MyCalculatorListener implements ActionListener {

    //获取三个变量
    private TextField num1,num2,num3;
    //把外面的传进来，想怎么用都快可以
    public MyCalculatorListener(TextField num1, TextField num2, TextField num3) {
        this.num1 = num1;
        this.num2 = num2;
        this.num3 = num3;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //1. 获得两个加数,并转换成int类型
        int n1 = Integer.parseInt(num1.getText());
        int n2 = Integer.parseInt(num2.getText());

        //2. 将两个值加法运算后，放到第三个框
        num3.setText("" + (n1 + n2));//暴力转换字符

        //3. 清除前两个框
        num1.setText("");
        num2.setText("");
    }
}

完全改造为面向对象写法

package lesson02;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

//简易计算器
public class TestCalc {
    public static void main(String[] args) {
        new Calculator().loadFrame();
    }
}

//计算器类
class Calculator extends Frame {
    //属性
    TextField num1, num2, num3;

    //方法
    public void loadFrame() {
        //先把组件拼起来
        num1 = new TextField(10);//最大字符数
        num2 = new TextField(10);//最大字符数
        num3 = new TextField(20);//最大字符数
        Button button = new Button("=");
        Label label = new Label("+");

        //组件需要的监听器加上
        button.addActionListener(new MyCalculatorListener(this)) ;//把自己传进去

        //布局
        setLayout(new FlowLayout());
        add(num1);
        add(label);
        add(num2);
        add(button);
        add(num3);

        pack();
        setVisible(true);
    }
}

//监听器类
class MyCalculatorListener implements ActionListener {

    //获取计算器这个对象,在一个类中组合另外一个类
    Calculator calculator = null;

    public MyCalculatorListener(Calculator calculator) {
        this.calculator = calculator;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //1. 获得两个加数,并转换成int类型
        int n1 = Integer.parseInt(calculator.num1.getText());
        int n2 = Integer.parseInt(calculator.num2.getText());

        //2. 将两个值加法运算后，放到第三个框
        calculator.num3.setText("" + (n1 + n2));

        //3. 清除前两个框
        calculator.num1.setText("");
        calculator.num2.setText("");
    }
}

内部类: 更好的包装

package lesson02;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

//简易计算器
public class TestCalc {
    public static void main(String[] args) {
        new Calculator().loadFrame();
    }
}

//计算器类
class Calculator extends Frame {
    //属性
    TextField num1, num2, num3;

    //方法
    public void loadFrame() {
        //先把组件拼起来
        num1 = new TextField(10);//最大字符数
        num2 = new TextField(10);//最大字符数
        num3 = new TextField(20);//最大字符数
        Button button = new Button("=");
        Label label = new Label("+");

        //组件需要的监听器加上
        button.addActionListener(new MyCalculatorListener()) ;

        //布局
        setLayout(new FlowLayout());
        add(num1);
        add(label);
        add(num2);
        add(button);
        add(num3);

        pack();
        setVisible(true);
    }

    //监听器类
    //内部类最大的好处，就是可以畅通无阻的访问外部类的属性和方法！！！！！
    private class MyCalculatorListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            //1. 获得两个加数,并转换成int类型
            //内部类，不用calculator.num1.getText()了
            int n1 = Integer.parseInt(num1.getText());
            int n2 = Integer.parseInt(num2.getText());

            //2. 将两个值加法运算后，放到第三个框
            num3.setText("" + (n1 + n2));

            //3. 清除前两个框
            num1.setText("");
            num2.setText("");
        }
    }
}

1.7 画笔

  package lesson03;

import java.awt.*;
import java.util.Date;

public class TestPaint {
    public static void main(String[] args) {
        new MyPaint().loadFrame();
    }
}

class MyPaint extends Frame {

    public void loadFrame() {
        setBounds(200, 200, 600, 500);
        setVisible(true);
    }

    //画笔
    @Override
    public void paint(Graphics g) {
        //画笔，需要有颜色，可以画画
        //g.setColor(Color.green);
        g.drawOval(100, 100, 100, 100);
        g.fillOval(100, 100, 100, 100);//实心的圆

        //g.setColor(Color.red);
        g.fillRect(150, 200, 200, 200);

        //养成习惯，画笔用完，将他还原到最初的颜色
    }
}

1.8 鼠标监听

实现简单鼠标画画

PS：首先我们需要一个窗口，然后单独搞了画笔，又做了适配器。于是要建立联系，要一个缓冲的地方，就是鼠标点存放地方–集合(因为所有人都要用，所以写到最上面)。开始点点，就把鼠标点的坐标存到集合里面，集合传入鼠标监听读取集合，第一次点没有反应(因为已经画完了，我们需要它不断的重新画)。

package lesson03;

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 addPoint(Point point) {
        points.add(point);
    }

    //适配器模式,想重写那个就重写那个
    private class  MyMouseListener extends MouseAdapter {
        //鼠标，按下，弹起，按住不放
        @Override
        public void mousePressed(MouseEvent e) {
            //用getSource拿到窗口
            MyFrame frame = (MyFrame) e.getSource();//强转
            //这里我们点击的时候，就会在界面上产生一个点！
            //这个点就是鼠标的点
            frame.addPoint(new Point(e.getX(), e.getY()));

            //每次点击鼠标都需要重新画一遍
            frame.repaint();//刷新
        }
    }
}

在这里插入图片描述

1.9 窗口监听

内部类关闭窗口

package lesson03;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class TestWindow {
    public static void main(String[] args) {
        new WindowFrame();
    }
}
class WindowFrame extends Frame {
    public WindowFrame() {
        setBackground(Color.BLUE);
        setBounds(100, 100, 200, 200);
        setVisible(true);
        addWindowListener(new MyWindowListener());//优化去掉

    }

    //内部类
    class MyWindowListener extends WindowAdapter {
        @Override
        public void windowClosing(WindowEvent e) {
            //setVisible(false);//隐藏窗口，通过按钮隐藏当前窗口
            System.exit(0);//正常退出
        }
    }
}

匿名内部类

package lesson03;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class TestWindow {
    public static void main(String[] args) {
        new WindowFrame();
    }
}
class WindowFrame extends Frame {
    public WindowFrame() {
        setBackground(Color.BLUE);
        setBounds(100, 100, 200, 200);
        setVisible(true);
        //addWindowListener(new MyWindowListener());//优化去掉

        //优化：匿名内部类
        this.addWindowListener (
            new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    System.out.println("你点击了x");
                    System.exit(0);
                }
            }
        );
    }
}

监听事件

package lesson03;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class TestWindow {
    public static void main(String[] args) {
        new WindowFrame();
    }
}
class WindowFrame extends Frame {
    public WindowFrame() {
        setBackground(Color.BLUE);
        setBounds(100, 100, 200, 200);
        setVisible(true);

        //优化：匿名内部类
        this.addWindowListener (
            new WindowAdapter() {
                //关闭窗口
                @Override
                public void windowClosing(WindowEvent e) {
                    System.out.println("windowClosing");
                    System.exit(0);
                }

                //激活窗口
                @Override
                public void windowActivated(WindowEvent e) {
                    WindowFrame source = (WindowFrame) e.getSource();//获取什么数据呢？WindowFrame
                    source.setTitle("被激活了");
                    System.out.println("windowActivated");//窗口激活
                }
            }
        );
    }
}

1.10 键盘监听

package lesson03;

import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

//键盘监听
public class TestKeyListener {
    public static void main(String[] args) {
        new KeyFrame();
    }
}

class KeyFrame extends Frame {
    //给无参构造器
    public KeyFrame() {
        setBounds(1, 2, 300, 400);
        setVisible(true);

        this.addKeyListener(new KeyAdapter() {
            //键盘按下的时候出现的事情
            @Override
            public void keyPressed(KeyEvent e) {
                //获得键盘按下的键是那个键，当前的码
                int keyCode = e.getKeyCode();//不需要记这个值，直接使用静态属性 VK_XXX
                System.out.println(keyCode);
                if(keyCode == KeyEvent.VK_UP) {
                    System.out.println("你按下了上键");
                }
            }
        });
    }
}

第二章 Swing

2.1 窗口、面板

标签居中

package lesson04;

import javax.swing.*;
import java.awt.*;

public class JFrameDemo02 {
    public static void main(String[] args) {
        new MyJFrame2().init();
    }
}

class MyJFrame2 extends JFrame {
    public void init() {
        this.setBounds(10, 10, 200, 300);
        this.setVisible(true);

        JLabel label = new JLabel("Java节目");
        this.add(label);

        //让文本标签居中
        label.setHorizontalAlignment(SwingConstants.CENTER);

        //获得一个容器
        Container container = this.getContentPane();
        container.setBackground(Color.PINK);

    }
}

2.2 弹窗

  package lesson04;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

//主窗口
public class DialogDemo extends JFrame {

    public DialogDemo() {
        //初始化
        this.setVisible(true);
        this.setSize(700, 500);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        //JFrame放东西需要容器
        Container container = this.getContentPane();
        //绝对布局/定位
        container.setLayout(null);

        //按钮
        JButton button = new JButton("点击弹出一个对话框");//创建对象
        button.setBounds(30, 30, 200, 50);

        //点击这个按钮的时候，弹出一个弹窗
        button.addActionListener(new ActionListener() { //监听器
            @Override
            public void actionPerformed(ActionEvent e) {
                //弹窗
                new MyDialogDemo();
            }
        });
        //加到容器里
        container.add(button);
    }
    public static void main(String[] args) {
        new DialogDemo();
    }
}

//弹窗的窗口
class MyDialogDemo extends JDialog {
    public MyDialogDemo() {
        this.setVisible(true);
        this.setBounds(100, 100, 500, 500);
        //报错:弹窗关闭功能已经实现，不用继续专门写入
        //this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        Container container = this.getContentPane();
        container.setLayout(null);

        container.add(new Label("学java"));
    }
}

在这里插入图片描述
2.3 标签

图标

package lesson04;

import javax.swing.*;
import java.awt.*;

//图标，需要实现类，继承JFrame,使用弹窗implements
public class IconDemo extends JFrame implements Icon {
    private int width;
    private int height;
    //无参构造器
    public IconDemo() {

    }
    //构造器
    public IconDemo(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public void init() {
        IconDemo iconDemo = new IconDemo(15, 15);
        //图标放在标签，也可以放在按钮上！
        JLabel label = new JLabel("icontest", iconDemo, SwingConstants.CENTER);

        Container container = getContentPane();
        container.add(label);//生成label对象才能放进去

        this.setVisible(true);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        new IconDemo().init();
    }

    @Override
    public void paintIcon(Component c, Graphics g, int x, int y) {
        g.fillOval(x, y, width, height);
    }

    @Override
    public int getIconWidth() {
        return this.width;
    }

    @Override
    public int getIconHeight() {
        return this.height;
    }
}

在这里插入图片描述

图片

package lesson04;

import javax.swing.*;
import java.awt.*;
import java.net.URL;

public class ImageIconDemo extends JFrame {
    public ImageIconDemo() {
        //获取图片的地址,一般要写入到标签
        JLabel label = new JLabel("ImageIcon");
        URL ur1 = ImageIconDemo.class.getResource("zzz.jpg");//获取菜单栏中的文件

        ImageIcon imageIcon = new ImageIcon(ur1);
        label.setIcon(imageIcon);
        label.setHorizontalAlignment(SwingConstants.CENTER);//居中

        Container container = getContentPane();
        container.add(label);

        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setBounds(100, 100, 200, 200);
    }

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

在这里插入图片描述

2.4 面板

JPanel

package lesson05;

import javax.swing.*;
import java.awt.*;

public class JPanelDemo extends JFrame {

    public JPanelDemo() {
        //第一步，所有东西放在container里面，针对它操作
        Container container = this.getContentPane();
        //设置容器的样子
        container.setLayout(new GridLayout(2, 1, 10, 10)); //后面两个参数表示间距

        JPanel panel1 = new JPanel(new GridLayout(1, 3));
        JPanel panel2 = new JPanel(new GridLayout(1, 2));
        JPanel panel3 = new JPanel(new GridLayout(2, 1));
        JPanel panel4 = new JPanel(new GridLayout(3, 2));

        panel1.add(new JButton("1"));
        panel1.add(new JButton("1"));
        panel1.add(new JButton("1"));
        panel2.add(new JButton("2"));
        panel2.add(new JButton("2"));
        panel3.add(new JButton("3"));
        panel3.add(new JButton("3"));
        panel4.add(new JButton("4"));
        panel4.add(new JButton("4"));
        panel4.add(new JButton("4"));
        panel4.add(new JButton("4"));
        panel4.add(new JButton("4"));
        panel4.add (new JButton("4"));

        container.add(panel1);//把面板加到容器内
        container.add(panel2);
        container.add(panel3);
        container.add(panel4);

        this.setVisible(true);
        this.setSize(500, 500);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

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

    }
}

在这里插入图片描述

JScrollPanel

package lesson05;

import javax.swing.*;
import java.awt.*;

public class JScrollDemo extends JFrame {

    public JScrollDemo() {
        Container container = this.getContentPane();

        //文本域
        JTextArea textArea = new JTextArea(20, 50);
        textArea.setText("欢迎学习狂神说java");

        //Scroll面板
        JScrollPane scrollPane = new JScrollPane(textArea);
        container.add(scrollPane); //把面板丢到容器里

        this.setVisible(true);
        this.setBounds(100, 100, 300, 350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

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

2.5 按钮

图片按钮

package lesson05;

import javax.swing.*;
import java.awt.*;
import java.net.URL;

public class JButtonDemo01 extends JFrame {

    //初始化:构造/初始化方法都可以实现
    public JButtonDemo01() {
        Container container = this.getContentPane();
        //图片变为图标
        URL url = JButtonDemo01.class.getResource("ppkq.png");
        Icon icon = new ImageIcon(url);//需要手动编程Icon

        //图标放在按钮上
        JButton button = new JButton();
        button.setIcon(icon);
        button.setToolTipText("图片按钮");

        //按钮加到容器上
        container.add(button);

        this.setVisible(true);
        this.setSize(500, 300);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

    }

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

在这里插入图片描述

单选按钮

package lesson05;

import javax.swing.*;
import java.awt.*;
import java.net.URL;

public class JButtonDemo02 extends JFrame{

    public JButtonDemo02() {
        Container container = this.getContentPane();
        //图片变为图标
        URL url = JButtonDemo02.class.getResource("ppkq.png");
        Icon icon = new ImageIcon(url);//需要手动编程Icon

        //单选框
        JRadioButton jRadioButton01 = new JRadioButton("JRadioButton01");
        JRadioButton jRadioButton02 = new JRadioButton("JRadioButton02");
        JRadioButton jRadioButton03 = new JRadioButton("JRadioButton03");

        //由于单选框只能选择一个，分组,一个组中只能选一个
        ButtonGroup group = new ButtonGroup();
        group.add(jRadioButton01);
        group.add(jRadioButton02);
        group.add(jRadioButton03);

        container.add(jRadioButton01, BorderLayout.CENTER);
        container.add(jRadioButton02, BorderLayout.NORTH);
        container.add(jRadioButton03, BorderLayout.SOUTH);

        this.setVisible(true);
        this.setSize(500, 300);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

    }

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

在这里插入图片描述

复选按钮

package lesson05;

import javax.swing.*;
import java.awt.*;
import java.net.URL;

public class JButtonDemo03 extends JFrame{
    public JButtonDemo03() {
        Container container = this.getContentPane();
        //图片变为图标
        URL url = JButtonDemo03.class.getResource("ppkq.png");
        Icon icon = new ImageIcon(url);//需要手动编程Icon

        //多选框
        JCheckBox CheckBox01 = new JCheckBox("CheckBox01");
        JCheckBox CheckBox02 = new JCheckBox("CheckBox02");

        //放到容器里
        container.add(CheckBox01, BorderLayout.NORTH);
        container.add(CheckBox02, BorderLayout.SOUTH);
        
        this.setVisible(true);
        this.setSize(500, 300);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

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

在这里插入图片描述

2.6 列表

下拉框

package lessson06;

import javax.swing.*;
import java.awt.*;

public class TestComboboxDemo01 extends JFrame {
    public TestComboboxDemo01() {
        Container container = this.getContentPane();

        JComboBox status = new JComboBox ();
        status.addItem(null);
        status.addItem("正在热映");
        status.addItem("已下架");
        status.addItem("即将上映");

        container.add(status);

        this.setVisible(true);
        this.setSize(500, 350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {

        new TestComboboxDemo01();
    }
}

在这里插入图片描述

列表框

package lessson06;

import javax.swing.*;
import java.awt.*;
import java.util.Vector;

public class TestComboboxDemo02 extends JFrame{
    public TestComboboxDemo02() {
        Container container = this.getContentPane();

        //生成列表的内容
        //String[] content  = {"1", "2", "3"}; //静态变量
        Vector content = new Vector(); //动态变量

        //列表中需要放内容
        JList jList = new JList(content);

        content.add("zhangsan");
        content.add("lisi");
        content.add("wangwu");

        container.add(jList); 

        this.setVisible(true);
        this.setSize(500, 350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

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

在这里插入图片描述

应用场景 :

选择地区，或者是一些单个选项
列表，展示信息，一般是动态扩容！

2.7 文本框

文本框

package lessson06;

import javax.swing.*;
import java.awt.*;

public class TestTextDemo01 extends JFrame {
    public TestTextDemo01() {
        Container container = this.getContentPane();

        JTextField textField = new JTextField("hello");
        JTextField textField2 = new JTextField("world");

        container.add(textField, BorderLayout.NORTH);
        container.add(textField2, BorderLayout.SOUTH);

        this.setVisible(true);
        this.setSize(500, 350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

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

}

在这里插入图片描述

密码框

package lessson06;

import javax.swing.*;
import java.awt.*;

public class TestTextDemo02 extends JFrame{
    public TestTextDemo02() {
        Container container = this.getContentPane();

        JPasswordField passwordField = new JPasswordField(); //不用手动***
        passwordField.setEchoChar('*');

        container.add(passwordField);

        this.setVisible(true);
        this.setSize(500, 350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

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

在这里插入图片描述

文本域

见JScrollDemo.java…

第三章实战玩法 - 贪吃蛇

实现要素

帧：如果时间片足够小，就是动画（一秒30帧、60帧）。连起来是动画，拆开就是图片
键盘监听：
定时器 Timer

代码实现

定义数据
初始化
画上去
监听事件（键盘监听/事件监听）

Data部分

package snake;
import javax.swing.*;
import java.net.URL;

//数据中心
public class Data {
    //相对路径: tx.jpg
    //绝对路径: / 相当于当前的项目
    public static URL headerURL = Data.class.getResource("statics/header.png");
    public static ImageIcon header = new ImageIcon(headerURL);

    //其他都是一样的代码
    public static URL upURL = Data.class.getResource("statics/up.png");
    public static URL downURL = Data.class.getResource("statics/down.png");
    public static URL leftURL = Data.class.getResource("statics/left.png");
    public static URL rightURL = Data.class.getResource("statics/right.png");
    //同样封装成 ImageIcon
    public static ImageIcon up = new ImageIcon(upURL);
    public static ImageIcon down = new ImageIcon(downURL);
    public static ImageIcon left = new ImageIcon(leftURL);
    public static ImageIcon right = new ImageIcon(rightURL);

    public static URL bodyURL = Data.class.getResource("statics/body.png");
    public static ImageIcon body = new ImageIcon(bodyURL);

    public static URL foodURL = Data.class.getResource("statics/food.png");
    public static ImageIcon food = new ImageIcon(foodURL);

}

GamePanel部分

package snake;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;

//游戏的面板
public class GamePanel extends JPanel implements KeyListener, ActionListener { //继承类，自带方法

    //定义蛇的数据结构->初始化->放进去监听
    int length;//蛇的长度
    int[] snakeX = new int[600];//蛇的x坐标
    int[] snakeY = new int[500];//蛇的Y坐标
    String fx = "R";//初始方向向右

    //食物的坐标
    int foodx;
    int foody;
    Random random = new Random();

    int score;//分数

    //游戏当前的状态：开始 停止
    boolean isStart = false;//默认不开始游戏！

    boolean isFail = false;//默认游戏没有失败

    //定时器(要实现ActionListener接口)-以毫秒为单位
    Timer timer = new Timer(100, this);//每100毫秒执行一次，监听的是this这个类

    //构造器 调用init方法，new的时候自动被初始化
    public GamePanel() {
        init();
        //获得焦点和键盘事件
        this.setFocusable(true);//获得焦点事件
        this.addKeyListener(this);//获得键盘监听事件
        timer.start();//游戏一开始，定时器就启动
    }
    //初始化方法
    public void init() {
        length = 3;
        snakeX[0] = 100; snakeY[0] = 100; //头的初始坐标
        snakeX[1] = 75; snakeY[1] = 100; //第一个身体坐标
        snakeX[2] = 50; snakeY[2] = 100; //第二个身体坐标
        fx = "R";//初始方向向右

        //把食物随机分布在界面上
        foodx = 25 + 25 * random.nextInt(34);
        foody = 75 + 25 * random.nextInt(24);

        score = 0;
    }


    //绘制面板，游戏中的所有东西，都使用这个画笔来完成
    @Override //面板做好add进主方法的frame中就可以了
    protected void paintComponent(Graphics g) {
        super.paintComponent(g); //清屏，防闪烁
        //绘制静态面板
        this.setBackground(Color.WHITE);
        //放入头部广告栏
        Data.header.paintIcon(this, g, 25, 11);//放那个组件上?,用那个画笔画?,画到那个位置?
        g.fillRect(25, 75, 850, 600);//默认的游戏界面

        //画积分
        g.setColor(Color.WHITE);
        g.setFont(new Font("微软雅黑", Font.BOLD, 18));
        g.drawString("长度: " + length, 750, 30);
        g.drawString("得分: " + score, 750, 54);

        //先画食物，再画身体，就不会盖住头
        Data.food.paintIcon(this, g, foodx, foody);

        //把小蛇画上去
        if(fx.equals("R")) {
            Data.right.paintIcon(this, g, snakeX[0], snakeY[0]);//蛇头初始化向右,需要通过方向来判断
        } else if(fx.equals("L")) {
            Data.left.paintIcon(this, g, snakeX[0], snakeY[0]);//蛇头初始化向右,需要通过方向来判断
        } else if(fx.equals("U")) {
            Data.up.paintIcon(this, g, snakeX[0], snakeY[0]);//蛇头初始化向右,需要通过方向来判断
        } else if(fx.equals("D")) {
            Data.down.paintIcon(this, g, snakeX[0], snakeY[0]);//蛇头初始化向右,需要通过方向来判断
        }

        for (int i = 1; i < length; i++) { //头不能变了，从第一节身体开始变换，一直延长
            Data.body.paintIcon(this, g, snakeX[i], snakeY[i]);//每次变换就画一次身体，相当于身体就动起来了
        }

        //游戏状态
        if(isStart == false) {
            g.setColor(Color.WHITE);
            g.setFont(new Font("微软雅黑", Font.BOLD, 40));//设置字体
            g.drawString("按下空格开始游戏", 300, 300);
        }

        if(isFail) {
            g.setColor(Color.RED);
            g.setFont(new Font("微软雅黑", Font.BOLD, 40));//设置字体
            g.drawString("游戏失败，按下空格重新开始", 300, 300);
        }

    }

    //键盘监听事件
    //直接实现使用内部类
    @Override
    public void keyPressed(KeyEvent e) {
        int keyCode = e.getKeyCode();//获得键盘按键
        if(keyCode == KeyEvent.VK_SPACE) { //如果按下的是空格键
            if(isFail) { //先判断游戏是否结束，如果结束就重新开始
                isFail = false;
                init();
            } else { //如果没有结束，才按下空格开始/停止
                isStart = !isStart;//取反操作，按一下继续/暂停
                repaint();//重新绘制
            }
        }
        //小蛇移动
        if(keyCode == KeyEvent.VK_UP) {
            fx = "U";
        } else if(keyCode == KeyEvent.VK_DOWN) {
            fx = "D";
        } else if(keyCode == KeyEvent.VK_LEFT) {
            fx = "L";
        } else if(keyCode == KeyEvent.VK_RIGHT) {
            fx = "R";
        }
    }

    //事件监听(需要通过固定事件来刷新，1s=10次)
    @Override
    public void actionPerformed(ActionEvent e) {
        if(isStart && isFail == false) { //如果游戏没有处于失败状态并且是开始状态，就让小蛇动起来
            //吃食物
            if(snakeX[0] == foodx && snakeY[0] == foody) { //重合判断
                length++;//小蛇长度增加
                score += 10;//分数增加
                //再次随机食物
                foodx = 25 + 25 * random.nextInt(34);
                foody = 75 + 25 * random.nextInt(24);
            }

            //身体移动是固定的，后一节到前一节的位置即可
            for (int i = length - 1; i > 0; i--) { //身体长度等于length - 1
                snakeX[i] = snakeX[i - 1];//向前移动一节，前一节=后一节(如第一节身体移到头)
                snakeY[i] = snakeY[i - 1];//x，y坐标都向前移动，那么位置就都变了
            }

            //控制头部走向
            if(fx.equals("R")) {
                snakeX[0] = snakeX[0] + 25;
                if (snakeX[0] > 850) { //边界判断
                    snakeX[0] = 25;//回到最初的样子
                }
            }
            else if(fx.equals("L")) {
                snakeX[0] = snakeX[0] - 25;
                if(snakeX[0] < 25) { //边界判断
                    snakeX[0] = 850;//回到最初的样子
                }
            }
            else if(fx.equals("U")) {
                snakeY[0] = snakeY[0] - 25;
                if(snakeY[0] < 75) { //左右动x轴，上下动y轴
                    snakeY[0] = 650;
                }
            }
            else if(fx.equals("D")) {
                snakeY[0] = snakeY[0] + 25;
                if(snakeY[0] > 650) { //左右动x轴，上下动y轴
                    snakeY[0] = 75;
                }
            }

            //失败判定：撞到自己就算失败
            for (int i = 1; i < length; i++) {
                if(snakeX[0] == snakeX[i] && snakeY[0] == snakeY[i]) { //遍历所有身子坐标，如果头和任意一个身子重合，就失败了
                    isFail = true;
                }
            }
            repaint();//变完就重画页面
        }
        timer.start();//定时器开启
    }

    @Override //没用的放在最下面
    public void keyReleased(KeyEvent e) {

    }
    @Override
    public void keyTyped(KeyEvent e) {

    }
}

StartGame部分

package snake;

import javax.swing.*;

//游戏主启动类
public class StartGame {
    public static void main(String[] args) {
        JFrame frame = new JFrame();

        frame.setSize(900, 720);
        frame.setResizable(false);//窗口大小不可变
        //正常游戏界面都应该在面板上！！！！！！主程序只管启动！！！！！！
        frame.add(new GamePanel());

        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.setVisible(true);//放最后
    }
}