Java GUI实现贪吃蛇游戏

贪吃蛇是一款经典的游戏，玩法相对简单但富有挑战性。以下是贪吃蛇游戏的基本玩法说明：

1. 目标：控制一条蛇，在游戏区域内吃到尽可能多的食物，使蛇身变长，同时避免撞到自己的身体或游戏区域的边界。

2. 控制：通常使用方向键（上、下、左、右）或滑动屏幕来控制蛇的移动方向，使其朝着食物的方向前进。

3. 食物和增长：在游戏区域内随机生成食物。当蛇头接触到食物时，蛇身增长一个单位，并且得分会增加。

4. 增加难度：随着蛇身不断增长，游戏会变得更加困难。蛇的身体会占据更多的空间，同时移动速度可能加快。

5. 失败条件：游戏结束的条件包括蛇头撞到自己的身体或者撞到游戏区域的边界。

6. 计分：游戏通常会记录你的得分，即吃到的食物数量或者游戏时长。

贪吃蛇是一款简单而又令人上瘾的游戏，你可以在各种平台上找到不同版本的贪吃蛇游戏。希望你能享受这个经典游戏带来的乐趣！

以下是Java实现的基本贪吃蛇游戏代码，你可以根据自己的需求进行修改和完善：

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
 
public class SnakeGame extends JFrame implements KeyListener {
 
    private static final long serialVersionUID = 1L;
 
    private JPanel panel;
    private static JLabel scoreLabel, gameOverLabel;
    private static int score = 0;
    private static int highScore = 0;
    private static boolean gameOver = false;
 
    private static final int ROWS = 30, COLS = 30;
    private static final int CELL_SIZE = 20;
 
    private Snake snake;
    private Food food;
    private Timer timer;
 
    public static void main(String[] args) {
        new SnakeGame().setVisible(true);
    }
 
    public SnakeGame() {
        setTitle("贪吃蛇游戏");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(false);
 
        panel = new JPanel();
        panel.setPreferredSize(new Dimension(ROWS * CELL_SIZE, COLS * CELL_SIZE));
        getContentPane().add(panel);
        addKeyListener(this);
 
        scoreLabel = new JLabel("得分: 0  最高分: " + highScore);
        panel.add(scoreLabel);
 
        gameOverLabel = new JLabel("游戏结束");
        gameOverLabel.setForeground(Color.RED);
        gameOverLabel.setVisible(false);
        panel.add(gameOverLabel);
 
        snake = new Snake();
        food = new Food(snake);
        food.generate();
 
        timer = new Timer(100, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent arg0) {
                snake.update();
                checkGameOver();
                panel.repaint();
            }
        });
        timer.start();
        pack();
        setLocationRelativeTo(null);
    }
 
    private void checkGameOver() {
        if (snake.checkCollision()) {
            gameOver = true;
            gameOverLabel.setVisible(true);
            timer.stop();
 
            if (score > highScore) {
                highScore = score;
                scoreLabel.setText("得分: " + score + "  最高分: " + highScore);
            }
        }
    }
 
    @Override
    public void keyPressed(KeyEvent e) {
        if (!gameOver) {
            int keyCode = e.getKeyCode();
            if (keyCode == KeyEvent.VK_UP) {
                snake.changeDirection(Snake.UP);
            } else if (keyCode == KeyEvent.VK_DOWN) {
                snake.changeDirection(Snake.DOWN);
            } else if (keyCode == KeyEvent.VK_LEFT) {
                snake.changeDirection(Snake.LEFT);
            } else if (keyCode == KeyEvent.VK_RIGHT) {
                snake.changeDirection(Snake.RIGHT);
            }
        }
    }
 
    @Override
    public void keyReleased(KeyEvent e) {
    }
 
    @Override
    public void keyTyped(KeyEvent e) {
    }
 
    public class Snake {
 
        private LinkedList<Point> segments;
        private int direction;
 
        public static final int UP = 1, DOWN = -1, LEFT = 2, RIGHT = -2;
 
        public Snake() {
            segments = new LinkedList<Point>();
            segments.add(new Point(3, 0));
            segments.add(new Point(2, 0));
            segments.add(new Point(1, 0));
            segments.add(new Point(0, 0));
            direction = RIGHT;
        }
 
        public void changeDirection(int newDirection) {
            if (direction + newDirection != 0) {
                direction = newDirection;
            }
        }
 
        public void update() {
            Point head = segments.getFirst();
            Point newHead = (Point) head.clone();
 
            if (direction == UP) {
                newHead.translate(0, -1);
            } else if (direction == DOWN) {
                newHead.translate(0, 1);
            } else if (direction == LEFT) {
                newHead.translate(-1, 0);
            } else if (direction == RIGHT) {
                newHead.translate(1, 0);
            }
 
            segments.addFirst(newHead);
            if (!food.checkCollision(newHead.x, newHead.y)) {
                segments.removeLast();
            } else {
                score++;
                scoreLabel.setText("得分: " + score + "  最高分: " + highScore);
                food.generate();
            }
        }
 
        public boolean checkCollision() {
            Point head = segments.getFirst();
            if (head.x < 0 || head.x >= COLS || head.y < 0 || head.y >= ROWS) {
                return true;
            }
            for (int i = 1; i < segments.size(); i++) {
                if (segments.get(i).equals(head)) {
                    return true;
                }
            }
            return false;
        }
 
        public void draw(Graphics g) {
            for (Point p : segments) {
                g.setColor(Color.GREEN);
                g.fillRect(p.x * CELL_SIZE, p.y * CELL_SIZE, CELL_SIZE, CELL_SIZE);
            }
        }
    }
 
    public class Food {
        private int x, y;
        private Snake snake;
        private Random rand;
 
        public Food(Snake snake) {
            this.snake = snake;
            rand = new Random();
        }
 
        public void generate() {
            do {
                x = rand.nextInt(COLS);
                y = rand.nextInt(ROWS);
            } while (snake.segments.contains(new Point(x, y)));
        }
 
        public boolean checkCollision(int x, int y) {
            if (this.x == x && this.y == y) {
                return true;
            }
            return false;
        }
 
        public void draw(Graphics g) {
            g.setColor(Color.RED);
            g.fillRect(x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE);
        }
    }
 
    @Override
    public void paint(Graphics g) {
        g.setColor(Color.LIGHT_GRAY);
        g.fillRect(0, 0, getWidth(), getHeight());
        snake.draw(g);
        food.draw(g);
    }
}

这个代码实现的贪吃蛇游戏界面为：