• 全文手敲代码，教你用Java实现扫雷小游戏

    摘要：本程序共封装了五个类，分别是主类GameWin类，绘制底层地图和绘制顶层地图的类MapBottom类和MapTop类，绘制底层数字的类BottomNum类，以及初始化地雷的BottomRay类和工具GameUtil类，用于存静态参数和方法。

    本文分享自华为云社区《Java实现扫雷小游戏【完整版】》，作者：橙子!。

    效果展示

    主类：GameWin类

    1. package com.sxt;
    2. import javax.swing.*;
    3. import java.awt.*;
    4. import java.awt.event.MouseAdapter;
    5. import java.awt.event.MouseEvent;
    6.  
    7. public class GameWin extends JFrame {
    8.     int width = 2 * GameUtil.OFFSET + GameUtil.MAP_W * GameUtil.SQUARE_LENGTH;
    9.     int height = 4 * GameUtil.OFFSET + GameUtil.MAP_H * GameUtil.SQUARE_LENGTH;
    10.  
    11.     Image offScreenImage = null;
    12.     MapBottom mapBottom = new MapBottom();
    13.     MapTop mapTop = new MapTop();
    14.  
    15.     void launch(){
    16.         GameUtil.START_TIME=System.currentTimeMillis();
    17.         this.setVisible(true);
    18.         this.setSize(width,height);
    19.         this.setLocationRelativeTo(null);
    20.         this.setTitle("Java扫雷小游戏");
    21.         this.setDefaultCloseOperation(EXIT_ON_CLOSE);
    22.         //鼠标事件
    23.         this.addMouseListener(new MouseAdapter() {
    24.             @Override
    25.             public void mouseClicked(MouseEvent e) {
    26.                 super.mouseClicked(e);
    27.                 switch (GameUtil.state){
    28.                     case 0 :
    29.                         if(e.getButton()==1){
    30.                             GameUtil.MOUSE_X = e.getX();
    31.                             GameUtil.MOUSE_Y = e.getY();
    32.                             GameUtil.LEFT = true;
    33.                         }
    34.                         if(e.getButton()==3) {
    35.                             GameUtil.MOUSE_X = e.getX();
    36.                             GameUtil.MOUSE_Y = e.getY();
    37.                             GameUtil.RIGHT = true;
    38.                         }
    39.                         //去掉break，任何时候都监听鼠标事件
    40.                     case 1 :
    41.                     case 2 :
    42.                         if(e.getButton()==1){
    43.                             if(e.getX()>GameUtil.OFFSET + GameUtil.SQUARE_LENGTH*(GameUtil.MAP_W/2)
    44.                                     && e.getX()<GameUtil.OFFSET + GameUtil.SQUARE_LENGTH*(GameUtil.MAP_W/2) + GameUtil.SQUARE_LENGTH
    45.                                     && e.getY()>GameUtil.OFFSET
    46.                                     && e.getY()<GameUtil.OFFSET+GameUtil.SQUARE_LENGTH){
    47.                                 mapBottom.reGame();
    48.                                 mapTop.reGame();
    49.                                 GameUtil.FLAG_NUM=0;
    50.                                 GameUtil.START_TIME=System.currentTimeMillis();
    51.                                 GameUtil.state=0;
    52.                             }
    53.                         }
    54.                         break;
    55.                     default:
    56.                 }
    57.             }
    58.         });
    59.  
    60.         while (true){
    61.             repaint();
    62.             try {
    63.                 Thread.sleep(40);
    64.             } catch (InterruptedException e) {
    65.                 e.printStackTrace();
    66.             }
    67.         }
    68.     }
    69.  
    70.     @Override
    71.     public void paint(Graphics g) {
    72.         offScreenImage = this.createImage(width,height);
    73.         Graphics gImage = offScreenImage.getGraphics();
    74.         //设置背景颜色
    75.         gImage.setColor(Color.lightGray);
    76.         gImage.fillRect(0,0,width,height);
    77.  
    78.         mapBottom.paintSelf(gImage);
    79.         mapTop.paintSelf(gImage);
    80.         g.drawImage(offScreenImage,0,0,null);
    81.     }
    82.  
    83.     public static void main(String[] args) {
    84.         GameWin gameWin = new GameWin();
    85.         gameWin.launch();
    86.     }
    87. }

    底层地图MapBottom类

    1. //底层地图：绘制游戏相关组件
    2. package com.sxt;
    3. import java.awt.*;
    4.  
    5. public class MapBottom {
    6.     BottomRay bottomRay = new BottomRay();
    7.     BottomNum bottomNum = new BottomNum();
    8.     {
    9.         bottomRay.newRay();
    10.         bottomNum.newNum();
    11.     }
    12.  
    13.     //重置游戏
    14.     void reGame(){
    15.         for (int i = 1; i <=GameUtil.MAP_W ; i++) {
    16.             for (int j = 1; j <=GameUtil.MAP_H ; j++) {
    17.                 GameUtil.DATA_BOTTOM[i][j]=0;
    18.             }
    19.         }
    20.         bottomRay.newRay();
    21.         bottomNum.newNum();
    22.     }
    23.  
    24.     //绘制方法
    25.     void paintSelf(Graphics g){
    26.         g.setColor(Color.BLACK);
    27.         //画竖线
    28.         for (int i = 0; i <= GameUtil.MAP_W; i++) {
    29.             g.drawLine(GameUtil.OFFSET + i * GameUtil.SQUARE_LENGTH,
    30.                     3*GameUtil.OFFSET,
    31.                     GameUtil.OFFSET+i*GameUtil.SQUARE_LENGTH,
    32.                     3*GameUtil.OFFSET+GameUtil.MAP_H*GameUtil.SQUARE_LENGTH);
    33.         }
    34.         //画横线
    35.         for (int i = 0; i <=GameUtil.MAP_H; i++){
    36.             g.drawLine(GameUtil.OFFSET,
    37.                     3*GameUtil.OFFSET+i*GameUtil.SQUARE_LENGTH,
    38.                     GameUtil.OFFSET+GameUtil.MAP_W*GameUtil.SQUARE_LENGTH,
    39.                     3*GameUtil.OFFSET+i*GameUtil.SQUARE_LENGTH);
    40.         }
    41.         for (int i = 1; i <= GameUtil.MAP_W ; i++) {
    42.             for (int j = 1; j <= GameUtil.MAP_H; j++) {
    43.                 //雷
    44.                 if (GameUtil.DATA_BOTTOM[i][j] == -1) {
    45.                     g.drawImage(GameUtil.lei,
    46.                             GameUtil.OFFSET + (i - 1) * GameUtil.SQUARE_LENGTH + 1,
    47.                             GameUtil.OFFSET * 3 + (j - 1) * GameUtil.SQUARE_LENGTH + 1,
    48.                             GameUtil.SQUARE_LENGTH - 2,
    49.                             GameUtil.SQUARE_LENGTH - 2,
    50.                             null);
    51.                 }
    52.                 //数字
    53.                 if (GameUtil.DATA_BOTTOM[i][j] >=0) {
    54.                     g.drawImage(GameUtil.images[GameUtil.DATA_BOTTOM[i][j]],
    55.                             GameUtil.OFFSET + (i - 1) * GameUtil.SQUARE_LENGTH + 15,
    56.                             GameUtil.OFFSET * 3 + (j - 1) * GameUtil.SQUARE_LENGTH + 5,
    57.                             null);
    58.                 }
    59.             }
    60.         }
    61.  
    62.         //绘制数字，剩余雷数，倒计时
    63.         GameUtil.drawWord(g,""+(GameUtil.RAY_MAX-GameUtil.FLAG_NUM),
    64.                 GameUtil.OFFSET,
    65.                 2*GameUtil.OFFSET,30,Color.red);
    66.         GameUtil.drawWord(g,""+(GameUtil.END_TIME-GameUtil.START_TIME)/1000,
    67.                 GameUtil.OFFSET + GameUtil.SQUARE_LENGTH*(GameUtil.MAP_W-1),
    68.                 2*GameUtil.OFFSET,30,Color.red);
    69.         switch (GameUtil.state){
    70.             case 0:
    71.                 GameUtil.END_TIME=System.currentTimeMillis();
    72.                 g.drawImage(GameUtil.face,
    73.                         GameUtil.OFFSET + GameUtil.SQUARE_LENGTH * (GameUtil.MAP_W/2),
    74.                         GameUtil.OFFSET,
    75.                         null);
    76.                 break;
    77.             case 1:
    78.                 g.drawImage(GameUtil.win,
    79.                         GameUtil.OFFSET + GameUtil.SQUARE_LENGTH * (GameUtil.MAP_W/2),
    80.                         GameUtil.OFFSET,
    81.                         null);
    82.                 break;
    83.             case 2:
    84.                 g.drawImage(GameUtil.over,
    85.                         GameUtil.OFFSET + GameUtil.SQUARE_LENGTH * (GameUtil.MAP_W/2),
    86.                         GameUtil.OFFSET,
    87.                         null);
    88.                 break;
    89.             default:
    90.         }
    91.     }
    92. }

    顶层地图MapTop类

    1. 顶层地图类：绘制顶层组件
    2. package com.sxt;
    3. import java.awt.*;
    4.  
    5. public class MapTop {
    6.     //格子位置
    7.     int temp_x;
    8.     int temp_y;
    9.  
    10.     //重置游戏
    11.     void reGame(){
    12.         for (int i = 1; i <=GameUtil.MAP_W ; i++) {
    13.             for (int j = 1; j <=GameUtil.MAP_H ; j++) {
    14.                 GameUtil.DATA_TOP[i][j]=0;
    15.             }
    16.         }
    17.     }
    18.  
    19.     //判断逻辑
    20.     void logic(){
    21.         temp_x=0;
    22.         temp_y=0;
    23.         if(GameUtil.MOUSE_X>GameUtil.OFFSET && GameUtil.MOUSE_Y>3*GameUtil.OFFSET){
    24.             temp_x = (GameUtil.MOUSE_X - GameUtil.OFFSET)/GameUtil.SQUARE_LENGTH+1;
    25.             temp_y = (GameUtil.MOUSE_Y - GameUtil.OFFSET * 3)/GameUtil.SQUARE_LENGTH+1;
    26.         }
    27.  
    28.         if(temp_x>=1 && temp_x<=GameUtil.MAP_W
    29.                 && temp_y>=1 && temp_y<=GameUtil.MAP_H){
    30.             if(GameUtil.LEFT){
    31.                 //覆盖,则翻开
    32.                 if(GameUtil.DATA_TOP[temp_x][temp_y]==0){
    33.                     GameUtil.DATA_TOP[temp_x][temp_y]=-1;
    34.                 }
    35.                 spaceOpen(temp_x,temp_y);
    36.                 GameUtil.LEFT=false;
    37.             }
    38.             if(GameUtil.RIGHT){
    39.                 //覆盖则插旗
    40.                 if(GameUtil.DATA_TOP[temp_x][temp_y]==0){
    41.                     GameUtil.DATA_TOP[temp_x][temp_y]=1;
    42.                     GameUtil.FLAG_NUM++;
    43.                 }
    44.                 //插旗则取消
    45.                 else if(GameUtil.DATA_TOP[temp_x][temp_y]==1){
    46.                     GameUtil.DATA_TOP[temp_x][temp_y]=0;
    47.                     GameUtil.FLAG_NUM--;
    48.                 }
    49.                 else if(GameUtil.DATA_TOP[temp_x][temp_y]==-1){
    50.                     numOpen(temp_x,temp_y);
    51.                 }
    52.                 GameUtil.RIGHT=false;
    53.             }
    54.         }
    55.         boom();
    56.         victory();
    57.     }
    58.     //数字翻开
    59.     void numOpen(int x,int y){
    60.         //记录旗数
    61.         int count=0;
    62.         if(GameUtil.DATA_BOTTOM[x][y]>0){
    63.             for (int i = x-1; i <=x+1 ; i++) {
    64.                 for (int j = y-1; j <=y+1 ; j++) {
    65.                     if(GameUtil.DATA_TOP[i][j]==1){
    66.                         count++;
    67.                     }
    68.                 }
    69.             }
    70.             if(count==GameUtil.DATA_BOTTOM[x][y]){
    71.                 for (int i = x-1; i <=x+1 ; i++) {
    72.                     for (int j = y-1; j <=y+1 ; j++) {
    73.                         if(GameUtil.DATA_TOP[i][j]!=1){
    74.                             GameUtil.DATA_TOP[i][j]=-1;
    75.                         }
    76.                         //必须在雷区当中
    77.                         if(i>=1&&j>=1&&i<=GameUtil.MAP_W&&j<=GameUtil.MAP_H){
    78.                             spaceOpen(i,j);
    79.                         }
    80.                     }
    81.                 }
    82.             }
    83.         }
    84.     }
    85.     //失败判定  t 表示失败 f 未失败
    86.     boolean boom(){
    87.         if(GameUtil.FLAG_NUM==GameUtil.RAY_MAX){
    88.             for (int i = 1; i <=GameUtil.MAP_W ; i++) {
    89.                 for (int j = 1; j <=GameUtil.MAP_H ; j++) {
    90.                     if(GameUtil.DATA_TOP[i][j]==0){
    91.                         GameUtil.DATA_TOP[i][j]=-1;
    92.                     }
    93.                 }
    94.             }
    95.         }
    96.         for (int i = 1; i <=GameUtil.MAP_W ; i++) {
    97.             for (int j = 1; j <=GameUtil.MAP_H ; j++) {
    98.                 if(GameUtil.DATA_BOTTOM[i][j]==-1&&GameUtil.DATA_TOP[i][j]==-1){
    99.                     GameUtil.state = 2;
    100.                     seeBoom();
    101.                     return true;
    102.                 }
    103.             }
    104.         }
    105.         return false;
    106.     }
    107.     //失败显示
    108.     void seeBoom(){
    109.         for (int i = 1; i <=GameUtil.MAP_W ; i++) {
    110.             for (int j = 1; j <=GameUtil.MAP_H ; j++) {
    111.                 //底层是雷,顶层不是旗,显示
    112.                 if(GameUtil.DATA_BOTTOM[i][j]==-1&&GameUtil.DATA_TOP[i][j]!=1){
    113.                     GameUtil.DATA_TOP[i][j]=-1;
    114.                 }
    115.                 //底层不是雷,顶层是旗,显示差错旗
    116.                 if(GameUtil.DATA_BOTTOM[i][j]!=-1&&GameUtil.DATA_TOP[i][j]==1){
    117.                     GameUtil.DATA_TOP[i][j]=2;
    118.                 }
    119.             }
    120.         }
    121.     }
    122.     //胜利判断  t 表示胜利 f 未胜利
    123.     boolean victory(){
    124.         //统计未打开格子数
    125.         int count=0;
    126.         for (int i = 1; i <=GameUtil.MAP_W ; i++) {
    127.             for (int j = 1; j <=GameUtil.MAP_H ; j++) {
    128.                 if(GameUtil.DATA_TOP[i][j]!=-1){
    129.                     count++;
    130.                 }
    131.             }
    132.         }
    133.         if(count==GameUtil.RAY_MAX){
    134.             GameUtil.state=1;
    135.             for (int i = 1; i <=GameUtil.MAP_W ; i++) {
    136.                 for (int j = 1; j <=GameUtil.MAP_H ; j++) {
    137.                     //未翻开,变成旗
    138.                     if(GameUtil.DATA_TOP[i][j]==0){
    139.                         GameUtil.DATA_TOP[i][j]=1;
    140.                     }
    141.                 }
    142.             }
    143.             return true;
    144.         }
    145.         return false;
    146.     }
    147.  
    148.     //打开空格
    149.     void spaceOpen(int x,int y){
    150.         if(GameUtil.DATA_BOTTOM[x][y]==0){
    151.             for (int i = x-1; i <=x+1 ; i++) {
    152.                 for (int j = y-1; j <=y+1 ; j++) {
    153.                     //覆盖,才递归
    154.                     if(GameUtil.DATA_TOP[i][j]!=-1){
    155.                         if(GameUtil.DATA_TOP[i][j]==1){GameUtil.FLAG_NUM--;}
    156.                         GameUtil.DATA_TOP[i][j]=-1;
    157.                         //必须在雷区当中
    158.                         if(i>=1&&j>=1&&i<=GameUtil.MAP_W&&j<=GameUtil.MAP_H){
    159.                             spaceOpen(i,j);
    160.                         }
    161.                     }
    162.                 }
    163.             }
    164.         }
    165.     }
    166.     //绘制方法
    167.     void paintSelf(Graphics g){
    168.         logic();
    169.         for (int i = 1; i <= GameUtil.MAP_W ; i++) {
    170.             for (int j = 1; j <= GameUtil.MAP_H; j++) {
    171.                 //覆盖
    172.                 if (GameUtil.DATA_TOP[i][j] == 0) {
    173.                     g.drawImage(GameUtil.top,
    174.                             GameUtil.OFFSET + (i - 1) * GameUtil.SQUARE_LENGTH + 1,
    175.                             GameUtil.OFFSET * 3 + (j - 1) * GameUtil.SQUARE_LENGTH + 1,
    176.                             GameUtil.SQUARE_LENGTH - 2,
    177.                             GameUtil.SQUARE_LENGTH - 2,
    178.                             null);
    179.                 }
    180.                 //插旗
    181.                 if (GameUtil.DATA_TOP[i][j] == 1) {
    182.                     g.drawImage(GameUtil.flag,
    183.                             GameUtil.OFFSET + (i - 1) * GameUtil.SQUARE_LENGTH + 1,
    184.                             GameUtil.OFFSET * 3 + (j - 1) * GameUtil.SQUARE_LENGTH + 1,
    185.                             GameUtil.SQUARE_LENGTH - 2,
    186.                             GameUtil.SQUARE_LENGTH - 2,
    187.                             null);
    188.                 }
    189.                 //差错旗
    190.                 if (GameUtil.DATA_TOP[i][j] == 2) {
    191.                     g.drawImage(GameUtil.noflag,
    192.                             GameUtil.OFFSET + (i - 1) * GameUtil.SQUARE_LENGTH + 1,
    193.                             GameUtil.OFFSET * 3 + (j - 1) * GameUtil.SQUARE_LENGTH + 1,
    194.                             GameUtil.SQUARE_LENGTH - 2,
    195.                             GameUtil.SQUARE_LENGTH - 2,
    196.                             null);
    197.                 }
    198.             }
    199.         }
    200.     }
    201. }

    底层数字BottomNum类

    1. //底层数字类
    2. package com.sxt;
    3.  
    4. public class BottomNum {
    5.     void newNum() {
    6.         for (int i = 1; i <=GameUtil.MAP_W ; i++) {
    7.             for (int j = 1; j <=GameUtil.MAP_H ; j++) {
    8.                 if(GameUtil.DATA_BOTTOM[i][j]==-1){
    9.                     for (int k = i-1; k <=i+1 ; k++) {
    10.                         for (int l = j-1; l <=j+1 ; l++) {
    11.                             if(GameUtil.DATA_BOTTOM[k][l]>=0){
    12.                                 GameUtil.DATA_BOTTOM[k][l]++;
    13.                             }
    14.                         }
    15.                     }
    16.                 }
    17.             }
    18.         }
    19.     }
    20. }

    初始化地雷BottomRay类

    1. //初始化地雷类
    2. package com.sxt;
    3.  
    4. public class BottomRay {
    5.     //存放坐标
    6.     int[] rays = new int[GameUtil.RAY_MAX*2];
    7.     //地雷坐标
    8.     int x,y;
    9.     //是否放置 T 表示可以放置 F 不可放置
    10.     boolean isPlace = true;
    11.  
    12.     //生成雷
    13.     void newRay() {
    14.         for (int i = 0; i < GameUtil.RAY_MAX*2 ; i=i+2) {
    15.             x= (int) (Math.random()*GameUtil.MAP_W +1);//1-12
    16.             y= (int) (Math.random()*GameUtil.MAP_H +1);//1-12
    17.             //判断坐标是否存在
    18.             for (int j = 0; j < i ; j=j+2) {
    19.                 if(x==rays[j] && y==rays[j+1]){
    20.                     i=i-2;
    21.                     isPlace = false;
    22.                     break;
    23.                 }
    24.             }
    25.             //将坐标放入数组
    26.             if(isPlace){
    27.                 rays[i]=x;
    28.                 rays[i+1]=y;
    29.             }
    30.             isPlace = true;
    31.         }
    32.  
    33.         for (int i = 0; i < GameUtil.RAY_MAX*2; i=i+2) {
    34.             GameUtil.DATA_BOTTOM[rays[i]][rays[i+1]]=-1;
    35.         }
    36.     }
    37. }

    工具GameUtil类

    1. //工具类：存放静态参数，工具方法
    2. package com.sxt;
    3. import java.awt.*;
    4.  
    5. public class GameUtil {
    6.     //地雷个数
    7.     static int RAY_MAX = 5;
    8.     //地图的宽
    9.     static int MAP_W = 11;
    10.     //地图的高
    11.     static int MAP_H = 11;
    12.     //雷区偏移量
    13.     static int OFFSET = 45;
    14.     //格子边长
    15.     static int SQUARE_LENGTH = 50;
    16.  
    17.     //插旗数量
    18.     static int FLAG_NUM = 0;
    19.  
    20.     //鼠标相关
    21.     //坐标
    22.     static int MOUSE_X;
    23.     static int MOUSE_Y;
    24.     //状态
    25.     static boolean LEFT = false;
    26.     static boolean RIGHT = false;
    27.  
    28.     //游戏状态 0 表示游戏中 1 胜利 2 失败
    29.     static int state = 0;
    30.  
    31.     //倒计时
    32.     static long START_TIME;
    33.     static long END_TIME;
    34.  
    35.     //底层元素  -1 雷 0 空 1-8 表示对应数字
    36.     static int[][] DATA_BOTTOM = new int[MAP_W+2][MAP_H+2];
    37.     //顶层元素  -1 无覆盖 0 覆盖 1 插旗 2 差错旗
    38.     static int[][] DATA_TOP = new int[MAP_W+2][MAP_H+2];
    39.  
    40.     //载入图片
    41.     static Image lei = Toolkit.getDefaultToolkit().getImage("imgs/lei.png");
    42.     static Image top = Toolkit.getDefaultToolkit().getImage("imgs/top.gif");
    43.     static Image flag = Toolkit.getDefaultToolkit().getImage("imgs/flag.gif");
    44.     static Image noflag = Toolkit.getDefaultToolkit().getImage("imgs/noflag.png");
    45.  
    46.     static Image face = Toolkit.getDefaultToolkit().getImage("imgs/face.png");
    47.     static Image over = Toolkit.getDefaultToolkit().getImage("imgs/over.png");
    48.     static Image win = Toolkit.getDefaultToolkit().getImage("imgs/win.png");
    49.  
    50.     static Image[] images = new Image[9];
    51.     static {
    52.         for (int i = 1; i <=8 ; i++) {
    53.             images[i] = Toolkit.getDefaultToolkit().getImage("imgs/num/"+i+".png");
    54.         }
    55.     }
    56.  
    57.     static void drawWord(Graphics g,String str,int x,int y,int size,Color color){
    58.         g.setColor(color);
    59.         g.setFont(new Font("仿宋",Font.BOLD,size));
    60.         g.drawString(str,x,y);
    61.     }
    62. }

    总结

    在使用Java编写扫雷小游戏时遇到了很多问题，在解决问题时，确实对java的面向对象编程有了更加深入的理解。虽然GUI现在并没有很大的市场，甚至好多初学者已经放弃了学习GUI，但是利用GUI编程的过程对于培养编程兴趣，深入理解Java编程有很大的作用。

    本程序共封装了五个类，分别是主类GameWin类，绘制底层地图和绘制顶层地图的类MapBottom类和MapTop类，绘制底层数字的类BottomNum类，以及初始化地雷的BottomRay类和工具GameUtil类，用于存静态参数和方法。

    游戏的设计类似windows扫雷，用户在图形化用户界面内利用鼠标监听事件标记雷区，左上角表示剩余雷的数量，右上角动态显示使用的时间。用户可选择中间组件按钮重新游戏。为了解决程序窗口闪动的问题，本程序采用了双缓冲技术。

    程序的总体界面布局：

    项目结构：

    程序测试：

    请大家指正！

    点击关注，第一时间了解华为云新鲜技术~

  • 相关阅读:
    Linux 网络性能的 15 个优化建议
    一图读懂腾讯云EdgeOne Open Edge平台
    Matter理论教程-通用-1-01：理论详解
    NX二次开发-几款辅助学习NX开发的搜索软件
    什么是抽象类
    AWTK UI 自动化测试工具发布
    淘宝API接口商品详情，关键词搜索
    flutter系列之:flutter中常用的GridView layout详解
    Redis高可用之哨兵模式、集群
    Unity 3D 2022.1 AND UnityHub 3.2 Patch
  • 原文地址：https://blog.csdn.net/devcloud/article/details/125546346