用JAVA写一个贪吃蛇的代码

### 回答1：

我很乐意为你编写一段贪吃蛇的JAVA代码：
public class SnakeGame {
public static void main(String[] args) {
// 创建一个SnakeGame对象
SnakeGame game = new SnakeGame();
// 设置游戏界面的大小，如果没有参数，默认界面大小为20*20
game.setSize(30, 30);
// 开始游戏
game.startGame();
}
}

### 回答2：
贪吃蛇是一种经典的游戏，下面是一个简单的用JAVA编写的贪吃蛇代码示例：

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class SnakeGame extends JFrame {
    private final static int WIDTH = 800; // 游戏窗口宽度
    private final static int HEIGHT = 600; // 游戏窗口高度
    private final static int UNIT_SIZE = 20; // 蛇身及食物的大小
    private final static int GAME_UNITS = (WIDTH * HEIGHT) / (UNIT_SIZE * UNIT_SIZE); // 游戏单元格数
    private final static int DELAY = 100; // 游戏速度

    private List<Integer> snakeX = new ArrayList<>(); // 蛇身x坐标列表
    private List<Integer> snakeY = new ArrayList<>(); // 蛇身y坐标列表
    private boolean directionRight = true; // 初始蛇的移动方向向右
    private boolean directionLeft = false;
    private boolean directionUp = false;
    private boolean directionDown = false;
    private int foodX; // 食物x坐标
    private int foodY; // 食物y坐标
    private int score = 0; // 得分
    private boolean gameRunning = true; // 游戏是否运行中

    public SnakeGame() {
        setTitle("贪吃蛇游戏");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(false);
        setSize(WIDTH, HEIGHT);
        setLocationRelativeTo(null);
        setVisible(true);
        addKeyListener(new GameKeyListener());

        generateFood();

        Timer timer = new Timer(DELAY, e -> {
            if (gameRunning) {
                move();
                checkFoodCollision();
                checkCollision();
                repaint();
            }
        });
        timer.start();
    }

    public void paint(Graphics g) {
        if (gameRunning) {
            g.clearRect(0, 0, WIDTH, HEIGHT);

            // 画蛇头
            g.setColor(Color.green);
            g.fillRect(snakeX.get(0), snakeY.get(0), UNIT_SIZE, UNIT_SIZE);

            // 画蛇身
            g.setColor(Color.lightGray);
            for (int i = 1; i < snakeX.size(); i++) {
                g.fillRect(snakeX.get(i), snakeY.get(i), UNIT_SIZE, UNIT_SIZE);
            }

            // 画食物
            g.setColor(Color.red);
            g.fillRect(foodX, foodY, UNIT_SIZE, UNIT_SIZE);

            // 画分数
            g.setColor(Color.white);
            g.setFont(new Font("Arial", Font.BOLD, 20));
            g.drawString("Score: " + score, 10, 30);

        } else {
            gameOver(g);
        }
    }

    public void move() {
        for (int i = snakeX.size() - 1; i > 0; i--) {
            snakeX.set(i, snakeX.get(i - 1));
            snakeY.set(i, snakeY.get(i - 1));
        }

        if (directionRight) {
            snakeX.set(0, snakeX.get(0) + UNIT_SIZE);
        } else if (directionLeft) {
            snakeX.set(0, snakeX.get(0) - UNIT_SIZE);
        } else if (directionUp) {
            snakeY.set(0, snakeY.get(0) - UNIT_SIZE);
        } else {
            snakeY.set(0, snakeY.get(0) + UNIT_SIZE);
        }
    }

    public void generateFood() {
        Random random = new Random();
        foodX = random.nextInt((WIDTH / UNIT_SIZE)) * UNIT_SIZE;
        foodY = random.nextInt((HEIGHT / UNIT_SIZE)) * UNIT_SIZE;
    }

    public void checkFoodCollision() {
        if (snakeX.get(0).equals(foodX) && snakeY.get(0).equals(foodY)) {
            snakeX.add(snakeX.get(snakeX.size() - 1));
            snakeY.add(snakeY.get(snakeY.size() - 1));
            score++;
            generateFood();
        }
    }

    public void checkCollision() {
        // 检查蛇头与蛇身碰撞
        for (int i = 1; i < snakeX.size(); i++) {
            if (snakeX.get(0).equals(snakeX.get(i)) && snakeY.get(0).equals(snakeY.get(i))) {
                gameRunning = false;
                break;
            }
        }

        // 检查蛇头是否碰撞到游戏界面边缘
        if (snakeX.get(0) >= WIDTH || snakeX.get(0) < 0 || snakeY.get(0) >= HEIGHT || snakeY.get(0) < 0) {
            gameRunning = false;
        }
    }

    public void gameOver(Graphics g) {
        g.setColor(Color.white);
        g.setFont(new Font("Arial", Font.BOLD, 40));
        g.drawString("游戏结束", WIDTH / 2 - 120, HEIGHT / 2 - 50);
        g.drawString("得分：" + score, WIDTH / 2 - 80, HEIGHT / 2);
    }

    private class GameKeyListener extends KeyAdapter {
        @Override
        public void keyPressed(KeyEvent e) {
            switch (e.getKeyCode()) {
                case KeyEvent.VK_RIGHT:
                    if (!directionLeft) {
                        directionRight = true;
                        directionUp = false;
                        directionDown = false;
                    }
                    break;
                case KeyEvent.VK_LEFT:
                    if (!directionRight) {
                        directionLeft = true;
                        directionUp = false;
                        directionDown = false;
                    }
                    break;
                case KeyEvent.VK_UP:
                    if (!directionDown) {
                        directionLeft = false;
                        directionUp = true;
                        directionRight = false;
                    }
                    break;
                case KeyEvent.VK_DOWN:
                    if (!directionUp) {
                        directionDown = true;
                        directionLeft = false;
                        directionRight = false;
                    }
                    break;
            }
        }
    }

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

此代码使用了`javax.swing`和`java.awt`库来创建游戏窗口、绘制游戏界面、处理用户输入等逻辑。整个游戏界面由一个大小为`800x600`的窗口构成，游戏中的所有元素大小都是`20x20`个像素，包括蛇身和食物。蛇的移动是用一个定时器来控制的，每隔一段时间更新蛇的坐标并重新绘制游戏界面。用户可以使用方向键来控制蛇的移动方向。游戏会检查蛇头和蛇身、蛇头和界面边缘的碰撞情况，并根据得分生成新的食物。当蛇头与蛇身或界面边缘碰撞时，游戏结束，并在界面上显示游戏结束的提示信息和得分。

### 回答3：
贪吃蛇游戏是一款经典的游戏，下面是用JAVA编写的贪吃蛇代码：

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

public class GreedySnake extends JFrame implements ActionListener {

    private static final int WIDTH = 600; // 窗口宽度
    private static final int HEIGHT = 400; // 窗口高度
    private static final int DELAY = 100; // 游戏延迟

    private SnakePanel snakePanel; // 游戏面板
    private Timer timer; // 计时器

    public GreedySnake() {
        setTitle("贪吃蛇");
        setSize(WIDTH, HEIGHT);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);

        snakePanel = new SnakePanel(20, 15); // 创建游戏面板，20行15列
        add(snakePanel); // 将游戏面板添加到窗口

        timer = new Timer(DELAY, this);
        timer.start();

        addKeyListener(new SnakeKeyAdapter()); // 添加监听器

        setVisible(true);
    }

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

    @Override
    public void actionPerformed(ActionEvent e) {
        snakePanel.moveSnake(); // 移动蛇
        snakePanel.repaint(); // 重绘游戏面板
    }
}

class SnakePanel extends JPanel {

    private static final int CELL_SIZE = 20; // 每个单元格的大小

    private int rows; // 行数
    private int cols; // 列数

    private Snake snake; // 蛇
    private Food food; // 食物

    public SnakePanel(int rows, int cols) {
        this.rows = rows;
        this.cols = cols;

        snake = new Snake();
        food = new Food(rows, cols);

        setFocusable(true);
    }

    public void moveSnake() {
        if (snake.isDead()) {
            JOptionPane.showMessageDialog(this, "Game Over");
            System.exit(0);
        }

        snake.move();
        if (snake.canEat(food)) {
            snake.eat(food);
            food.randomLocation(rows, cols);
        }
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);

        // 绘制蛇
        for (Point point : snake.getBody()) {
            drawCell(g, point, Color.GREEN);
        }

        // 绘制食物
        drawCell(g, food.getLocation(), Color.RED);
    }

    private void drawCell(Graphics g, Point point, Color color) {
        int x = point.x * CELL_SIZE;
        int y = point.y * CELL_SIZE;

        g.setColor(color);
        g.fillRect(x, y, CELL_SIZE, CELL_SIZE);
    }
}

class Snake {

    private static final int INITIAL_LENGTH = 3; // 初始长度

    private LinkedList<Point> body; // 蛇身
    private Direction direction; // 移动方向

    public Snake() {
        body = new LinkedList<>();
        direction = Direction.RIGHT;

        for (int i = 0; i < INITIAL_LENGTH; i++) {
            body.add(new Point(INITIAL_LENGTH - i, 1));
        }
    }

    public void move() {
        Point head = new Point(body.getFirst());
        switch (direction) {
            case UP:
                head.translate(0, -1);
                break;
            case DOWN:
                head.translate(0, 1);
                break;
            case LEFT:
                head.translate(-1, 0);
                break;
            case RIGHT:
                head.translate(1, 0);
                break;
        }
        body.addFirst(head);
        body.removeLast();
    }

    public void eat(Food food) {
        Point head = new Point(body.getFirst());
        switch (direction) {
            case UP:
                head.translate(0, -1);
                break;
            case DOWN:
                head.translate(0, 1);
                break;
            case LEFT:
                head.translate(-1, 0);
                break;
            case RIGHT:
                head.translate(1, 0);
                break;
        }
        body.addFirst(head);
        food.randomLocation(body.size(), body.size());
    }

    public boolean canEat(Food food) {
        Point head = new Point(body.getFirst());
        switch (direction) {
            case UP:
                head.translate(0, -1);
                break;
            case DOWN:
                head.translate(0, 1);
                break;
            case LEFT:
                head.translate(-1, 0);
                break;
            case RIGHT:
                head.translate(1, 0);
                break;
        }
        return head.equals(food.getLocation());
    }

    public boolean isDead() {
        Point head = body.getFirst();
        int x = head.x;
        int y = head.y;

        if (x < 1 || x >= SnakePanel.COLS || y < 1 || y >= SnakePanel.ROWS) {
            return true;
        }

        for (int i = 1; i < body.size(); i++) {
            if (head.equals(body.get(i))) {
                return true;
            }
        }

        return false;
    }

    public LinkedList<Point> getBody() {
        return body;
    }
}

class Food {

    private Point location; // 食物坐标

    public Food(int rows, int cols) {
        randomLocation(rows, cols);
    }

    public void randomLocation(int rows, int cols) {
        int x = (int) (Math.random() * cols) + 1;
        int y = (int) (Math.random() * rows) + 1;
        location = new Point(x, y);
    }

    public Point getLocation() {
        return location;
    }
}

class SnakeKeyAdapter extends KeyAdapter {

    @Override
    public void keyPressed(KeyEvent e) {
        int code = e.getKeyCode();
        switch (code) {
            case KeyEvent.VK_UP:
                snakePanel.getSnake().setDirection(Direction.UP);
                break;
            case KeyEvent.VK_DOWN:
                snakePanel.getSnake().setDirection(Direction.DOWN);
                break;
            case KeyEvent.VK_LEFT:
                snakePanel.getSnake().setDirection(Direction.LEFT);
                break;
            case KeyEvent.VK_RIGHT:
                snakePanel.getSnake().setDirection(Direction.RIGHT);
                break;
        }
        snakePanel.setFocusable(true);
    }
}

enum Direction {
    UP, DOWN, LEFT, RIGHT
}

这段代码利用Java的AWT和Swing库来实现游戏的绘制和控制。其中，SnakePanel类是游戏的主要面板，在paintComponent方法中绘制蛇和食物，同时在moveSnake方法中处理蛇的移动和吃食物的逻辑。Snake类表示蛇的数据结构和相关方法，Food类表示食物的数据和相关方法。SnakeKeyAdapter类监听键盘事件，根据用户的输入来改变蛇的移动方向。最后，通过GreedySnake类构建游戏窗口，并启动游戏的主循环。