Java awt项目开发

通过Java awt 界面上的知识编写的扫雷游戏

代码中有详细的注解

package com.langsin.saolei;

import java.awt.Color;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Insets;
import java.awt.Label;
import java.awt.Menu;
import java.awt.MenuBar;
import java.awt.MenuItem;
import java.awt.MenuShortcut;
import java.awt.TextArea;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class Saolei extends Frame implements ActionListener {
// 先定义横向的按钮的个数和纵向的按钮的个
private static int WITH = 10;
private static int LENG = 10;
// 定义地雷的个数
private static int Mines_Count = 10;
// 定义旗帜的个数
private static int Red_Count = 10;
// 定义一个random类
private static Random random = new Random();
// 定义一个二维数组
private static Bomb[][] jb = new Bomb[WITH][LENG];
// 判断是否结束
private boolean flag = false;
// 判断是否成功 默认是没有成功
private boolean sucess = false;
// 用集合暂存sucess.txt中的内容
private List<String> list = new ArrayList<String>();
// 用集合暂存游戏时间
private List<String> listtime = new ArrayList<String>();
StringBuffer buffer = new StringBuffer();
// 定义一个面板成员变量
private JPanel jp;
// 记录时间的线程
private Runnable runnable;
// 已用时间
private int usedTime = 0;
// 定义两个标签 时间和旗帜
private Label time, redFlag;
/*
* 检测某点周围是否有雷，周围点的坐标可由该数组计算得到
*/
private int[][] mv = { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 }, { 1, 1 },
{ -1, -1 }, { 1, -1 }, { -1, 1 } };

// 通过构造器初始化
public Saolei() throws Exception {
super("扫雷");
// 绝对布局管理器
this.setLayout(null);
// 设置图标
this.setIconImage(ImageIO.read(new File("./image/图标.jpg")));
// 设置大小
this.setBounds(100, 100, 500, 500);
this.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
setMenu();
intMine();
intBottom();
this.setResizable(false);
this.setVisible(true);
}

// 设置初始化菜单
public void setMenu() {
// 菜单条
MenuBar menbar = new MenuBar();
// 菜单项 游戏
Menu game = new Menu("游戏（G）");
// 菜单项游戏的组件 新游戏
MenuItem newgame = new MenuItem("新游戏");
// 游戏从新开始

newgame.addActionListener(new ActionListener() {

@Override
public void actionPerformed(ActionEvent e) {
// 调用重新开始游戏的方法
resetGame();
}
});
game.add(newgame);

// 菜单项游戏的组件 更改外观
MenuItem change = new MenuItem("更改外观");
change.addActionListener(new ActionListener() {

@Override
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < WITH; i++) {
for (int j = 0; j < LENG; j++) {
if (!jb[i][j].isIsclicked() && jb[i][j].isEnabled()) {
jb[i][j].setBackground(Color.BLUE);
} else {
jb[i][j].setBackground(Color.WHITE);
}
}
}
}
});
game.add(change);
// 加一条横线
// game.addSeparator();
game.add(new MenuItem("-"));
// 菜单项游戏的组件 退出
MenuItem exit = new MenuItem("退出",
new MenuShortcut(KeyEvent.VK_A, true));
exit.addActionListener(new ActionListener() {

@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
System.exit(0);
}

});
game.add(exit);
menbar.add(game);

// 菜单项 帮助
Menu Tj = new Menu("统计（T）");
// 菜单项游戏的组件 统计信息
MenuItem record = new MenuItem("查看统计信息");
// 将游戏的成败和时间记录两个txt文本中
record.addActionListener(new ActionListener() {

@Override
public void actionPerformed(ActionEvent e) {
try {
Tongji();
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
});
Tj.add(record);
menbar.add(Tj);
// 添加菜单条
this.setMenuBar(menbar);
}

// 初始化底部
private void intBottom() {
// 创建两个label 一个是时间 一个是计时
Label lab1 = new Label("时间");
lab1.setFont(new Font("宋体", Font.BOLD, 15));
lab1.setForeground(Color.BLUE);
lab1.setBounds(80, 430, 35, 35);
this.add(lab1);
time = new Label("0");
time.setFont(new Font("宋体", Font.PLAIN, 15));
time.setBounds(140, 435, 50, 25);
this.add(time);
// 一个是标记 小红旗的个数
Label lab2 = new Label("旗帜");
lab2.setFont(new Font("宋体", Font.BOLD, 15));
lab2.setForeground(Color.BLUE);
lab2.setBounds(300, 430, 35, 35);
this.add(lab2);
redFlag = new Label(" 10");
redFlag.setFont(new Font("宋体", Font.PLAIN, 15));
redFlag.setBounds(350, 435, 50, 25);
this.add(redFlag);
// 通过接口来实现
runnable = new Runnable() {
public void run() {
while (true) {
// 是否结束
if (flag) {
break;
}
try {
// 睡眠1s
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 已用时间+1
usedTime++;
time.setText(String.valueOf(usedTime));
}
}
};
// 开始线程
new Thread(runnable).start();
}

// 初始化雷区(用按钮来充当地雷 用面板在面板上添加按钮)
private void intMine() {
// 将按钮放在面板上
jp = new JPanel();
// 面板的布局管理器为网格布局管理器
jp.setLayout(new GridLayout(WITH, LENG, 0, 0));
// 设置面板的位置
jp.setBounds(75, 70, 350, 350);
makeMines(true);
this.add(jp);
}

// 随机布置雷区 重置雷区
private void makeMines(boolean newFlag) {
// 在面板上面放按钮 并设置初始按钮属性
for (int i = 0; i < LENG; i++) {
for (int j = 0; j < WITH; j++) {
if (newFlag) {
// 记录下位置
jb[i][j] = new Bomb(i, j);
jp.add(jb[i][j]);
// 设置按钮和标签之间的空白 数字所在按钮的位置
jb[i][j].setMargin(new Insets(0, 0, 0, 0));
jb[i][j].addActionListener(this);
// 鼠标点击事件 鼠标右击
jb[i][j].addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
Object obj = e.getSource();
// e.isMetaDown() 检测鼠标右键单击
if (e.isMetaDown() && obj instanceof Bomb) {
// 强制类型转换
Bomb bomb = (Bomb) obj;
// 旗帜的个数大于等于0
if (bomb.isEnabled() && Red_Count >= 0) {
// 定义一个数字 来判定状态
// 右击点一下 变为1 红旗状态 两下变为2 ？号状态
int num = (bomb.getBombflag() + 1) % 3;
switch (num) {
case 0:
// 初始状态
bomb.setIcon(null);
break;
case 1:
Red_Count--;
// 缓冲图片对象
BufferedImage bf1 = new BufferedImage(
35, 35,
BufferedImage.TYPE_INT_RGB);
// 通过缓存图片对象，来得到画笔工具对象Graphics，对缓存图片进行修改
Graphics grap = bf1.getGraphics();
// 先读到这幅图片
Image image;
try {
image = ImageIO.read(new File(
"./image/红旗.jpg"));
// 然后通过画笔对象来改变它,将这幅图片进行缩放
grap.drawImage(image, 0, 0, 35, 35,
null);
bomb.setIcon(new ImageIcon(bf1));
} catch (IOException e2) {
// TODO Auto-generated catch block
e2.printStackTrace();
}

break;
case 2:
Red_Count++;
// 缓冲图片对象
BufferedImage bf2 = new BufferedImage(
35, 35,
BufferedImage.TYPE_INT_RGB);
// 通过缓存图片对象，来得到画笔工具对象Graphics，对缓存图片进行修改
Graphics grap2 = bf2.getGraphics();
// 先读到这幅图片
Image image2;
try {
// 然后通过画笔对象来改变它,将这幅图片进行缩放
image2 = ImageIO.read(new File(
"./image/问号.jpg"));
grap2.drawImage(image2, 0, 0, 35,
35, null);
bomb.setIcon(new ImageIcon(bf2));
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}

break;
default:
break;
}
redFlag.setText(String.valueOf(Red_Count));
// 改变状态
bomb.setBombflag(num);
try {
checkSuccess();
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
}
}
});
} else {
jb[i][j].setIcon(null);
jb[i][j].setEnabled(true);
// 默认为都没有点击
jb[i][j].setIsclicked(false);
jb[i][j].setText("");
// 默认是无雷
jb[i][j].setBomb(false);
// 默认初始状态值为0
jb[i][j].setBombflag(0);
}
}
}
// 布雷的个数
int i = 0;
// 定义坐标
int x, y;
while (i < 10) {
x = random.nextInt(WITH);
y = random.nextInt(LENG);
// 判断这个地方是否有雷 默认没有
if (!jb[x][y].isBomb()) {
// 设置为有雷
jb[x][y].setBomb(true);
// 查看是否有重复的
// 查看坐标位置 其中y对应的是列 x对应的是行 从0-9
System.out.println(x + " " + y);
i++;
}
}
}

// 通过点击事件来判断游戏的进展
// 点击事件
@Override
public void actionPerformed(ActionEvent e) {
Object obj = e.getSource();
if (obj instanceof Bomb) {
Bomb bs = (Bomb) obj;
// 如果得到的状态是1 即红旗 结束点击事件
if (bs.getBombflag() == 1) {
return;
}
// 如果得到的状态是2 即“？”
else if (bs.getBombflag() == 2) {
// 点击一下将问号去除
bs.setIsclicked(true);
bs.setIcon(null);
}
// 如果点到的是雷
if (bs.isBomb()) {
// 缓冲图片对象
BufferedImage bf1 = new BufferedImage(35, 35,
BufferedImage.TYPE_INT_RGB);
// 通过缓存图片对象，来得到画笔工具对象Graphics，对缓存图片进行修改
Graphics grap = bf1.getGraphics();
// 先读到这幅图片
Image image;
try {
image = ImageIO.read(new File("./image/地雷.png"));
// 然后通过画笔对象来改变它,将这幅图片进行缩放
grap.drawImage(image, 0, 0, 35, 35, null);
// 将图片设置为雷
bs.setIcon(new ImageIcon(bf1));
} catch (IOException e2) {
// TODO Auto-generated catch block
e2.printStackTrace();
}
// 游戏结束
flag = true;
// 显示所有的雷
try {
showMine();
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
// 弹出一个窗口对话框显示游戏结束 结束点击事件
JOptionPane.showMessageDialog(this, "扫雷失败!");
return;
}
// 没有点到雷时
// 通过算法判断是否有雷 来判断周围雷的情况
judge(bs.getNum_x(), bs.getNum_y());
}
}

// 重新开始游戏
private void resetGame() {
flag = true;
Red_Count = 10;
time.setText("0");
usedTime = 0;
redFlag.setText("10");
makeMines(false);
// 将游戏外观设为初始
for (int i = 0; i < WITH; i++) {
for (int j = 0; j < LENG; j++) {
jb[i][j].setBackground(null);
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}

new Thread(runnable).start();
flag = false;
}

// 如果点到雷，游戏结束显示所有雷
// 显示所有雷的方法
private void showMine() throws Exception {
for (int i = 0; i < WITH; i++) {
for (int j = 0; j < LENG; j++) {
if (jb[i][j].isBomb()) {
// 缓冲图片对象
BufferedImage bf1 = new BufferedImage(35, 35,
BufferedImage.TYPE_INT_RGB);
// 通过缓存图片对象，来得到画笔工具对象Graphics，对缓存图片进行修改
Graphics grap = bf1.getGraphics();
// 先读到这幅图片
Image image = ImageIO.read(new File("./image/地雷.png"));
// 然后通过画笔对象来改变它,将这幅图片进行缩放
grap.drawImage(image, 0, 0, 35, 35, null);
jb[i][j].setIcon(new ImageIcon(bf1));

}
}
}
}

// 判断是否成功
private void checkSuccess() throws Exception {
int count = 0;
for (int i = 0; i < LENG; i++) {
for (int j = 0; j < WITH; j++) {
// 如果是雷 并且这个地方有红旗
if (jb[i][j].isBomb() && jb[i][j].getBombflag() == 1) {
// 进行累加
count++;
}
}
}
if (count == Mines_Count) {
flag = true;
JOptionPane.showMessageDialog(this, "恭喜你，胜利了！");
sucess = true;
String tm = time.getText();
listtime.add(tm);
writesucess(sucess);
}
}

// 判断周围是否有雷
private void judge(int x, int y) {
// 设置(x,y)这个位置已经点击 得到这个位置
jb[x][y].setIsclicked(true);
// 点击了以后将背景设置为白色
jb[x][y].setBackground(Color.WHITE);
// 点过的设置为不可点击 点击过设置为不可用
jb[x][y].setEnabled(false);
// 设定点击的这个点的相对初始位置是（0，0） 设定初始周围雷的个数是0
int sx = 0;
int sy = 0;
int mineNumber = 0;
for (int i = 0; i < mv.length; i++) {
sx = x + mv[i][0];
sy = y + mv[i][1];
// 保证所有的坐标点都在面板上 判断那些没有被点击过的按钮
if (sx >= 0 && sx < WITH && sy >= 0 && sy < LENG) {
if (jb[sx][sy].isBomb()) {
// 如果是雷的话
// 显示的数字累加 得到(x,y)这个位置周围雷的个数
mineNumber++;
}
}
}
// 通过递归来实现
if (mineNumber == 0) {
for (int i = 0; i < mv.length; i++) {
sx = x + mv[i][0];
sy = y + mv[i][1];
// 保证所有的坐标都对应一个按钮
if (sx >= 0 && sx < LENG && sy >= 0 && sy < LENG
&& !jb[sx][sy].isIsclicked()) {
judge(sx, sy);
}
}

} else {
jb[x][y].setFont(new Font("宋体", Font.BOLD, 12));
jb[x][y].setText(String.valueOf(mineNumber));
}
}

// 只有成功了才写
// 写一个方法将成功记录写到sucess.txt 文件中
private void writesucess(boolean sucess) throws Exception {
int snum = 0;
// 如果list中没有元素
readsucess();
if (list.isEmpty()) {
PrintWriter pw = new PrintWriter(new File("./sucess.txt"));
pw.println("游戏结果\t游戏时间");

buffer.append("游戏成功" + "\t" + listtime.get(snum));
pw.println(buffer.toString());
pw.close();
snum++;
} else {
PrintWriter pw = new PrintWriter(new File("./sucess.txt"));
for (int i = 0; i < list.size(); i++) {
pw.println(list.get(i));
}
buffer.append("游戏成功" + "\t" + listtime.get(snum));
pw.println(buffer.toString());
pw.close();
snum++;
}

}

private void readsucess() throws Exception {
BufferedReader br = new BufferedReader(new FileReader("./sucess.txt"));
String line = null;
while ((line = br.readLine()) != null) {
list.add(line);
}
br.close();
}

// 建立一个新的窗口
private void Tongji() throws Exception {
final Frame frame = new Frame("统计信息");
frame.setBounds(100, 100, 300, 300);
TextArea ta = new TextArea();
ta.setFont(new Font("宋体", Font.BOLD, 15));
ta.setForeground(Color.BLUE);
BufferedReader bf = new BufferedReader(new FileReader(new File(
"./sucess.txt")));
String line = null;
StringBuffer buf = new StringBuffer();
while ((line = bf.readLine()) != null) {
buf.append(line + "\n");
}
ta.setText(buf.toString());
bf.close();
frame.add(ta);
frame.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
frame.dispose();
}
});
frame.setResizable(false);
frame.setVisible(true);

}

// 程序执行
public static void main(String[] args) throws Exception {
new Saolei();
}
}