贪吃蛇小游戏

在B站看视频的时候，看到下面这个视频就比较感兴趣，跟着手动做了一遍，写下这篇博客，

     【狂神说Java】一小时开发贪吃蛇游戏  https://www.bilibili.com/video/BV1HE41127CV?p=1 

最终游戏的界面长这个（都是画图做的图片，能力有限）

   具体的步骤，可以参照上面的视频听一下，简单易懂，（但是有一个问题，就是头部和身体重合的时候，头部的图片在下面被隐藏了，待改正，但是还没想好怎么实现，有知道怎么实现的，跪求告诉了...）

游戏规则：小蛇初始长度为3，可以上下左右四个方向移动，吃到蓝色的食物，身体长度加一，分数加10，可以穿过自己的身体，也可以穿过墙壁,（没有死亡，因为触碰身体就死掉的话很不爽，也有这个功能，只不过注释掉了）

      

玩了一会，之后的界面

      

之前使用IDEA写的代码，但是一直说的激活码失效了，一直自动退出，就很气，改用eclipse了 

下面开始说一下，编写的步骤：

   1. 首先创建一个简单的java项目 File -> 右键 - > New -> Project 

     

2.创建以下目录

      

3，把相关的图片添加到此文件夹下

       

下面就是对应图片。。。有需要直接拿走，别吐槽，我自己都惊呆了，技术有限

              

这个是对应图片的名字

4. 创建一个 StartGames 类，用来绘制窗口

     

package com.wang.snake;

import javax.swing.*;

public class StartGames {
    public static void main(String[] args) {
        // 1.绘制一个静态窗口
        JFrame frame = new JFrame("贪吃蛇小游戏");
        // 2.设置界面的大小
        frame.setBounds(100,10,910,720);
        // 3.设置窗口不可调整大小
        frame.setResizable(false);
        // 4.“X”的关闭事件，关闭窗口
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 5.把面板添加到窗口里
        frame.add(new GamePanel());
        // 6.让窗口可以展示
        frame.setVisible(true);
    }
}

5.创建Data类，获取添加的图片信息

package com.wang.snake;

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

/**
 * 存放数据
 */
public class Data {

    // 获取标题栏图片的相对路径
    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 rightURL = Data.class.getResource("/statics/right.png");
    public static URL downURL = Data.class.getResource("/statics/down.png");
    public static URL leftURL = Data.class.getResource("/statics/left.png");
    public static ImageIcon upHeader = new ImageIcon(upURL);
    public static ImageIcon rightHeader = new ImageIcon(rightURL);
    public static ImageIcon downHeader = new ImageIcon(downURL);
    public static ImageIcon leftHeader = new ImageIcon(leftURL);

    // 获取小蛇的身体图片
    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);

}

 6.创建GamePanel类，绘制界面，包含了标题块，游戏块，以及小蛇的移动等功能的实现类

package com.wang.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.Iterator;
import java.util.Random;

public class GamePanel extends JPanel implements KeyListener, ActionListener {

    // 游戏是否开始flag
    boolean isStart = false;
    // 游戏是否失败flag
    boolean isFail = false;  
 
    //定义一个记分系统
    int score;

    // 定义一个小蛇
    String fx;                      // 定义小蛇头部的朝向
    int length;                    // 小蛇的长度
    int[] snakeX = new int[600];   // 小蛇的X坐标
    int[] snakeY = new int[500];   // 小蛇的Y坐标

    // 定义一个食物
    int foodX;   // 食物的X坐标
    int foodY;   // 食物的Y坐标
    // 随机数的对象
    Random random = new Random();

    // 定义一个定时器
    Timer timer = new Timer(100,this);

    //创建构造器，调用init方法，
    public  GamePanel(){
        // 小蛇的初始化
        init();

        // 获取键盘的监听事件
        // 获取焦点，默认是不获取焦点的
        this.setFocusable(true);
        // 添加监听
        this.addKeyListener(this);
        // 启动定时器
        timer.start();
    }

    // 小蛇和食物的初始化的长度及位置
    public void init(){
        // 记分的初期值设置为0
        score = 0;
        
        // 小蛇的长度是3个，头部位置在X:100，Y:100的坐标处，朝向右
        fx = "R";
        length = 3;
        snakeX[0] = 100;
        snakeY[0] = 100;
        // 身体部分的坐标,第一部分的位置在X:75，Y:100的坐标处，
        snakeX[1] = 75;
        snakeY[1] = 100;
        // 第二部分的位置在X:50，Y:100的坐标处，
        snakeX[2] = 50;
        snakeY[2] = 100;

        // 食物的初期的位置随机的坐标，
        foodX = 25 + 25 * random.nextInt(34);
        foodY = 75 + 25 * random.nextInt(24);
    }

    // Graphics 画笔
    // 面板：画界面，画小蛇
    @Override
    protected void paintComponent(Graphics g) {
        // 调用父类方法，清屏
        super.paintComponent(g);

        // 设置面板背景颜色(黑色)
        this.setBackground(Color.white);

        // 绘制头部的标题栏
        Data.header.paintIcon(this,g,25,10);
        
        // 绘制游戏区域
        g.fillRect(25,75,850,600);

        // 创建一个静态的小蛇
        if (fx.equals("R")){
            Data.rightHeader.paintIcon(this,g,snakeX[0], snakeY[0]);
        } else if (fx.equals("L")){
            Data.leftHeader.paintIcon(this,g,snakeX[0], snakeY[0]);
        } else if (fx.equals("U")){
            Data.upHeader.paintIcon(this,g,snakeX[0], snakeY[0]);
        } else if (fx.equals("D")){
            Data.downHeader.paintIcon(this,g,snakeX[0], snakeY[0]);
        }

        // 通过for循环，创建小蛇的身体部分
        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 == 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("游戏失败，按下空格重新开始游戏",200,300);
        }
        
        // 记分提示文字的属性，
        g.setColor(Color.white);
        g.setFont(new Font("微软雅黑",Font.BOLD,18));
        g.drawString("长度：" + length,750,33);
        g.drawString("分数：" + score,750,55);
    }

    /**
     * 接受键盘的输入,进行监听
     * @param e
     */
    @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_LEFT) {
            fx = "L";
        } else if (keyCode == KeyEvent.VK_RIGHT){
            fx = "R";
        }else if (keyCode == KeyEvent.VK_UP) {
            fx = "U";
        }else if (keyCode == KeyEvent.VK_DOWN) {
            fx = "D";
        }

    }

    /**
     * 定时器，监听事件，执行定时操作
     * @param e
     */
    @Override
    public void actionPerformed(ActionEvent e) {

        // 如果游戏处于开始状态，并且游戏没有结束，小蛇就移动
        if (isStart && isFail == false){

            // 除了头部，身体都跟着往右移动
            for (int i = length - 1; i > 0; i--) {
                snakeX[i] = snakeX[i-1];
                snakeY[i] = snakeY[i-1];
            }

            // 通过控制方向，移动头部
            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){
                    snakeY[0] = 650;
                }
            } else if (fx.equals("D")){
                // 头部向左移动一步
                snakeY[0] = snakeY[0] + 25;
                // 如果已经到达边界，则从最右侧重新开始
                if (snakeY[0] > 650){
                    snakeY[0] = 75;
                }
            }

            //System.out.println("snakeX = "+snakeX[0]+" foodX="+foodX +"////snakeY = "+snakeY[0]+" foodY="+foodY);
            // 判断小蛇的头的坐标和食物的坐标重合的情况下
              if (snakeX[0] == foodX && snakeY[0] == foodY)
            {
                // 小蛇的身体长度加1
                length ++ ;
    		    snakeX[length-1] = snakeX[length-2] * 2 - snakeX[length-3];
    		    snakeY[length-1] = snakeY[length-2] * 2 - snakeY[length-3];
                
                // 每当吃掉一个食物，积分+10
                score = score + 10;

                // 生成新的食物
                foodX = 25 + 25 * random.nextInt(34);
                foodY = 75 + 25 * random.nextInt(24);
            }

              // 结束判断：头和身体有接触，则游戏失败
              //for (int i = 1; i < length; i++) {
              //    if (snakeX[0] == snakeX[i] && snakeY[0] == snakeY[i]) {
              //        // isFail = true;
              //    
              //    }    
              //}

            // 刷新界面
            repaint();
        }
        // 定时器启动
        timer.start();
    }

    /**
     * 键盘按下，
     * @param e
     */
    @Override
    public void keyTyped(KeyEvent e) {

    }

    /**
     *
     * @param e
     */
    @Override
    public void keyReleased(KeyEvent e) {

    }


}

 

第二次改版，添加了计时器的功能，同时修改了之前Date类的类名=> ImageData 

代码如下 GamePanel类的改修,底色为粉色的部分 

package com.wang.snake;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.text.AttributedCharacterIterator;
import java.util.Random;

import javax.swing.JPanel;
import javax.swing.Timer;

public class GamePanel extends JPanel implements KeyListener, ActionListener {

    // 游戏是否开始flag
    boolean isStart = false;
    // 游戏是否失败flag
    boolean isFail = false;  
    
    // 计时器的显示格式： 时分秒
    String initialTime = "00:00:00";  
    // 程序第一次开始时间  
    long programStart = System.currentTimeMillis();  
    // 程序一开始就是暂停的  
    long pauseStart = programStart;   
    // 程序暂停的总时间  
    long pauseCount = 0;  
        //定义一个记分系统
    int score;

    // 定义一个小蛇
    String fx;                      // 定义小蛇头部的朝向
    int length;                    // 小蛇的长度
    int[] snakeX = new int[600];   // 小蛇的X坐标
    int[] snakeY = new int[500];   // 小蛇的Y坐标

    // 定义一个食物
    int foodX;   // 食物的X坐标
    int foodY;   // 食物的Y坐标
    // 随机数的对象
    Random random = new Random();

    // 定义一个定时器
    Timer timer = new Timer(100,this);

    //创建构造器，调用init方法，
    public  GamePanel(){
        // 小蛇的初始化
        init();

        // 获取键盘的监听事件
        // 获取焦点，默认是不获取焦点的
        this.setFocusable(true);
        // 添加监听
        this.addKeyListener(this);
        // 启动定时器
        timer.start();
    }

    // 小蛇和食物的初始化的长度及位置
    public void init(){
        // 记分的初期值设置为0
        score = 0;
        
        // 小蛇的长度是3个，头部位置在X:100，Y:100的坐标处，朝向右
        fx = "R";
        length = 3;
        snakeX[0] = 100;
        snakeY[0] = 100;
        // 身体部分的坐标,第一部分的位置在X:75，Y:100的坐标处，
        snakeX[1] = 75;
        snakeY[1] = 100;
        // 第二部分的位置在X:50，Y:100的坐标处，
        snakeX[2] = 50;
        snakeY[2] = 100;

        // 食物的初期的位置随机的坐标，
        foodX = 25 + 25 * random.nextInt(34);
        foodY = 75 + 25 * random.nextInt(24);
    }

    // Graphics 画笔
    // 面板：画界面，画小蛇
    @Override
    protected void paintComponent(Graphics g) {
        // 调用父类方法，清屏
        super.paintComponent(g);
        
        // 设置面板背景颜色(黑色)
        this.setBackground(Color.white);

        // 绘制头部的标题栏
        ImageData.header.paintIcon(this,g,25,10);
        
        // 绘制游戏区域
        g.fillRect(25,75,850,600);

        // 创建一个静态的小蛇
        if (fx.equals("R")){
            ImageData.rightHeader.paintIcon(this,g,snakeX[0], snakeY[0]);
        } else if (fx.equals("L")){
            ImageData.leftHeader.paintIcon(this,g,snakeX[0], snakeY[0]);
        } else if (fx.equals("U")){
            ImageData.upHeader.paintIcon(this,g,snakeX[0], snakeY[0]);
        } else if (fx.equals("D")){
            ImageData.downHeader.paintIcon(this,g,snakeX[0], snakeY[0]);
        }

        // 通过for循环，创建小蛇的身体部分
        for (int i = 1; i < length; i++){
            ImageData.body.paintIcon(this,g,snakeX[i], snakeY[i]);
        }

        // 把食物添加到窗口里
        ImageData.food.paintIcon(this,g,foodX, foodY);

        // 游戏开始提示:是否开始游戏
        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("游戏失败，按下空格重新开始游戏",200,300);
        }
        
        // 记分提示文字的属性，
        g.setColor(Color.white);
        g.setFont(new Font("微软雅黑",Font.BOLD,18));
        g.drawString("长度：" + length,750,33);
        g.drawString("分数：" + score,750,55);
        
        // 计时器提示文字的属性，
        g.setColor(Color.white);
        g.setFont(new Font("微软雅黑",Font.BOLD,18));
        g.drawString("计时器：" + initialTime,30,55);      
        
    }

    /**
     * 接受键盘的输入,进行监听
     * @param e
     */
    @Override
    public void keyPressed(KeyEvent e) {
        // 获取键盘按下的是哪一个键
        int keyCode = e.getKeyCode();

        // 如果按下的是空格键，就启动或者暂停
        if (keyCode == KeyEvent.VK_SPACE) {
            // 如果游戏失败
            if (isFail) {
                // 游戏重新开始
                isFail = false;

                // 计时器时间初始化
                programStart = System.currentTimeMillis();
                pauseStart = programStart;
                pauseCount = 0;

                // 重新初始化游戏
                init();

            } else {
                // 暂停游戏
                isStart = !isStart;
                // 如果是游戏开始,则获取暂停的时间，否则暂停的时间等于当前时间
                if (isStart) {
                    pauseCount += (System.currentTimeMillis() - pauseStart);
                } else {
                    pauseStart = System.currentTimeMillis();
                }
            }

            // 刷新界面
            repaint();
        }
        
        // 判断键盘按下的上下左右键，控制小蛇的走向
        if (keyCode == KeyEvent.VK_LEFT) {
            fx = "L";
        } else if (keyCode == KeyEvent.VK_RIGHT){
            fx = "R";
        }else if (keyCode == KeyEvent.VK_UP) {
            fx = "U";
        }else if (keyCode == KeyEvent.VK_DOWN) {
            fx = "D";
        }
    }

    /**
     * 定时器，监听事件，执行定时操作
     * @param e
     */
    @Override
    public void actionPerformed(ActionEvent e) {

        // 如果游戏处于开始状态，并且游戏没有结束，小蛇就移动
        if (isStart && isFail == false){
            // 计时器持续开始计时
            long elapsed = System.currentTimeMillis() - programStart - pauseCount;    
            initialTime = format(elapsed);  

            // 除了头部，身体都跟着往右移动
            for (int i = length - 1; i > 0; i--) {
                snakeX[i] = snakeX[i-1];
                snakeY[i] = snakeY[i-1];
            }

            // 通过控制方向，移动头部
            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){
                    snakeY[0] = 650;
                }
            } else if (fx.equals("D")){
                // 头部向左移动一步
                snakeY[0] = snakeY[0] + 25;
                // 如果已经到达边界，则从最右侧重新开始
                if (snakeY[0] > 650){
                    snakeY[0] = 75;
                }
            }

            //System.out.println("snakeX = "+snakeX[0]+" foodX="+foodX +"////snakeY = "+snakeY[0]+" foodY="+foodY);
            // 判断小蛇的头的坐标和食物的坐标重合的情况下
              if (snakeX[0] == foodX && snakeY[0] == foodY)
            {
                // 小蛇的身体长度加1
                length ++ ;
                snakeX[length-1] = snakeX[length-2] * 2 - snakeX[length-3];
                snakeY[length-1] = snakeY[length-2] * 2 - snakeY[length-3];
                
                // 每当吃掉一个食物，积分+10
                score = score + 10;

                // 生成新的食物
                foodX = 25 + 25 * random.nextInt(34);
                foodY = 75 + 25 * random.nextInt(24);
            }

              // 结束判断：头和身体有接触，则游戏失败
              for (int i = 1; i < length; i++) {
                  if (snakeX[0] == snakeX[i] && snakeY[0] == snakeY[i]) {
                       isFail = true;                 
                  }    
              } 
            // 刷新界面
            repaint();
        } 
        // 定时器启动
        timer.start();
    }
    
    // 将毫秒数格式化  
    private String format(long elapsed) {  
        int hour, minute, second, milli;  

        milli = (int) (elapsed % 1000);  
        elapsed = elapsed / 1000;  

        second = (int) (elapsed % 60);  
        elapsed = elapsed / 60;  

        minute = (int) (elapsed % 60);  
        elapsed = elapsed / 60;  

        hour = (int) (elapsed % 60);  

        // 带有毫秒的显示
        //return String.format("%02d:%02d:%02d %03d", hour, minute, second, milli); 
        return String.format("%02d:%02d:%02d", hour, minute, second);  

    }  
    
    /**
     * 键盘按下，
     * @param e
     */
    @Override
    public void keyTyped(KeyEvent e) {

    }

    /**
     *
     * @param e
     */
    @Override
    public void keyReleased(KeyEvent e) {

    }
}

第三版 添加了限时模式以及菜单栏

初期的画面

限时模式

StartGames类的改修

package com.wang.snake;

import java.awt.Color;
import java.awt.Font;

import javax.swing.*;

public class StartGames {

    private final static Font f = new Font("微软雅黑", Font.PLAIN, 15);
    private final static Font f2 = new Font("微软雅黑", Font.PLAIN, 12);

    public final static String ONE_MINUTE = "00:01:00";
    public final static String THREE_MINUTE = "00:03:00";
    public final static String FIVE_MINUTE = "00:05:00";
    public final static int ONE_MINUTE_END_TIME = 60000;
    public final static int THREE_MINUTE_END_TIME = 180000;
    public final static int FIVE_MINUTE_END_TIME = 300000;
    public final static int COUNT_DOWN_TIME_STRAT = 1;

    static JFrame frame;
    static GamePanel gamePanel;

    public static void main(String[] args) {
        // 1.绘制一个静态窗口
        frame = new JFrame("贪吃蛇小游戏");
        // 2.设置界面的大小
        frame.setBounds(100, 0, 875, 635);        
        // 3.添加菜单栏
        menuBar();        
        // 4.设置窗口不可调整大小
        frame.setResizable(false);
        // 5.“X”的关闭事件，关闭窗口
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 6.把面板添加到窗口里
        gamePanel = new GamePanel();
        frame.add(gamePanel);        
        // 7.让窗口可以展示
        frame.setVisible(true);

    }

    // 添加菜单栏以及触发的事件
    static void menuBar() {
        // 添加菜单栏
        JMenuBar bar = new JMenuBar();
        bar.setBackground(Color.white);
        frame.setJMenuBar(bar);
        // 设置画面属性
        JMenu modes = new JMenu("画面显示设定");
        modes.setFont(f);
        bar.add(modes);

        // 不同的游戏模式
        JMenu Settings = new JMenu("模式选择");
        Settings.setFont(f);
        bar.add(Settings);

        // 无限模式
        JMenuItem infiniteMode = new JMenuItem("无限模式");
        infiniteMode.setFont(f2);
        Settings.add(infiniteMode);

        // 限时模式
        JMenuItem countDownTimeMode = new JMenuItem("限时模式");
        countDownTimeMode.setFont(f2);
        Settings.add(countDownTimeMode);

        // 限时模式的时长,添加限时时长的菜单栏,以及限时时长
        JMenu duration = new JMenu("限时模式的时长");
        duration.setFont(f);
        bar.add(duration);
        JMenuItem oneMinute = new JMenuItem("1分钟");
        oneMinute.setFont(f2);
        duration.add(oneMinute);
        JMenuItem threeMinute = new JMenuItem("3分钟");
        threeMinute.setFont(f2);
        duration.add(threeMinute);
        JMenuItem friveMinute = new JMenuItem("5分钟");
        friveMinute.setFont(f2);
        duration.add(friveMinute);

        // 选择无限模式时的事件
        infiniteMode.addActionListener(e -> {
            gamePanel.infiniteTime = "00:00:00";
            gamePanel.programStart = System.currentTimeMillis();
            gamePanel.pauseStart = gamePanel.programStart;
            gamePanel.pauseCount = 0;
            // 限时模式未开始
            gamePanel.iscountDownTime = 0;
            gamePanel.isStart = false;
            gamePanel.init();
            // 刷新画面
            gamePanel.repaint();
        });

        // 选择限时模式时的事件
        countDownTimeMode.addActionListener(e -> {
            // 设置限时3分钟
            countDownModeMinuteaddActionListener(COUNT_DOWN_TIME_STRAT, THREE_MINUTE, THREE_MINUTE_END_TIME);
        });

        // 选择限时1分钟
        oneMinute.addActionListener(e -> {
            countDownModeMinuteaddActionListener(COUNT_DOWN_TIME_STRAT, ONE_MINUTE, ONE_MINUTE_END_TIME);
        });

        // 选择限时3分钟
        threeMinute.addActionListener(e -> {
            countDownModeMinuteaddActionListener(COUNT_DOWN_TIME_STRAT, THREE_MINUTE, THREE_MINUTE_END_TIME);
        });

        // 选择限时5分钟
        friveMinute.addActionListener(e -> {
            countDownModeMinuteaddActionListener(COUNT_DOWN_TIME_STRAT, FIVE_MINUTE, FIVE_MINUTE_END_TIME);
        });
    }
    
    // 限时时长的共同方法
    static void countDownModeMinuteaddActionListener(Integer iscountDownTime, String countDownTime, int endTime) {
        gamePanel.isStart = false;
        // 限时模式开始
        gamePanel.iscountDownTime = iscountDownTime;
        // 设置默认时长的限时格式
        gamePanel.countDownTime = countDownTime;
        // 默认时长的毫秒数
        gamePanel.endTime = endTime;
        gamePanel.init();
        gamePanel.repaint();
    }
}

GamePanel类的改修

package com.wang.snake;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;

import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.Timer;

public class GamePanel extends JPanel implements KeyListener, ActionListener {

    private static final long serialVersionUID = 1L;

    // 游戏是否开始flag
    boolean isStart = false;
    // 游戏是否失败flag
    static boolean isFail = false;
    
    // 计时器的显示格式： 时分秒
    String infiniteTime = "00:00:00";
    // 程序第一次开始时间
    long programStart = System.currentTimeMillis();
    // 程序一开始就是暂停的
    long pauseStart = programStart;
    // 程序暂停的总时间
    long pauseCount = 0;
    
    // 限时模式
    String countDownTime;
    int endTime;
    // 限时模式是否开始:0未开始，1开始，2结束
    int iscountDownTime = 0;

    // 定义一个记分系统
    int score;

    // 定义一个小蛇
    String fx; // 定义小蛇头部的朝向
    int length; // 小蛇的长度
    int[] snakeX = new int[600]; // 小蛇的X坐标
    int[] snakeY = new int[500]; // 小蛇的Y坐标    

    // 定义一个食物
    int foodX; // 食物的X坐标
    int foodY; // 食物的Y坐标
    // 随机数，用于食物的坐标
    Random random = new Random();
    
    // 定时任务间隔时长
    int timingDuration = 100;
    // 定义一个定时器
    Timer timer = new Timer(timingDuration, this);

    // 创建构造器，调用init方法，
    public GamePanel() {
        // 小蛇的初始化
        init();

        // 获取焦点，默认是不获取焦点的
        this.setFocusable(true);

        // 添加监听
        this.addKeyListener(this);

        // 启动定时器
        timer.start();
    }

    // 小蛇和食物的初始化的长度及位置
    public void init() {
        // 记分的初期值设置为0
        score = 0;

        // 小蛇的长度是3个，头部位置在X:100，Y:100的坐标处，朝向右
        fx = "R";
        length = 3;
        snakeX[0] = 105;
        snakeY[0] = 90;
        // 身体部分的坐标,第一部分的位置在X:75，Y:100的坐标处，
        snakeX[1] = 80;
        snakeY[1] = 90;
        // 第二部分的位置在X:50，Y:100的坐标处，
        snakeX[2] = 55;
        snakeY[2] = 90;

        // 食物的初期的位置随机的坐标，
        foodX = 5 + 25 * random.nextInt(34);
        foodY = 65 + 25 * random.nextInt(20);
    }

    // Graphics 画笔
    // 面板：画界面，画小蛇
    @Override
    protected void paintComponent(Graphics g) {
        // 调用父类方法，清屏
        super.paintComponent(g);

        // 设置面板背景颜色(黑色)
        this.setBackground(Color.white);

        // 绘制头部的标题栏
        ImageData.header.paintIcon(this, g, 5, 5);

        // 绘制游戏区域
        g.fillRect(5, 65, 850, 500);

        // 创建一个静态的小蛇
        if (fx.equals("R")) {
            ImageData.rightHeader.paintIcon(this, g, snakeX[0], snakeY[0]);
        } else if (fx.equals("L")) {
            ImageData.leftHeader.paintIcon(this, g, snakeX[0], snakeY[0]);
        } else if (fx.equals("U")) {
            ImageData.upHeader.paintIcon(this, g, snakeX[0], snakeY[0]);
        } else if (fx.equals("D")) {
            ImageData.downHeader.paintIcon(this, g, snakeX[0], snakeY[0]);
        }

        // 通过for循环，创建小蛇的身体部分
        for (int i = 1; i < length; i++) {
            ImageData.body.paintIcon(this, g, snakeX[i], snakeY[i]);
        }

        // 把食物添加到窗口里
        ImageData.food.paintIcon(this, g, foodX, foodY);

        // 游戏开始提示:是否开始游戏
        if (isStart == false) {
            // 提示文字的属性，
            g.setFont(new Font("微软雅黑", Font.BOLD, 40));
            // 计时器提示文字的属性，
            if (iscountDownTime == 1) {
                g.setColor(Color.CYAN);
                g.drawString("限时模式：按下空格开始游戏", 150, 300);
            } else {
                g.setColor(Color.white);
                g.drawString("无限模式：按下空格开始游戏", 150, 300);
            }    
        // 游戏失败提示:游戏失败
        } else if (isFail) {
            // 提示文字的属性，
            g.setColor(Color.red);
            g.setFont(new Font("微软雅黑", Font.BOLD, 40));
            g.drawString("游戏结束，按下空格重新开始游戏", 150, 300);            
        }

        // 记分提示文字的属性，
        g.setColor(Color.white);
        g.setFont(new Font("微软雅黑", Font.BOLD, 18));
        g.drawString("长度：" + length, 740, 28);
        g.drawString("分数：" + score, 740, 48);

        // 计时器提示文字的属性，
        if (iscountDownTime == 1) {
            g.drawString("限时模式倒计时：" + countDownTime, 10, 48);
        } else {
            g.drawString("在线时长：" + infiniteTime, 10, 48);
        }
    }

    /**
     * 接受键盘的输入,进行监听
     * 
     * @param e
     */
    @Override
    public void keyPressed(KeyEvent e) {
        // 获取键盘按下的是哪一个键
        int keyCode = e.getKeyCode();

        // 如果按下的是空格键，就启动或者暂停
        if (keyCode == KeyEvent.VK_SPACE) {
            // 如果游戏失败
            if (isFail) {
                // 游戏重新开始
                isFail = false;

                // 计时器时间初始化
                programStart = System.currentTimeMillis();
                pauseStart = programStart;
                pauseCount = 0;

                // 重新初始化游戏
                init();

            } else {
                // 暂停游戏
                isStart = !isStart;
                // 如果是游戏开始,则获取暂停的时间，否则暂停的时间等于当前时间
                if (isStart) {
                    pauseCount += (System.currentTimeMillis() - pauseStart);
                } else {
                    pauseStart = System.currentTimeMillis();
                }
            }

            // 刷新界面
            repaint();
        }

        // 判断键盘按下的上下左右键，控制小蛇的走向
        if (keyCode == KeyEvent.VK_LEFT) {
            fx = "L";
        } else if (keyCode == KeyEvent.VK_RIGHT) {
            fx = "R";
        } else if (keyCode == KeyEvent.VK_UP) {
            fx = "U";
        } else if (keyCode == KeyEvent.VK_DOWN) {
            fx = "D";
        }
    }

    /**
     * 定时器，监听事件，执行定时操作
     * 
     * @param e
     */
    @Override
    public void actionPerformed(ActionEvent e) {

        // 如果游戏处于开始状态，并且游戏没有结束，小蛇就移动
        if (isStart && isFail == false) {
            // 计时器启动
            format2();
            // 小蛇的长度增加以及移动，
            snakeGrowUp();
            // 刷新界面
            repaint();
        }
        // 定时器启动
        timer.start();
    }

    // 计时器
    private void format2() {
        // 如果是限时模式的话，开始进行倒计时
        if (iscountDownTime == 1) {
            // 判断限时模式是否到时间了
            if (endTime >= 1000) {
                //System.out.println("endTime = " + endTime);
                endTime = endTime - timingDuration;
                countDownTime = format(endTime);
                //System.out.println("countDownTime = " + countDownTime);

                // 限时模式时间到，游戏结束
            } else {
                iscountDownTime = 2;
                isFail = true;
            }
        // 无限模式
        } else {
            // 计时器开始计时
            long elapsed = System.currentTimeMillis() - programStart - pauseCount;
            infiniteTime = format(elapsed);
        }
    }

    private void snakeGrowUp() {
        // 除了头部，身体都跟着往右移动
        for (int i = length - 1; i > 0; i--) {
            snakeX[i] = snakeX[i - 1];
            snakeY[i] = snakeY[i - 1];
        }

        // 通过控制方向，移动头部
        if (fx.equals("R")) {
            // 头部向右移动一步
            snakeX[0] = snakeX[0] + 25;
            // 如果已经到达边界，则从最右侧重新开始
            if (snakeX[0] > 830) {
                snakeX[0] = 5;
            }
        } else if (fx.equals("L")) {
            // 头部向左移动一步
            snakeX[0] = snakeX[0] - 25;
            // 如果已经到达边界，则从最右侧重新开始
            if (snakeX[0] < 5) {
                snakeX[0] = 830;
            }
        } else if (fx.equals("U")) {
            // 头部向左移动一步
            snakeY[0] = snakeY[0] - 25;
            // 如果已经到达边界，则从最右侧重新开始
            if (snakeY[0] < 65) {
                snakeY[0] = 540;
            }
        } else if (fx.equals("D")) {
            // 头部向左移动一步
            snakeY[0] = snakeY[0] + 25;
            // 如果已经到达边界，则从最右侧重新开始
            if (snakeY[0] > 540) {
                snakeY[0] = 65;
            }
        }

        // System.out.println("snakeX = "+snakeX[0]+" foodX="+foodX +"////snakeY =
        // "+snakeY[0]+" foodY="+foodY);
        // 判断小蛇的头的坐标和食物的坐标重合的情况下
        if (snakeX[0] == foodX && snakeY[0] == foodY) {
            // 小蛇的身体长度加1
            length++;
            snakeX[length - 1] = snakeX[length - 2] * 2 - snakeX[length - 3];
            snakeY[length - 1] = snakeY[length - 2] * 2 - snakeY[length - 3];

            // 每当吃掉一个食物，积分+10
            score = score + 10;

            // 生成新的食物
            foodX = 5 + 25 * random.nextInt(34);
            foodY = 65 + 25 * random.nextInt(20);
        }

        // 结束判断：头和身体有接触，则游戏失败
        for (int i = 1; i < length; i++) {
            if (snakeX[0] == snakeX[i] && snakeY[0] == snakeY[i]) {
                // isFail = true;
            }
        }
    }

    // 将毫秒数格式化
    private static String format(long elapsed) {
        int hour, minute, second, milli;

        milli = (int) (elapsed % 1000);
        elapsed = elapsed / 1000;

        second = (int) (elapsed % 60);
        elapsed = elapsed / 60;

        minute = (int) (elapsed % 60);
        elapsed = elapsed / 60;

        hour = (int) (elapsed % 60);

        // 带有毫秒的显示
        // return String.format("%02d:%02d:%02d %03d", hour, minute, second, milli);
        return String.format("%02d:%02d:%02d", hour, minute, second);

    }

    /**
     * 键盘按下，
     * 
     * @param e
     */
    @Override
    public void keyTyped(KeyEvent e) {

    }

    /**
     *
     * @param e
     */
    @Override
    public void keyReleased(KeyEvent e) {

    }
}