java实现扫雷小游戏

package GUI;

import java.util.Random;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.Font;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.event.InputEvent;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JButton;
import javax.swing.JTextField;
import javax.swing.JMenuBar;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.UIManager;
import javax.swing.ImageIcon;
import javax.swing.BorderFactory;
import javax.swing.border.EmptyBorder;

public class MineSweeperFrame extends JFrame {
 // 游戏模式编号
 public static final int Custom_Mode = 0;
 public static final int Elementary_Mode = 1;
 public static final int Intermediate_Mode = 2;
 public static final int Advanced_Mode = 3;
 // 游戏模式参数
 public static final int[] Elementary = {9, 9, 10, Elementary_Mode};
 public static final int[] Intermediate = {16, 16, 40, Intermediate_Mode};
 public static final int[] Advanced = {16, 30, 99, Advanced_Mode};
 // 游戏字体、图片、文字颜色
 private static final Font FontC = new Font("Consolas", Font.PLAIN, 22);
 private static final Font FontD = new Font("等线", Font.PLAIN, 20);
 private static final ImageIcon imgicon = new ImageIcon(
  MineSweeperFrame.class.getResource("/Images/icon.jpg"));
 private static final ImageIcon imgflag = new ImageIcon(
  MineSweeperFrame.class.getResource("/Images/flag.png"));
 private static final ImageIcon imgbomb = new ImageIcon(
  MineSweeperFrame.class.getResource("/Images/bomb.png"));
 private static final Color[] NumberColor = {Color.blue, 
  Color.green, Color.orange, Color.magenta, 
  Color.red, Color.cyan, Color.black, Color.gray};
 // 数据文件及高分记录
 private static File file = new File("MineSweeper.txt");
 private static int HighScore_Elementary;
 private static int HighScore_Intermediate;
 private static int HighScore_Advanced;
 
 private int gamemode;
 private int row;
 private int column;
 private int area;
 private int minecount;
 private int flagcount;
 private int enablecount;
 private boolean[][] minearea;
 private boolean[][] flagmark;
 private boolean isGameOver;
 private boolean isFirstClick;
 private TimeThread timeThread;
 
 private JPanel contentPane;
 private JMenuBar menuBar;
 private JPanel pnlCount;
 private JPanel pnlMine;
 private MineButton[][] btnMine;
 private JTextField txtTime;
 private JTextField txtCount;
 
 /**
 * Launch the application.
 */
 public static void main(String[] args) {
 int[] i = getDataFromFile();
 EventQueue.invokeLater(new Runnable() {
  public void run() {
  try {
   new MineSweeperFrame(i[0], i[1], i[2], i[3]);
  } catch (Exception e) {
   e.printStackTrace();
  }
  }
 });
 }

 /**
 * Create the frame.
 */
 public MineSweeperFrame(int row, int column, int minecount, int mode) {
 // 设置各组件的默认字体
 UIManager.put("Menu.font", FontD);
 UIManager.put("Label.font", FontD);
 UIManager.put("Button.font", FontD);
 UIManager.put("MenuBar.font", FontD);
 UIManager.put("MenuItem.font", FontD);
 UIManager.put("TextField.font", FontD);
 UIManager.put("OptionPane.buttonFont", FontD);
 UIManager.put("OptionPane.messageFont", FontD);
 
 setTitle("扫雷");
 setResizable(false);  // 设置窗口不可改变大小
 setVisible(true);   // 设置窗口初始可见
 setIconImage(imgicon.getImage()); // 设置窗体的icon
 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 // 注册监听器，响应窗口关闭事件
 addWindowListener(new WindowAdapter() {
  public void windowClosing(WindowEvent e){
  saveDataToFile();
  }
 });
 
 menuBar = new JMenuBar();
 setJMenuBar(menuBar);
 
 JMenu mGame = new JMenu("游戏");
 menuBar.add(mGame);
 
 JMenu mRestart = new JMenu("重新开始");
 mGame.add(mRestart);
 
 JMenuItem mitRestart = new JMenuItem("重新开始本局");
 mitRestart.addActionListener(new RestartListener());
 mRestart.add(mitRestart);
 
 JMenuItem mitReset = new JMenuItem("开始新的游戏");
 mitReset.addActionListener(new ResetMineListener());
 mRestart.add(mitReset);
 
 JMenu mDifficulty = new JMenu("难度设置");
 mGame.add(mDifficulty);
 
 JMenuItem mitElementary = new JMenuItem("初级");
 mitElementary.addActionListener(new ResetModeListener(Elementary));
 mDifficulty.add(mitElementary);
 
 JMenuItem mitIntermediate = new JMenuItem("中级");
 mitIntermediate.addActionListener(new ResetModeListener(Intermediate));
 mDifficulty.add(mitIntermediate);
 
 JMenuItem mitAdvanced = new JMenuItem("高级");
 mitAdvanced.addActionListener(new ResetModeListener(Advanced));
 mDifficulty.add(mitAdvanced);
 
 JMenuItem mitCustom = new JMenuItem("自定义");
 mitCustom.addActionListener(new CustomSizeFrameListener());
 mDifficulty.add(mitCustom);
 
 JMenuItem mitHighScore = new JMenuItem("高分榜");
 mitHighScore.addActionListener(new HighScoreListener());
 mGame.add(mitHighScore);
 
 mGame.addSeparator();
 JMenuItem mitExit = new JMenuItem("退出");
 // 注册监听器，监听“退出”菜单项
 mitExit.addActionListener(new ActionListener() {
  public void actionPerformed(ActionEvent e) {
  saveDataToFile();
  System.exit(0);
  }
 });
 mGame.add(mitExit);
 
 JMenu mHelp = new JMenu("帮助");
 mHelp.add(new JMenuItem("http://www.baidu.com/"));
 menuBar.add(mHelp);
 
 contentPane = new JPanel();
 contentPane.setBorder(new EmptyBorder(10, 10, 10, 10));
 contentPane.setLayout(new BorderLayout(0, 0));
 setContentPane(contentPane);
 
 pnlCount = new JPanel();
 contentPane.add(pnlCount, BorderLayout.NORTH);
 
 JLabel lblTime = new JLabel("时间");
 pnlCount.add(lblTime);
 
 txtTime = new JTextField("0", 3);
 txtTime.setEditable(false);
 pnlCount.add(txtTime);
 
 JLabel lblCount = new JLabel("计数");
 pnlCount.add(lblCount);
 
 txtCount = new JTextField("0/" + minecount, 5);
 txtCount.setEditable(false);
 pnlCount.add(txtCount);
 
 pnlMine = new JPanel();
 contentPane.add(pnlMine, BorderLayout.CENTER);
 
 gamemode = mode;
 setMineArea(row, column, minecount);
 setMinePosition();
 setMineButton();
 UIManager.put("Label.font", FontC);
 }
 
 // 从文件中读取数据
 public static int[] getDataFromFile() {
 try {
  FileInputStream fis = new FileInputStream(file);
  byte[] buffer = new byte[256];
  int size = fis.read(buffer);
  fis.close();
  String[] s = new String(buffer, 0, size).split(" ");
  HighScore_Elementary = Integer.parseInt(s[0]);
  HighScore_Intermediate = Integer.parseInt(s[1]);
  HighScore_Advanced = Integer.parseInt(s[2]);
  int[] i = {Integer.parseInt(s[3]), Integer.parseInt(s[4]),
   Integer.parseInt(s[5]), Integer.parseInt(s[6])};
  return i;
 } catch (Exception e) {
  HighScore_Elementary = Integer.MAX_VALUE;
  HighScore_Intermediate = Integer.MAX_VALUE;
  HighScore_Advanced = Integer.MAX_VALUE;
  return Elementary;
 }
 }
 
 // 保存数据到文件
 public void saveDataToFile() {
 try {
  String s = HighScore_Elementary + " " + HighScore_Intermediate + " "
   + HighScore_Advanced + " " + row + " " + column + " "
   + minecount + " " + gamemode;
  FileOutputStream fos = new FileOutputStream(file);
  fos.write(s.getBytes());
  fos.close();
 } catch (IOException e) {
  e.printStackTrace();
 }
 }
 
 // 初始化面板的各项参数
 private void setMineArea(int row, int column, int minecount) {
 setSize(30 * column + 20, 30 * row + 120);
 // 设置窗口在屏幕的正中心
 setLocationRelativeTo(null);
 this.row = row;
 this.column = column;
 this.minecount = minecount;
 area = row * column;
 flagcount = 0;
 enablecount = area;
 minearea = new boolean[row][column];
 flagmark = new boolean[row][column];
 isGameOver = false;
 isFirstClick = true;
 }
 
 // 随机生成地雷的位置
 private void setMinePosition(){
 // 生成minecount个不重复的随机数
 int[] pos = new int[area];
 for (int i = 0; i < area; i++) {
  pos[i] = i;
 }
 Random rand = new Random();
 for (int i = 0; i < minecount; i++) {
  int n = rand.nextInt(area - i);
  minearea[pos[n] / column][pos[n] % column] = true;
  pos[n] = pos[area - i - 1];
 }
 }
 
 // 向地雷面板上添加按钮
 private void setMineButton() {
 pnlMine.setLayout(new GridLayout(row, column));
 btnMine = new MineButton[row][column];
 for (int i = 0; i < row; i++) {
  for (int j = 0; j < column; j++) {
  btnMine[i][j] = new MineButton(i, j);
  pnlMine.add(btnMine[i][j]);
  }
 }
 }
 
 // “重新开始本局”菜单项监听类
 private class RestartListener implements ActionListener {
 public void actionPerformed(ActionEvent e) {
  new MenuFunction().Restart();
 }
 }
 
 // “开始新的的游戏”菜单项监听类
 private class ResetMineListener implements ActionListener {
 public void actionPerformed(ActionEvent e) {
  new MenuFunction().ResetMine();
 }
 }
 
 // “游戏模式设置”菜单项监听类
 private class ResetModeListener implements ActionListener {
 private int[] mode;
 public ResetModeListener(int[] mode) {
  this.mode = mode;
 }
 
 public void actionPerformed(ActionEvent e) {
  if (gamemode == mode[3]) {
  new MenuFunction().ResetMine();
  } else {
  new MenuFunction().ResetSize(mode[0], mode[1], mode[2]);
  gamemode = mode[3];
  }
 }
 }
 
 // “自定义”菜单项监听类，JFrame窗口的子类
 private class CustomSizeFrameListener extends JFrame implements ActionListener {
 public CustomSizeFrameListener() {
  setTitle("自定义");
  setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
  setSize(320, 220);
  setLocationRelativeTo(null); // 设置窗口在屏幕的正中心
  setResizable(false);  // 设置窗体不可改变大小
  JPanel contentPane = new JPanel();
  contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
  contentPane.setLayout(new GridLayout(4, 0));
  setContentPane(contentPane);
  
  JPanel pnlRow = new JPanel();
  contentPane.add(pnlRow);
  pnlRow.add(new JLabel("行数："));
  JTextField txtRow = new JTextField(10);
  pnlRow.add(txtRow);
  
  JPanel pnlColumn = new JPanel();
  contentPane.add(pnlColumn);
  pnlColumn.add(new JLabel("列数："));
  JTextField txtColumn = new JTextField(10);
  pnlColumn.add(txtColumn);
  
  JPanel pnlMineCount = new JPanel();
  contentPane.add(pnlMineCount);
  pnlMineCount.add(new JLabel("雷数："));
  JTextField txtMineCount = new JTextField(10);
  pnlMineCount.add(txtMineCount);
  
  JPanel pnlButton = new JPanel();
  contentPane.add(pnlButton);
  JButton btnOK = new JButton("确定");
  btnOK.addActionListener(new ActionListener() {
  public void actionPerformed(ActionEvent e) {
   try {
   int r = Integer.parseInt(txtRow.getText().trim());
   int c = Integer.parseInt(txtColumn.getText().trim());
   int count = Integer.parseInt(txtMineCount.getText().trim());
   if (r <= 0 || c <= 0 || r > 24 || c > 30) {
    JOptionPane.showMessageDialog(null, "限制行数：1~24\n限制列数：1~30",
     "警告", JOptionPane.WARNING_MESSAGE);
    return;
   }
   if (count <= 0 || count > r * c) {
    JOptionPane.showMessageDialog(null, "限制雷数：1~" + (r * c),
     "警告", JOptionPane.WARNING_MESSAGE);
    return;
   }
   new MenuFunction().ResetSize(r, c, count);
   gamemode = Custom_Mode;
   setVisible(false);
   } catch (NumberFormatException ex) {
   JOptionPane.showMessageDialog(null, "无效输入！",
    "错误", JOptionPane.ERROR_MESSAGE);
   }
  }
  });
  pnlButton.add(btnOK);
 }
 
 public void actionPerformed(ActionEvent e) {
  setVisible(true);
 }
 }
 
 // “高分榜”菜单项监听类
 private class HighScoreListener implements ActionListener {
 public void actionPerformed(ActionEvent e) {
  JOptionPane.showMessageDialog(null, "初级：" + HighScore_Elementary
   + "秒\n中级：" + HighScore_Intermediate
   + "秒\n高级：" + HighScore_Advanced + "秒",
   "高分榜", JOptionPane.INFORMATION_MESSAGE);
 }
 }
 
 // 菜单栏事件监听函数类
 private class MenuFunction {
 // “重新开始本局”函数
 public void Restart() {
  flagcount = 0;
  enablecount = area;
  if (!isFirstClick) {
  timeThread.interrupt();
  isFirstClick = true;
  txtTime.setText("0");
  }
  txtCount.setText("0/" + minecount);
  for (int i = 0; i < row; i++) {
  for (int j = 0; j < column; j++) {
   flagmark[i][j] = false;
   btnMine[i][j].removeLabel();
   btnMine[i][j].setIcon(null);
   btnMine[i][j].setOriginalStyle();
   btnMine[i][j].setEnabled(true);
  }
  }
  if (isGameOver) {
  for (int i = 0; i < row; i++) {
   for (int j = 0; j < column; j++) {
   btnMine[i][j].setMineListener();
   }
  }
  isGameOver = false;
  }
 }
 
 // “开始新的游戏”函数
 public void ResetMine() {
  minearea = new boolean[row][column];
  setMinePosition();
  Restart();
 }
 
 // “游戏模式设置”函数
 public void ResetSize(int r, int c, int count) {
  Restart();
  txtCount.setText("0/" + count);
  pnlMine.removeAll();
  setMineArea(r, c, count);
  setMinePosition();
  setMineButton();
 }
 }
 
 // 地雷区按钮监听类
 private class MineListener extends MouseAdapter {
 private int r;
 private int c;
 private boolean bothpress;
 private MouseFunction mousefunction;
 public MineListener(int r, int c) {
  this.r = r;
  this.c = c;
  mousefunction = new MouseFunction(r, c);
 }
 
 // 鼠标点击时触发
 public void mousePressed(MouseEvent e) {
  // 判断是否为左右双键同时点击
  int d = e.getModifiersEx();
  if (d == InputEvent.BUTTON1_DOWN_MASK + InputEvent.BUTTON3_DOWN_MASK) {
  bothpress = true;
  } else {
  bothpress = false;
  }
  if (bothpress) {
  mousefunction.bothPressed();
  }
 }
 
 // 鼠标释放时触发
 public void mouseReleased(MouseEvent e) {
  if (bothpress) {
  mousefunction.bothReleased();
  } else if (e.getButton() == MouseEvent.BUTTON1) {
  mousefunction.leftReleased(r, c);
  } else if (e.getButton() == MouseEvent.BUTTON3 && !bothpress) {
  mousefunction.rightReleased();
  }
  if (minecount == enablecount) {
  mousefunction.Success();
  }
 }
 }
 
 // 地雷区鼠标点击事件监听函数类
 private class MouseFunction {
 private int r;
 private int c;
 private boolean[] bool;
 public MouseFunction(int r, int c) {
  this.r = r;
  this.c = c;
  bool = surroundingButtons(r, c);
 }
 
 // 判断被点击按钮周边3*3范围内有无其它按钮
 private boolean[] surroundingButtons(int r, int c) {
  boolean[] bool = {true, true, true, true, true, true, true, true, true};
  if (r == 0) {bool[0] = bool[1] = bool[2] = false;}
  if (r == row - 1) {bool[6] = bool[7] = bool[8] = false;}
  if (c == 0) {bool[0] = bool[3] = bool[6] = false;}
  if (c == column - 1) {bool[2] = bool[5] = bool[8] = false;}
  return bool;
 }
 
 // 左键释放函数
 public void leftReleased(int r, int c) {
  if (isFirstClick) {
  timeThread = new TimeThread();
  timeThread.start();
  isFirstClick = false;
  }
  if (flagmark[r][c] || !btnMine[r][c].isEnabled()) {return;}
  if (minearea[r][c]) {GameOver(r, c); return;}
  
  boolean[] bool = surroundingButtons(r, c);
  int i = 0;
  if (bool[0] && minearea[r - 1][c - 1]) {i++;}
  if (bool[1] && minearea[r - 1][c]) {i++;}
  if (bool[2] && minearea[r - 1][c + 1]) {i++;}
  if (bool[3] && minearea[r][c - 1]) {i++;}
  if (bool[5] && minearea[r][c + 1]) {i++;}
  if (bool[6] && minearea[r + 1][c - 1]) {i++;}
  if (bool[7] && minearea[r + 1][c]) {i++;}
  if (bool[8] && minearea[r + 1][c + 1]) {i++;}
  
  btnMine[r][c].setDisabledStyle();
  btnMine[r][c].setEnabled(false);
  enablecount--;
  if (i != 0) {
  btnMine[r][c].setLabel(i);
  } else {
  if (bool[0]) {leftReleased(r - 1, c - 1);}
  if (bool[1]) {leftReleased(r - 1, c);}
  if (bool[2]) {leftReleased(r - 1, c + 1);}
  if (bool[3]) {leftReleased(r, c - 1);}
  if (bool[5]) {leftReleased(r, c + 1);}
  if (bool[6]) {leftReleased(r + 1, c - 1);}
  if (bool[7]) {leftReleased(r + 1, c);}
  if (bool[8]) {leftReleased(r + 1, c + 1);}
  }
 }
 
 // 右键释放函数
 public void rightReleased() {
  if (flagmark[r][c]) {
  btnMine[r][c].setIcon(null);
  flagmark[r][c] = false;
  flagcount--;
  txtCount.setText(flagcount + "/" + minecount);
  } else {
  if (btnMine[r][c].isEnabled()) {
   btnMine[r][c].setIcon(imgflag);
   flagmark[r][c] = true;
   flagcount++;
   txtCount.setText(flagcount + "/" + minecount);
  }
  }
 }
 
 // 双键点击函数
 public void bothPressed() {
  if (flagmark[r][c]) {return;}
  int k = 0;
  for (int i = -1; i <= 1; i++) {
  for (int j = -1; j <= 1; j++) {
   if (bool[k++] && btnMine[r + i][c + j].isEnabled() && !flagmark[r + i][c + j]) {
   btnMine[r + i][c + j].setClickedStyle();
   }
  }
  }
 }
 
 // 双键释放函数
 public void bothReleased() {
  if (flagmark[r][c]) {return;}
  int k = 0, m = 0, n = 0;
  for (int i = -1; i <= 1; i++) {
  for (int j = -1; j <= 1; j++) {
   if (bool[k++]) {
   if (btnMine[r + i][c + j].isEnabled() && !flagmark[r + i][c + j]) {
    btnMine[r + i][c + j].setOriginalStyle();
   }
   if (minearea[r + i][c + j]) {
    m++;
   }
   if (flagmark[r + i][c + j]) {
    n++;
   }
   }
  }
  }
  if (btnMine[r][c].isEnabled()) {return;}
  if (m == n) {
  if (bool[0] && !flagmark[r - 1][c - 1]) {leftReleased(r - 1, c - 1);}
  if (bool[1] && !flagmark[r - 1][c]) {leftReleased(r - 1, c);}
  if (bool[2] && !flagmark[r - 1][c + 1]) {leftReleased(r - 1, c + 1);}
  if (bool[3] && !flagmark[r][c - 1]) {leftReleased(r, c - 1);}
  if (bool[5] && !flagmark[r][c + 1]) {leftReleased(r, c + 1);}
  if (bool[6] && !flagmark[r + 1][c - 1]) {leftReleased(r + 1, c - 1);}
  if (bool[7] && !flagmark[r + 1][c]) {leftReleased(r + 1, c);}
  if (bool[8] && !flagmark[r + 1][c + 1]) {leftReleased(r + 1, c + 1);}
  }
 }
 
 // 游戏结束函数
 public void GameOver(int r, int c) {
  btnMine[r][c].setBackground(Color.red);
  for (int i = 0; i < row; i++) {
  for (int j = 0; j < column; j++) {
   if (minearea[i][j]) {
   btnMine[i][j].setIcon(imgbomb);
   }
   btnMine[i][j].removeMineListener();
  }
  }
  timeThread.interrupt();
  JOptionPane.showMessageDialog(null, "Game Over",
   "提示", JOptionPane.INFORMATION_MESSAGE);
  isGameOver = true;
 }
 
 // 游戏胜利函数
 public void Success() {
  txtCount.setText(minecount + "/" + minecount);
  for (int i = 0; i < row; i++) {
  for (int j = 0; j < column; j++) {
   if (minearea[i][j]) {
   btnMine[i][j].setIcon(imgflag);
   }
   btnMine[i][j].removeMineListener();
  }
  }
  if (timeThread != null) {
  timeThread.interrupt();
  }
  String s = "You Win!";
  int time = Integer.parseInt(txtTime.getText());
  switch (gamemode) {
  case Elementary_Mode:
  if (time < HighScore_Elementary) {
   HighScore_Elementary = time;
   s = "New Record!";
  }
  break;
  case Intermediate_Mode:
  if (time < HighScore_Intermediate) {
   HighScore_Intermediate = time;
   s = "New Record!";
  }
  break;
  case Advanced_Mode:
  if (time < HighScore_Advanced) {
   HighScore_Advanced = time;
   s = "New Record!";
  }
  }
  JOptionPane.showMessageDialog(null, s + "\n用时：" + time + "秒",
   "提示", JOptionPane.INFORMATION_MESSAGE);
  isGameOver = true;
 }
 }
 
 // 地雷区按钮类，JButton按钮的子类
 private class MineButton extends JButton {
 private MineListener mineListener;
 private JLabel lbl;
 private MineButton() {
  super(null, null);
  setBackground(Color.lightGray);
  // 设置凸起来的按钮
  setBorder(BorderFactory.createRaisedBevelBorder());
 }
 
 public MineButton(int r, int c) {
  this();
  mineListener = new MineListener(r, c);
  addMouseListener(mineListener);
 }
 
 public void setMineListener() {
  addMouseListener(mineListener);
 }
 
 public void removeMineListener() {
  removeMouseListener(mineListener);
 }
 
 public void setOriginalStyle() {
  setBackground(Color.lightGray);
  // 设置凸起来的按钮
  setBorder(BorderFactory.createRaisedBevelBorder());
 }
 
 public void setDisabledStyle() {
  setBackground(null);
  // 设置按钮边框线条
  setBorder(BorderFactory.createLineBorder(Color.lightGray));
 }
 
 public void setClickedStyle() {
  setBackground(Color.lightGray);
  // 设置凹下去的按钮
  setBorder(BorderFactory.createLoweredBevelBorder());
 }
 
 public void setLabel(int i) {
  lbl = new JLabel(String.valueOf(i));
  lbl.setHorizontalAlignment(JLabel.CENTER);
  lbl.setVerticalAlignment(JLabel.CENTER);
  lbl.setForeground(NumberColor[i - 1]);
  setLayout(new BorderLayout(0, 0));
  add(lbl, BorderLayout.CENTER);
 }
 
 public void removeLabel() {
  if (lbl != null) {
  remove(lbl);
  lbl = null;
  }
 }
 }
 
 // 线程类，游戏开始后每隔一秒刷新txtTime文本框里显示的时间
 private class TimeThread extends Thread {
 // 重写run()方法
 public void run() {
  // 获取当前系统时间
  long startTime = System.currentTimeMillis();
  // 非阻塞过程中通过判断中断标志来退出
  while (!isInterrupted()) {
  // 获取当前的系统时间，与初始时间相减就是程序运行的毫秒数，除以1000就是秒数
  long endTime = System.currentTimeMillis();
  long usedTime = (endTime - startTime) / 1000;
  txtTime.setText(String.valueOf(usedTime));
  try {
   // 线程挂起一秒钟
   Thread.sleep(1000);
   // 阻塞过程捕获中断异常来退出
  } catch (InterruptedException e) {
   e.printStackTrace();
   // 捕获到异常之后，执行break跳出循环
   break;
  }
  }
 }
 }
}