[Java知识库]【Java】GUI实现贪吃蛇

【Java】GUI实现贪吃蛇

前言

我们在做这个小游戏之前，得确保自己的AWT和Swing有一定的基础，并且会写一些简单的逻辑操作。这些都会在后面写的时候体现出来。

狂神老师从这里开始讲贪吃蛇的

我们在看视频的时候都知道，视频是一帧一帧播放的，一般我们看动画的帧率是每秒24帧。

我们在GUI中实现帧率的，通过不断刷新实现

此外，我们要通过键盘监听来监听键盘的上下左右操作来控制小蛇的移动

还需要通过定时器Timer来实现

文章中的贪吃蛇代码源码已经给出了，这里还有一份我自己构建的jar包，下载地址

1、构建静态页面

效果如下：

我们创建一个游戏启动类，一个图片资源类，一个面板类

其中游戏启动类用于启动这个JFrame，图片资源就是用来加载图片资源的，面板就是用来放顶部的背景和小蛇存在的区域的

• 游戏启动类

  package top.woodwhale.snake;
  
  import javax.swing.*;
  
  // 游戏的主启动类
  public class StartGame {
      public static void main(String[] args) {
          JFrame frame = new JFrame();
  
          frame.setBounds(10,10,900,720);
          frame.setResizable(false);      // 设置窗口大小不变
          frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
          frame.add(new GamePanel());     // 增加游戏面板
          frame.setVisible(true);
      }
  }
  

• 资源类

  package top.woodwhale.snake;
  
  import javax.swing.*;
  import java.net.URL;
  
  public class Data {
  
      // 相对路径和绝对路径都可以使用
      public static URL headerURL = Data.class.getResource("statics/img/header.png");
      public static ImageIcon header = new ImageIcon(headerURL);
  
      public static URL upRUL = Data.class.getResource("statics/img/up.png");
      public static ImageIcon up = new ImageIcon(upRUL);
  
      public static URL downURL = Data.class.getResource("statics/img/down.png");
      public static ImageIcon down = new ImageIcon(downURL);
  
      public static URL leftURL = Data.class.getResource("statics/img/left.png");
      public static ImageIcon left = new ImageIcon(leftURL);
  
      public static URL rightURL = Data.class.getResource("statics/img/right.png");
      public static ImageIcon right = new ImageIcon(rightURL);
  
      public static URL bodyURL = Data.class.getResource("statics/img/body.png");
      public static ImageIcon body = new ImageIcon(bodyURL);
  
      public static URL foodURL = Data.class.getResource("statics/img/food.png");
      public static ImageIcon food = new ImageIcon(foodURL);
  
  }
  

• 游戏面板类

  package top.woodwhale.snake;
  
  import javax.swing.*;
  import java.awt.*;
  
  // 游戏面板
  public class GamePanel extends JPanel {
      // 绘制面板，游戏中的所有东西都用这个画笔来画
      @Override
      public void paintComponent(Graphics g) {
          super.paintComponent(g);    // 清除屏幕的作用
  
          // 绘制静态面板
          this.setBackground(Color.white);
          Data.header.paintIcon(this,g,25,11);    // 画上头部广告栏
          g.fillRect(25,75,850,600);      // 默认的游戏界面
  
      }
  }
  

2、构建小蛇位置

这一部分，我们在GamePanel类中添加了一些小蛇的信息，来绘制小蛇，并且对小蛇的属性进行定义。

效果如下：

代码：

package top.woodwhale.snake;

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

// 游戏面板
public class GamePanel extends JPanel {

    // 定义小蛇的数据结构
    int length;     // 蛇的长度
    int[] snakeX = new int[600];    // 蛇的x坐标 25*25
    int[] snakeY = new int[600];    // 蛇的y坐标
    String dictionary;        // 蛇头的方向
    boolean isStart;          // 游戏状态——是否开始

    public GamePanel() {
        init();     // 初始化
    }

    // 初始化方法
    public void init() {
        length = 3;
        snakeX[0] = 100;snakeY[0] = 100;    // 脑袋的坐标
        snakeX[1] = 75;snakeY[1] = 100;     // 第一个身体
        snakeX[2] = 50;snakeY[2] = 100;     // 第二个身体
        dictionary = "R";                   // 蛇头的初始方向
        isStart = false;                    // 默认游戏没开始
    }

    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);    // 清除屏幕的作用

        // 绘制静态面板
        this.setBackground(Color.white);
        Data.header.paintIcon(this,g,25,11);    // 画上头部广告栏
        g.fillRect(25,75,850,600);      // 默认的游戏界面

        // 判断蛇头方向
        if (dictionary.equals("R")) {
            Data.right.paintIcon(this,g,snakeX[0],snakeY[0]);   // 蛇头向右边
        } else if (dictionary.equals("L")) {
            Data.left.paintIcon(this,g,snakeX[0],snakeY[0]);    // 蛇头向左边
        } else if (dictionary.equals("U")) {
            Data.up.paintIcon(this,g,snakeX[0],snakeY[0]);      // 蛇头向上边
        } else {
            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) {
            g.setColor(Color.white);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Press Space To Start!",250,400);
        }
    }
}

3、监听键盘操作

我们仍然是在GamePanel类中实现键盘监听操作，我们直接让这个类使用KeyListener接口，重写三个键盘监听方法就可以实现键盘监听了

我们需要第一步做的就是按下空格开始/暂停，使用键盘监听空格键，如果按下了空格，那么我们就让游戏状态取反

package top.woodwhale.snake;

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

// 游戏面板
public class GamePanel extends JPanel implements KeyListener {

    // 定义小蛇的数据结构
    int length;     // 蛇的长度
    int[] snakeX = new int[600];    // 蛇的x坐标 25*25
    int[] snakeY = new int[600];    // 蛇的y坐标
    String dictionary;        // 蛇头的方向
    boolean isStart;          // 游戏状态——是否开始

    public GamePanel() {
        init();     // 初始化
        this.setFocusable(true);    // 获得焦点事件
        this.addKeyListener(this);  // 获取键盘监听，因为这个类是KeyListener类的接口，并且实现了监听方法，用this就好了
    }

    // 初始化方法
    public void init() {
        length = 3;
        snakeX[0] = 100;snakeY[0] = 100;    // 脑袋的坐标
        snakeX[1] = 75;snakeY[1] = 100;     // 第一个身体
        snakeX[2] = 50;snakeY[2] = 100;     // 第二个身体
        dictionary = "R";                   // 蛇头的初始方向
        isStart = false;                    // 默认游戏没开始
    }

    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);    // 清除屏幕的作用

        // 绘制静态面板
        this.setBackground(Color.white);
        Data.header.paintIcon(this,g,25,11);    // 画上头部广告栏
        g.fillRect(25,75,850,600);      // 默认的游戏界面

        // 判断蛇头方向
        if (dictionary.equals("R")) {
            Data.right.paintIcon(this,g,snakeX[0],snakeY[0]);   // 蛇头向右边
        } else if (dictionary.equals("L")) {
            Data.left.paintIcon(this,g,snakeX[0],snakeY[0]);    // 蛇头向左边
        } else if (dictionary.equals("U")) {
            Data.up.paintIcon(this,g,snakeX[0],snakeY[0]);      // 蛇头向上边
        } else {
            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) {
            g.setColor(Color.white);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Press Space To Start!",250,400);
        }
    }

    @Override
    public void keyTyped(KeyEvent keyEvent) {

    }

    // 键盘监听时间
    @Override
    public void keyPressed(KeyEvent keyEvent) {
        // 监听按下空格开始or暂停
        int keyCode = keyEvent.getKeyCode();
        if (keyCode == KeyEvent.VK_SPACE) {
            isStart = !isStart;     // 去反
            repaint();
        }
    }

    @Override
    public void keyReleased(KeyEvent keyEvent) {

    }
}

4、定时器使小蛇移动

在这一节中，我们要通过Timer类实现定时器，不断刷新、重画，让小蛇动起来，并且给小蛇监听键盘的上下左右

package top.woodwhale.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;

// 游戏面板
public class GamePanel extends JPanel implements KeyListener, ActionListener {

    // 定义小蛇的数据结构
    int length;     // 蛇的长度
    int[] snakeX = new int[600];    // 蛇的x坐标 25*25
    int[] snakeY = new int[600];    // 蛇的y坐标
    String dictionary;        // 蛇头的方向
    boolean isStart;          // 游戏状态——是否开始
    int preX;		// 改变方向时记录的坐标X
    int preY;		// 改变方向时记录的坐标Y

    // 定时器
    Timer timer;

    // 构造器
    public GamePanel() {
        init();     // 初始化
        this.setFocusable(true);    // 获得焦点事件
        this.addKeyListener(this);  // 获取键盘监听，因为这个类是KeyListener类的接口，并且实现了监听方法，用this就好了
    }

    // 初始化方法
    public void init() {
        length = 3;
        snakeX[0] = 100;snakeY[0] = 100;    // 脑袋的坐标
        snakeX[1] = 75;snakeY[1] = 100;     // 第一个身体
        snakeX[2] = 50;snakeY[2] = 100;     // 第二个身体
        preX = snakeX[0];preY = snakeY[0];
        dictionary = "R";                   // 蛇头的初始方向
        isStart = false;                    // 默认游戏没开始
        timer = new Timer(150,this);   // 监听this对象，按照1000ms执行一次
        timer.start();  // 游戏一开始定时器开始
    }

    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);    // 清除屏幕的作用

        // 绘制静态面板
        this.setBackground(Color.white);
        Data.header.paintIcon(this,g,25,11);    // 画上头部广告栏
        g.fillRect(25,75,850,600);      // 默认的游戏界面

        // 判断蛇头方向
        switch (dictionary) {
            case "R":
                Data.right.paintIcon(this, g, snakeX[0], snakeY[0]);   // 蛇头向右边

                break;
            case "L":
                Data.left.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向左边

                break;
            case "U":
                Data.up.paintIcon(this, g, snakeX[0], snakeY[0]);      // 蛇头向上边

                break;
            case "D":
                Data.down.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向下边

                break;
        }

        // 蛇的身体
        for (int i = 1; i < length; i++) {
            Data.body.paintIcon(this,g,snakeX[i],snakeY[i]);
        }

        // 游戏状态
        if (!isStart) {
            g.setColor(Color.white);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Press Space To Start!",250,400);
        }
    }

    @Override
    public void keyTyped(KeyEvent keyEvent) {

    }

    // 键盘监听时间
    @Override
    public void keyPressed(KeyEvent keyEvent) {
        // 监听按下空格开始or暂停
        int keyCode = keyEvent.getKeyCode();
        if (keyCode == KeyEvent.VK_SPACE) {
            isStart = !isStart;     // 去反
            repaint();
        }

        // 改变小蛇方向，必须满足按照当前方向走了一格以上才能改变方向
        if (Math.abs(preX - snakeX[0]) >= 25 || Math.abs(preY - snakeY[0]) >= 25) {
            switch (keyCode) {
                case KeyEvent.VK_UP:
                    if (!dictionary.equals("D")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "U";
                    }
                    break;
                case KeyEvent.VK_DOWN:
                    if (!dictionary.equals("U")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "D";
                    }
                    break;
                case KeyEvent.VK_LEFT:
                    if (!dictionary.equals("R")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "L";
                    }
                    break;
                case KeyEvent.VK_RIGHT:
                    if (!dictionary.equals("L")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "R";
                    }
                    break;
            }
        }

    }

    @Override
    public void keyReleased(KeyEvent keyEvent) {

    }

    // 重写事件监听方法——需要通过固定的事件来刷新，设置帧率
    @Override
    public void actionPerformed(ActionEvent actionEvent) {
        // 如果游戏是开始状态，就让小蛇动起来
        if (isStart) {
            // 后一节移动到前一节的位置
            for (int i = length-1; i > 0; i--) {
                snakeY[i] = snakeY[i-1];
                snakeX[i] = snakeX[i-1];
            }

            // 让小蛇的头动起来
            switch (dictionary) {
                case "R":
                    snakeX[0] += 25;
                    break;
                case "L":
                    snakeX[0] -= 25;
                    break;
                case "U":
                    snakeY[0] -= 25;
                    break;
                case "D":
                    snakeY[0] += 25;
                    break;
            }

            // 如果小蛇出界就回到最初的起点
            if (snakeX[0] > 850) {
                snakeX[0] = 25;
            } else if (snakeX[0] < 25) {
                snakeX[0] = 850;
            }
            if (snakeY[0] > 650) {
                snakeY[0] = 75;
            } else if (snakeY[0] < 75) {
                snakeY[0] = 650;
            }

            repaint();  // 重新画页面
            timer.start();  // 定时器开始
        }
    }
}

5、判断小蛇吃果子

如何判断小蛇吃到果子呢？果子应该在哪里生成呢？

• 小蛇头和果子坐标重合就是吃到果子了
• 果子用随机数生成
• 如果果子生成在小蛇身体里，就重新生成
• 每次吃完一次果子，果子没消失，而是坐标转移

package top.woodwhale.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.Arrays;
import java.util.Random;
import java.util.stream.Collectors;

// 游戏面板
public class GamePanel extends JPanel implements KeyListener, ActionListener {

    // 定义小蛇的数据结构
    int length;     // 蛇的长度
    int[] snakeX = new int[600];    // 蛇的x坐标 25*25
    int[] snakeY = new int[600];    // 蛇的y坐标
    String dictionary;        // 蛇头的方向
    boolean isStart;          // 游戏状态——是否开始
    int preX;       // 改变方向时记录的坐标X
    int preY;       // 改变方向时记录的坐标Y
    int foodX;      // 食物的X坐标
    int foodY;      // 食物的Y坐标
    Random random = new Random();   // 随即器
    Timer timer = new Timer(100,this);   // 定时器，监听this对象，按照100ms执行一次

    // 构造器
    public GamePanel() {
        init();     // 初始化
        this.setFocusable(true);    // 获得焦点事件
        this.addKeyListener(this);  // 获取键盘监听，因为这个类是KeyListener类的接口，并且实现了监听方法，用this就好了
    }

    // 初始化方法
    public void init() {
        length = 3;
        snakeX[0] = 100;snakeY[0] = 100;    // 脑袋的坐标
        snakeX[1] = 75;snakeY[1] = 100;     // 第一个身体
        snakeX[2] = 50;snakeY[2] = 100;     // 第二个身体
        preX = snakeX[0];preY = snakeY[0];  // 刚开始的时候，记录刚开始的脑袋坐标
        randomFood();   // 随机食物
        dictionary = "R";                   // 蛇头的初始方向
        isStart = false;                    // 默认游戏没开始
        timer.start();  // 游戏一开始定时器开始
    }

    public void randomFood() {
        foodX = 25 + 25 * random.nextInt(34);   // 随机食物
        foodY = 75 + 25 * random.nextInt(24);   // 随机食物
        java.util.List<Integer> tmpX = Arrays.stream(snakeX).boxed().collect(Collectors.toList());
        java.util.List<Integer> tmpY = Arrays.stream(snakeY).boxed().collect(Collectors.toList());
        // 如果食物在身体里，就刷新
        if (tmpX.contains(foodX) || tmpY.contains(foodY)) {
            randomFood();
        }
    }

    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);    // 清除屏幕的作用

        // 绘制静态面板
        this.setBackground(Color.white);
        Data.header.paintIcon(this,g,25,11);    // 画上头部广告栏
        g.fillRect(25,75,850,600);      // 默认的游戏界面

        // 判断蛇头方向
        switch (dictionary) {
            case "R":
                Data.right.paintIcon(this, g, snakeX[0], snakeY[0]);   // 蛇头向右边
                break;
            case "L":
                Data.left.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向左边
                break;
            case "U":
                Data.up.paintIcon(this, g, snakeX[0], snakeY[0]);      // 蛇头向上边
                break;
            case "D":
                Data.down.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向下边
                break;
        }

        // 蛇的身体
        for (int i = 1; i < length; i++) {
            Data.body.paintIcon(this,g,snakeX[i],snakeY[i]);
        }

        // 画食物
        Data.food.paintIcon(this,g,foodX,foodY);

        // 游戏状态
        if (!isStart) {
            g.setColor(Color.white);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Press Space To Start!",250,400);
        }
    }

    @Override
    public void keyTyped(KeyEvent keyEvent) {

    }

    // 键盘监听时间
    @Override
    public void keyPressed(KeyEvent keyEvent) {
        // 监听按下空格开始or暂停
        int keyCode = keyEvent.getKeyCode();
        if (keyCode == KeyEvent.VK_SPACE) {
            isStart = !isStart;     // 去反
            repaint();
        }

        // 改变小蛇方向，必须满足按照当前方向走了一格以上才能改变方向
        if (Math.abs(preX - snakeX[0]) >= 25 || Math.abs(preY - snakeY[0]) >= 25) {
            switch (keyCode) {
                case KeyEvent.VK_UP:
                    if (!dictionary.equals("D")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "U";
                    }
                    break;
                case KeyEvent.VK_DOWN:
                    if (!dictionary.equals("U")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "D";
                    }
                    break;
                case KeyEvent.VK_LEFT:
                    if (!dictionary.equals("R")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "L";
                    }
                    break;
                case KeyEvent.VK_RIGHT:
                    if (!dictionary.equals("L")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "R";
                    }
                    break;
            }
        }

    }

    @Override
    public void keyReleased(KeyEvent keyEvent) {

    }

    // 重写事件监听方法——需要通过固定的事件来刷新，设置帧率
    @Override
    public void actionPerformed(ActionEvent actionEvent) {
        // 如果游戏是开始状态，就让小蛇动起来
        if (isStart) {

            // 后一节移动到前一节的位置
            for (int i = length-1; i > 0; i--) {
                snakeY[i] = snakeY[i-1];
                snakeX[i] = snakeX[i-1];
            }

            // 让小蛇的头动起来
            switch (dictionary) {
                case "R":
                    snakeX[0] += 25;
                    break;
                case "L":
                    snakeX[0] -= 25;
                    break;
                case "U":
                    snakeY[0] -= 25;
                    break;
                case "D":
                    snakeY[0] += 25;
                    break;
            }

            // 如果小蛇的头吃到食物就变长
            if (snakeY[0] == foodY && snakeX[0] == foodX) {
                length++;
                snakeX[length-1] = snakeX[length-2];
                snakeY[length-1] = snakeY[length-2];
                randomFood();
            }

            // 如果小蛇出界就回到最初的起点
            if (snakeX[0] > 850) {
                snakeX[0] = 25;
            } else if (snakeX[0] < 25) {
                snakeX[0] = 850;
            }
            if (snakeY[0] > 650) {
                snakeY[0] = 75;
            } else if (snakeY[0] < 75) {
                snakeY[0] = 650;
            }

            repaint();  // 重新画页面
            timer.start();  // 定时器开始
        }
    }
}

6、游戏失败判断

小蛇的头与身体任意部分的坐标重合，就是失败

package top.woodwhale.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.Arrays;
import java.util.Random;
import java.util.stream.Collectors;

// 游戏面板
public class GamePanel extends JPanel implements KeyListener, ActionListener {

    // 定义小蛇的数据结构
    int length;     // 蛇的长度
    int[] snakeX = new int[600];    // 蛇的x坐标 25*25
    int[] snakeY = new int[600];    // 蛇的y坐标
    String dictionary;        // 蛇头的方向
    boolean isStart;          // 游戏状态——是否开始
    boolean isFail;           // 是否失败
    int preX;       // 改变方向时记录的坐标X
    int preY;       // 改变方向时记录的坐标Y
    int foodX;      // 食物的X坐标
    int foodY;      // 食物的Y坐标
    int score;      // 积分
    Random random = new Random();   // 随即器
    Timer timer = new Timer(150,this);   // 定时器，监听this对象，按照150ms执行一次

    // 构造器
    public GamePanel() {
        init();     // 初始化
        this.setFocusable(true);    // 获得焦点事件
        this.addKeyListener(this);  // 获取键盘监听，因为这个类是KeyListener类的接口，并且实现了监听方法，用this就好了
    }

    // 初始化方法
    public void init() {
        length = 3;
        score = 0;                          // 初始积分为0
        snakeX[0] = 100;snakeY[0] = 100;    // 脑袋的坐标
        snakeX[1] = 75;snakeY[1] = 100;     // 第一个身体
        snakeX[2] = 50;snakeY[2] = 100;     // 第二个身体
        preX = snakeX[0];preY = snakeY[0];  // 刚开始的时候，记录刚开始的脑袋坐标
        randomFood();   // 随机食物
        dictionary = "R";                   // 蛇头的初始方向
        isStart = false;                    // 默认游戏没开始
        timer.start();  // 游戏一开始定时器开始
    }

    // 随机食物
    public void randomFood() {
        foodX = 25 + 25 * random.nextInt(34);   // 随机食物
        foodY = 75 + 25 * random.nextInt(24);   // 随机食物
        java.util.List<Integer> tmpX = Arrays.stream(snakeX).boxed().collect(Collectors.toList());
        java.util.List<Integer> tmpY = Arrays.stream(snakeY).boxed().collect(Collectors.toList());
        // 如果食物在身体里，就刷新
        if (tmpX.contains(foodX) || tmpY.contains(foodY)) {
            randomFood();
        }
    }

    // 失败判定，碰到自己就失败
    public void isGameOver() {
        for (int i = 1; i < length; i++) {
            if (snakeY[0] == snakeY[i] && snakeX[0] == snakeX[i]) {
                isFail = true;
                break;
            }
        }
    }

    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public 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.orange);
        g.setFont(new Font("Chilanka",Font.BOLD,18));
        g.drawString("Length : " + length,750,30);
        g.drawString("Score : " + score,750,55);

        // 画食物
        Data.food.paintIcon(this,g,foodX,foodY);

        // 判断蛇头方向
        switch (dictionary) {
            case "R":
                Data.right.paintIcon(this, g, snakeX[0], snakeY[0]);   // 蛇头向右边
                break;
            case "L":
                Data.left.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向左边
                break;
            case "U":
                Data.up.paintIcon(this, g, snakeX[0], snakeY[0]);      // 蛇头向上边
                break;
            case "D":
                Data.down.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向下边
                break;
        }

        // 蛇的身体
        for (int i = 1; i < length; i++) {
            Data.body.paintIcon(this,g,snakeX[i],snakeY[i]);
        }

        // 游戏状态
        if (!isStart) {
            g.setColor(Color.white);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Press Space To Start !",250,400);
        }

        if (isFail) {
            g.setColor(Color.red);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Failed ! Space Again ?!",250,400);
        }
    }

    @Override
    public void keyTyped(KeyEvent keyEvent) {

    }

    // 键盘监听时间
    @Override
    public void keyPressed(KeyEvent keyEvent) {
        // 监听按下空格开始or暂停
        int keyCode = keyEvent.getKeyCode();
        if (keyCode == KeyEvent.VK_SPACE) {
            if (isFail) {   // 失败了重新开始
                isFail = false;
                init();
            } else {    // 否则就是暂停、开始
                isStart = !isStart;     // 去反
            }
            repaint();
        }

        // 改变小蛇方向，必须满足按照当前方向走了一格以上才能改变方向
        if (Math.abs(preX - snakeX[0]) >= 25 || Math.abs(preY - snakeY[0]) >= 25) {
            switch (keyCode) {
                case KeyEvent.VK_UP:
                    if (!dictionary.equals("D")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "U";
                    }
                    break;
                case KeyEvent.VK_DOWN:
                    if (!dictionary.equals("U")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "D";
                    }
                    break;
                case KeyEvent.VK_LEFT:
                    if (!dictionary.equals("R")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "L";
                    }
                    break;
                case KeyEvent.VK_RIGHT:
                    if (!dictionary.equals("L")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "R";
                    }
                    break;
            }
        }

    }

    @Override
    public void keyReleased(KeyEvent keyEvent) {

    }

    // 重写事件监听方法——需要通过固定的事件来刷新，设置帧率
    @Override
    public void actionPerformed(ActionEvent actionEvent) {
        // 如果游戏是开始状态，就让小蛇动起来
        if (isStart && !isFail) {

            // 后一节移动到前一节的位置
            for (int i = length-1; i > 0; i--) {
                snakeY[i] = snakeY[i-1];
                snakeX[i] = snakeX[i-1];
            }

            // 让小蛇的头动起来
            switch (dictionary) {
                case "R":
                    snakeX[0] += 25;
                    break;
                case "L":
                    snakeX[0] -= 25;
                    break;
                case "U":
                    snakeY[0] -= 25;
                    break;
                case "D":
                    snakeY[0] += 25;
                    break;
            }

            // 如果小蛇的头吃到食物就变长
            if (snakeY[0] == foodY && snakeX[0] == foodX) {
                score += 10;    // 每吃一个分数加10
                length++;       // 每吃一个长度加1
                snakeX[length-1] = snakeX[length-2];
                snakeY[length-1] = snakeY[length-2];
                randomFood();
            }

            // 如果小蛇出界就回到最初的起点
            if (snakeX[0] > 850) {
                snakeX[0] = 25;
            } else if (snakeX[0] < 25) {
                snakeX[0] = 850;
            }
            if (snakeY[0] > 650) {
                snakeY[0] = 75;
            } else if (snakeY[0] < 75) {
                snakeY[0] = 650;
            }


            // 失败判定，碰到自己就失败
            isGameOver();

            repaint();  // 重新画页面
            timer.start();  // 定时器开始
        }
    }
}

总结

所有源码：

Data类

package top.woodwhale.snake;

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

public class Data {

    // 相对路径和绝对路径都可以使用
    public static URL headerURL = Data.class.getResource("statics/img/header.png");
    public static ImageIcon header = new ImageIcon(headerURL);

    public static URL upRUL = Data.class.getResource("statics/img/up.png");
    public static ImageIcon up = new ImageIcon(upRUL);

    public static URL downURL = Data.class.getResource("statics/img/down.png");
    public static ImageIcon down = new ImageIcon(downURL);

    public static URL leftURL = Data.class.getResource("statics/img/left.png");
    public static ImageIcon left = new ImageIcon(leftURL);

    public static URL rightURL = Data.class.getResource("statics/img/right.png");
    public static ImageIcon right = new ImageIcon(rightURL);

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

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

}

StartGame类

package top.woodwhale.snake;

import javax.swing.*;

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

        frame.setBounds(10,10,900,720);
        frame.setResizable(false);      // 设置窗口大小不变
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.add(new GamePanel());     // 增加游戏面板
        frame.setVisible(true);
    }
}

GamePanel类

package top.woodwhale.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.Arrays;
import java.util.Random;
import java.util.stream.Collectors;

// 游戏面板
public class GamePanel extends JPanel implements KeyListener, ActionListener {

    // 定义小蛇的数据结构
    int length;     // 蛇的长度
    int[] snakeX = new int[600];    // 蛇的x坐标 25*25
    int[] snakeY = new int[600];    // 蛇的y坐标
    String dictionary;        // 蛇头的方向
    boolean isStart;          // 游戏状态——是否开始
    boolean isFail;           // 是否失败
    int preX;       // 改变方向时记录的坐标X
    int preY;       // 改变方向时记录的坐标Y
    int foodX;      // 食物的X坐标
    int foodY;      // 食物的Y坐标
    int score;      // 积分
    Random random = new Random();   // 随即器
    Timer timer = new Timer(150,this);   // 定时器，监听this对象，按照150ms执行一次

    // 构造器
    public GamePanel() {
        init();     // 初始化
        this.setFocusable(true);    // 获得焦点事件
        this.addKeyListener(this);  // 获取键盘监听，因为这个类是KeyListener类的接口，并且实现了监听方法，用this就好了
    }

    // 初始化方法
    public void init() {
        length = 3;
        score = 0;                          // 初始积分为0
        snakeX[0] = 100;snakeY[0] = 100;    // 脑袋的坐标
        snakeX[1] = 75;snakeY[1] = 100;     // 第一个身体
        snakeX[2] = 50;snakeY[2] = 100;     // 第二个身体
        preX = snakeX[0];preY = snakeY[0];  // 刚开始的时候，记录刚开始的脑袋坐标
        randomFood();   // 随机食物
        dictionary = "R";                   // 蛇头的初始方向
        isStart = false;                    // 默认游戏没开始
        timer.start();  // 游戏一开始定时器开始
    }

    // 随机食物
    public void randomFood() {
        foodX = 25 + 25 * random.nextInt(34);   // 随机食物
        foodY = 75 + 25 * random.nextInt(24);   // 随机食物
        java.util.List<Integer> tmpX = Arrays.stream(snakeX).boxed().collect(Collectors.toList());
        java.util.List<Integer> tmpY = Arrays.stream(snakeY).boxed().collect(Collectors.toList());
        // 如果食物在身体里，就刷新
        if (tmpX.contains(foodX) || tmpY.contains(foodY)) {
            randomFood();
        }
    }

    // 失败判定，碰到自己就失败
    public void isGameOver() {
        for (int i = 1; i < length; i++) {
            if (snakeY[0] == snakeY[i] && snakeX[0] == snakeX[i]) {
                isFail = true;
                break;
            }
        }
    }

    // 绘制面板，游戏中的所有东西都用这个画笔来画
    @Override
    public 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.orange);
        g.setFont(new Font("Chilanka",Font.BOLD,18));
        g.drawString("Length : " + length,750,30);
        g.drawString("Score : " + score,750,55);

        // 画食物
        Data.food.paintIcon(this,g,foodX,foodY);

        // 判断蛇头方向
        switch (dictionary) {
            case "R":
                Data.right.paintIcon(this, g, snakeX[0], snakeY[0]);   // 蛇头向右边
                break;
            case "L":
                Data.left.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向左边
                break;
            case "U":
                Data.up.paintIcon(this, g, snakeX[0], snakeY[0]);      // 蛇头向上边
                break;
            case "D":
                Data.down.paintIcon(this, g, snakeX[0], snakeY[0]);    // 蛇头向下边
                break;
        }

        // 蛇的身体
        for (int i = 1; i < length; i++) {
            Data.body.paintIcon(this,g,snakeX[i],snakeY[i]);
        }

        // 游戏状态
        if (!isStart) {
            g.setColor(Color.white);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Press Space To Start !",250,400);
        }

        if (isFail) {
            g.setColor(Color.red);
            g.setFont(new Font("Chilanka",Font.BOLD,40));
            g.drawString("Failed ! Space Again ?!",250,400);
        }
    }

    @Override
    public void keyTyped(KeyEvent keyEvent) {

    }

    // 键盘监听时间
    @Override
    public void keyPressed(KeyEvent keyEvent) {
        // 监听按下空格开始or暂停
        int keyCode = keyEvent.getKeyCode();
        if (keyCode == KeyEvent.VK_SPACE) {
            if (isFail) {   // 失败了重新开始
                isFail = false;
                init();
            } else {    // 否则就是暂停、开始
                isStart = !isStart;     // 去反
            }
            repaint();
        }

        // 改变小蛇方向，必须满足按照当前方向走了一格以上才能改变方向
        if (Math.abs(preX - snakeX[0]) >= 25 || Math.abs(preY - snakeY[0]) >= 25) {
            switch (keyCode) {
                case KeyEvent.VK_UP:
                    if (!dictionary.equals("D")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "U";
                    }
                    break;
                case KeyEvent.VK_DOWN:
                    if (!dictionary.equals("U")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "D";
                    }
                    break;
                case KeyEvent.VK_LEFT:
                    if (!dictionary.equals("R")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "L";
                    }
                    break;
                case KeyEvent.VK_RIGHT:
                    if (!dictionary.equals("L")) {
                        preX = snakeX[0];
                        preY = snakeY[0];
                        dictionary = "R";
                    }
                    break;
            }
        }

    }

    @Override
    public void keyReleased(KeyEvent keyEvent) {

    }

    // 重写事件监听方法——需要通过固定的事件来刷新，设置帧率
    @Override
    public void actionPerformed(ActionEvent actionEvent) {
        // 如果游戏是开始状态，就让小蛇动起来
        if (isStart && !isFail) {

            // 后一节移动到前一节的位置
            for (int i = length-1; i > 0; i--) {
                snakeY[i] = snakeY[i-1];
                snakeX[i] = snakeX[i-1];
            }

            // 让小蛇的头动起来
            switch (dictionary) {
                case "R":
                    snakeX[0] += 25;
                    break;
                case "L":
                    snakeX[0] -= 25;
                    break;
                case "U":
                    snakeY[0] -= 25;
                    break;
                case "D":
                    snakeY[0] += 25;
                    break;
            }

            // 如果小蛇的头吃到食物就变长
            if (snakeY[0] == foodY && snakeX[0] == foodX) {
                score += 10;    // 每吃一个分数加10
                length++;       // 每吃一个长度加1
                snakeX[length-1] = snakeX[length-2];
                snakeY[length-1] = snakeY[length-2];
                randomFood();
            }

            // 如果小蛇出界就回到最初的起点
            if (snakeX[0] > 850) {
                snakeX[0] = 25;
            } else if (snakeX[0] < 25) {
                snakeX[0] = 850;
            }
            if (snakeY[0] > 650) {
                snakeY[0] = 75;
            } else if (snakeY[0] < 75) {
                snakeY[0] = 650;
            }


            // 失败判定，碰到自己就失败
            isGameOver();

            repaint();  // 重新画页面
            timer.start();  // 定时器开始
        }
    }
}