• 用Java写一个贪吃蛇游戏

    目录

    创建窗体

    创建游戏棋盘

    创建蛇的节点

    创建蛇身

    让蛇移动

    添加键盘监听

    添加边界处理

    把食物绘制到棋盘上

    吃食物

    创建窗体

    创建一个MainFrame类继承JFrame，表示主窗体。

    1. public class MainFrame extends JFrame {
    2.     //创建窗体对象时，初始化船体参数
    3.     public MainFrame(){
    4.         initFrame();
    5.     }
    6. }

    MainFrame类中写一个initFrame方法，初始化窗体参数

    1. //1.初始化窗体参数
    2. private void initFrame() {
    3.     //设置窗体标题
    4.     setTitle("黑马贪吃蛇");
    5.     //设置窗体大小
    6.     setSize(610, 640);
    7.     //设置窗体位置
    8.     setLocation(400, 400);
    9.     //设置窗体大小不能改变
    10.     setResizable(false);
    11.     //设置窗体关闭按钮的作用，是正常退出
    12.     setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    13. }

    在MainFrame中添加一个main方法，创建窗体并运行，就可以看到窗体了

    1. //主方法
    2. public static void main(String[] args) {
    3.     //创建窗体，并显示在屏幕上
    4.     new MainFrame().setVisible(true);
    5. }

    创建游戏棋盘

    在JFrame类中写一个initGamePanel方法，初始化游戏棋盘

    1. //初始化游戏面板
    2. private void initGamePanel() {
    3.     JPanel jPanel = new JPanel() {
    4.         //paint是用来绘制面板中的内容
    5.         @Override
    6.         public void paint(Graphics g) {
    7.             //设置画笔颜色
    8.             g.setColor(Color.black); //设置画笔颜色是黑色
    9.             //绘制40条横线(起点横坐标，起点纵坐标，终点横坐标，终点纵坐标)
    10.             for(int i=1;i<=40;i++){
    11.                 g.drawLine(0,15*i,600,15*i);
    12.             }
    13.  
    14.             //绘制40条竖线
    15.             for (int i=1;i<=40;i++){
    16.                 g.drawLine(15*i,0,15*i,600);
    17.             }
    18.         }
    19.     };
    20.     add(jPanel);
    21. }

    创建蛇的节点

    创建一个Node类表示节点，一条蛇有若干个节点组成，每一个节点其实就是一个小方格，我们用行和列来定义节点在棋盘中的位置。

    1. public class Node {
    2.     private int x; //横坐标
    3.     private int y; //纵坐标
    4.  
    5.     public int getX() {
    6.         return x;
    7.     }
    8.  
    9.     public void setX(int x) {
    10.         this.x = x;
    11.     }
    12.  
    13.     public int getY() {
    14.         return y;
    15.     }
    16.  
    17.     public void setY(int y) {
    18.         this.y = y;
    19.     }
    20. }

    创建蛇身

    创建Snake类表示蛇，一条蛇有多个节点使用LinkedList集合存储Node节点，蛇出生的时候 有3个节点。

    1. public class Snake {
    2.     //body
    3.     private LinkedList<Node> body;
    4.     
    5.     //创建蛇对象时，初始化蛇身
    6.     public Snake() {
    7.         initSnake();
    8.     }
    9.  
    10.     //初始化蛇身 3个节点
    11.     public void initSnake(){
    12.         //创建蛇的躯体
    13.         body=new LinkedList<>();
    14.         //给蛇添加3个节点，在棋盘的中心位置横向排列
    15.         body.add(new Node(20,20));
    16.         body.add(new Node(21,20));
    17.         body.add(new Node(22,20));
    18.     }
    19.   
    20.     //获取蛇蛇身
    21.     public LinkedList<Node> getBody(){
    22.         return body;
    23.     }
    24. }

    把蛇绘制到棋盘上

    在MainFrame中添加一个创建Snake的成员变量，表示窗体中有一条蛇

    1. public class MainFrame extends JFrame {
    2.     //定义成员变量
    3.     private Snake snake=new Snake();
    4. 	....
    5. }

    在绘制棋盘的paint方法中，添加下面的代码绘制把蛇绘制到棋盘上

    1. //绘制横线
    2. ...
    3. //绘制竖线
    4. ...
    5.  
    6. //绘制蛇,根据每一个节点的坐标在棋盘上绘制矩形
    7. for (Node node : snake.getBody()) {
    8.     //每一个节点的宽度和高度是15
    9.     g.fillRect(node.getX()*15,node.getY()*15,15,15);
    10. }

     再次运行，就可以看到有一条蛇静静的躺在棋盘中间了

    让蛇移动

    定义一个枚举类型，表示运动的4个方向

    1. public enum  Direction {
    2.     UP,DOWN,LEFT,RIGHT
    3. }

    在Snake类中定义一个移动方向的变量成员变量，和move方法。

    1. public class Snake{
    2.     //蛇头运动的方向
    3.     private Direction direction;
    4.     
    5.     //移动的方法: 每次移动在蛇头运动方向添加一个节点，再删除最后一个节点
    6.     public void move(){
    7.         //获取蛇头的节点
    8.         Node head = body.getFirst();
    9.         //新的蛇头节点
    10.         Node newHead=null;
    11.         //检查移动的方向
    12.         switch (direction){
    13.             //如果向左移动
    14.             case LEFT:
    15.                 //创建一个新的蛇头节点
    16.                  newHead=new Node(head.getX()-1,head.getY());
    17.                 //把心得蛇头节点添加到body的第一个元素
    18.                 body.addFirst(newHead);
    19.                 //删除蛇尾
    20.                 body.removeLast();
    21.                 break;
    22.             case RIGHT:
    23.                 //创建一个新的蛇头节点
    24.                 newHead=new Node(head.getX()-1,head.getY());
    25.                 //把心得蛇头节点添加到body的第一个元素
    26.                 body.addFirst(newHead);
    27.                 //删除蛇尾
    28.                 body.removeLast();
    29.                 break;
    30.             case UP:
    31.                 //创建一个新的蛇头节点
    32.                 newHead=new Node(head.getX(),head.getY()-1);
    33.                 //把心得蛇头节点添加到body的第一个元素
    34.                 body.addFirst(newHead);
    35.                 //删除蛇尾
    36.                 body.removeLast();
    37.                 break;
    38.             case DOWN:
    39.                 //创建一个新的蛇头节点
    40.                 newHead=new Node(head.getX(),head.getY()+1);
    41.                 //把心得蛇头节点添加到body的第一个元素
    42.                 body.addFirst(newHead);
    43.                 //删除蛇尾
    44.                 body.removeLast();
    45.                 break;
    46.         }
    47.     }
    48. }

     在MainFrame类中，创建一个定时器每100毫秒，重绘游戏棋盘

    1. public class MainFrame extends JFrame {
    2.     ...
    3.     //游戏棋盘面板
    4.     JPanel jPanel=null;
    5.     //定义定时器
    6.     private Timer timer;
    7.     
    8.     public MainFrame() throws HeadlessException {
    9.         //初始化窗体参数
    10.         initFrame();
    11.         //初始化窗体中的游戏面板
    12.         initGamePanel();
    13.         //初始化定时器
    14.         initTimer();
    15.     }
    16.     
    17.     //2.初始化游戏棋盘
    18.     private void initGamePanel() {
    19.          jPanel = new JPanel() {
    20.             //paint是用来绘制面板中的内容
    21.             @Override
    22.             public void paint(Graphics g) {
    23. 				//每次重绘时清空面板中的内容
    24.                 g.clearRect(0,0,getWidth(),getHeight());
    25.                	....
    26.             }
    27.         };
    28.         add(jPanel);
    29.     }
    30.  
    31.     //3.初始化定时器
    32.     private void initTimer() {
    33.         TimerTask task=new TimerTask() {
    34.             @Override
    35.             public void run() {
    36.                 //调用蛇移动的方法
    37.                 snake.move();
    38.                 //每次移动重绘游戏棋盘，会自动调用jPanel的paint方法
    39.                 jPanel.repaint();
    40.             }
    41.         };
    42.         timer=new Timer();
    43.         timer.scheduleAtFixedRate(task,0,100);
    44.     }
    45. }

    添加键盘监听

    在MainFrame类中，添加一个setKeyListener的方法，监听上下左右四个键

    1. public class MainFrame extends JFrame {
    2.     ...
    3.     public MainFrame() throws HeadlessException {
    4.        	...
    5.         //添加键盘监听
    6.         setkeyListener();
    7.     }
    8.     
    9.     //添加键盘监听
    10.     private void setkeyListener() {
    11.         //对上下左右键进行监听
    12.         addKeyListener(new KeyAdapter() {
    13.             @Override
    14.             public void keyPressed(KeyEvent e) {
    15.                 switch (e.getKeyCode()){
    16.                     //按下上键
    17.                     case KeyEvent.VK_UP:
    18.                         //蛇头方向改为上
    19.                         snake.setDirection(Direction.UP);
    20.                         break;
    21.                     //按下下键
    22.                     case KeyEvent.VK_DOWN:
    23.                         //蛇头方向改为下
    24.                         snake.setDirection(Direction.DOWN);
    25.                         break;
    26.                     //按下左键
    27.                     case KeyEvent.VK_LEFT:
    28.                         //蛇头方向改为左
    29.                         snake.setDirection(Direction.LEFT);
    30.                         break;
    31.                     //按下右键
    32.                     case KeyEvent.VK_RIGHT:
    33.                         //蛇头方向改为右
    34.                         snake.setDirection(Direction.RIGHT);
    35.                         break;
    36.                 }
    37.             }
    38.         });
    39.     }
    40. }

    到此蛇就可以跟随键盘移动了

    添加边界处理

    当蛇移动到边界处就游戏结束，把标记改为false

    1. public class Snake{
    2.     ...
    3.     //定义一个标记true表示蛇是活的，可以运动
    4.     private boolean isLive=true;
    5.     
    6.     //检查蛇是否碰壁
    7.     private void checkOver() {
    8.         //获取蛇头
    9.         Node head = body.getFirst();
    10.         int x=head.getX();
    11.         int y=head.getY();
    12.         if(x<0||y<0||x>=40||y>=40){
    13.             isLive=false;
    14.         }
    15.     }
    16. }

    在定时器中调用checkOver()方法

    1. //3.初始化定时器
    2. private void initTimer() {
    3.     TimerTask task=new TimerTask() {
    4.         @Override
    5.         public void run() {
    6.             //移动
    7.             snake.move();
    8.             //检查是否碰壁
    9.             snake.checkOver();
    10.         }
    11.     };
    12.     timer=new Timer();
    13.     timer.scheduleAtFixedRate(task,0,100);
    14. }

    把食物绘制到棋盘上

    创建一个Food类表示食物，其实食物也是一个节点，所以让Food继承Node

    1. public class Food extends Node {
    2.     //创建食物的时候，随机产生一个位置
    3.     public Food() {
    4.         reset();
    5.     }
    6.     //随产生位置
    7.     public void reset(){
    8.         //随机生成食物的坐标
    9.         Random r=new Random();
    10.         setX(r.nextInt(40));
    11.         setY(r.nextInt(40));
    12.     }
    13. }

    在MainFrame中定义一个成员Food表示食物，并把食物绘制到棋盘上

    1. public class MainFrame extends JFrame {
    2.     //定义食物
    3.     private Node food=new Node();
    4.     
    5.     public MainFrame() throws HeadlessException {
    6.         //初始化窗体参数
    7.         initFrame();
    8.         //初始化窗体中的游戏面板
    9.         initGamePanel();
    10.         //初始化定时器
    11.         initTimer();
    12.         //添加键盘监听
    13.         setkeyListener();
    14.     }
    15.     
    16.     //2.初始化游戏棋盘
    17.     private void initGamePanel() {
    18.          jPanel = new JPanel() {
    19.             //paint是用来绘制面板中的内容
    20.             @Override
    21.             public void paint(Graphics g) {
    22.                 //清空棋盘
    23.                 g.clearRect(0,0,600,600);
    24.                 
    25.                 //绘制横线、绘制竖线、绘制蛇
    26.  
    27.                 //绘制食物
    28.                 g.fillRect(food.getX()*15,food.getY()*15,15,15);
    29.             }
    30.         };
    31.         add(jPanel);
    32.     }
    33. }

    吃食物

    在Snake类中添加一个eatFood方法

    1. //吃食物
    2. public void eatFood() {
    3.     //获取蛇头
    4.     Node head = body.getFirst();
    5.     //如果蛇头和食物的位置重合，就在蛇头添加一个元素
    6.   	if(head.getX()==MainFrame.food.getX()
    7.      	&&head.getY()==MainFrame.food.getY()){
    8.         //沿着蛇头运动方向创建一个节点
    9.         //新的蛇头节点
    10.         Node newHead=null;
    11.         //检查移动的方向
    12.         switch (direction){
    13.                 //如果向左移动
    14.             case LEFT:
    15.                 //创建一个新的蛇头节点
    16.                 newHead=new Node(head.getX()-1,head.getY());
    17.                 //把心得蛇头节点添加到body的第一个元素
    18.                 body.addFirst(newHead);
    19.                 break;
    20.             case RIGHT:
    21.                 //创建一个新的蛇头节点
    22.                 newHead=new Node(head.getX()+1,head.getY());
    23.                 //把心得蛇头节点添加到body的第一个元素
    24.                 body.addFirst(newHead);
    25.                 break;
    26.             case UP:
    27.                 //创建一个新的蛇头节点
    28.                 newHead=new Node(head.getX(),head.getY()-1);
    29.                 //把心得蛇头节点添加到body的第一个元素
    30.                 body.addFirst(newHead);
    31.                 break;
    32.             case DOWN:
    33.                 //创建一个新的蛇头节点
    34.                 newHead=new Node(head.getX(),head.getY()+1);
    35.                 //把心得蛇头节点添加到body的第一个元素
    36.                 body.addFirst(newHead);
    37.                 break;
    38.         }
    39.         //每次吃完食物，让食物重置
    40.         MainFrame.food.reset();
    41.     }
    42. }

    在定时器中调用吃食物的方法

    1. //2.初始化游戏棋盘
    2. private void initGamePanel() {
    3.     jPanel = new JPanel() {
    4.         //paint是用来绘制面板中的内容
    5.         @Override
    6.         public void paint(Graphics g) {
    7.             //清空棋盘
    8.             g.clearRect(0,0,600,600);
    9.  
    10.             //绘制横线、绘制竖线、绘制蛇
    11.  
    12.             //绘制食物
    13.             g.fillRect(food.getX()*15,food.getY()*15,15,15);
    14.         }
    15.     };
    16.     add(jPanel);
    17. }
  • 相关阅读:
    JAVASE语法零基础——static成员和代码块
    cmmi分为哪几个等级？
    进程同步——信号量机制（操作系统）
    离线部署uni-app，替换启动页
    9月，1Panel开源面板项目收到了这些评论
    车牌自动识别-matlab
    汽车电子 -- PCAN View 安装与使用
    【无标题】
    JavaWeb：上传文件
    谁能想到先打败程序员的不是35岁，而是.
  • 原文地址：https://blog.csdn.net/2301_76549195/article/details/134489845