计科（智能）22-1孙静202203200026

人机对战（共664行）

1、游戏规则

1. import javax.imageio.ImageIO;
2. import javax.swing.*;
3. import java.awt.*;
4. import java.awt.event.MouseEvent;
5. import java.awt.event.MouseListener;
6. import java.awt.image.BufferedImage;
7. import java.io.File;
8. import java.io.IOException;
9. public class MyJFrame_AI extends JFrame implements MouseListener {
10.     int qx = 20, qy = 40, qw = 490, qh = 490; //棋盘位置、宽高
11.     int bw = 150, bh = 50, bx = 570, by = 150; //按钮宽高、位置
12.     int x = 0, y = 0; //保存棋子坐标
13.     int[][] SaveGame = new int[15][15]; //保存每个棋子
14.     int qc = 1;//记录白棋=2，黑棋=1
15.     int qn = 0;//判断棋子是否重复
16.     boolean canplay = true; //判断游戏是否开始和结束
17.     String go = "黑子先行"; //游戏信息
18.     int bq = 0, hq = 0;
19.     //人机对战增加参数
20.     int machine = 0;// 该数值为1代表电脑先行
21.     int[][] score = new int[15][15];// 权值表，保存每个位置的分数

2、建立窗口

1.   //---------------------------------------------------------------------------------------------------------------------
2.     //窗体
3.     public void myJFrame() {
4.         this.setTitle("五子棋(人机对战)"); //标题
5.         this.setSize(800, 550); //窗口大小
6.         this.setResizable(false); //窗口是否可以改变大小=否
7.         this.setDefaultCloseOperation(MyJFrame_AI.EXIT_ON_CLOSE); //窗口关闭方式为关闭窗口同时结束程序
8.         int width = Toolkit.getDefaultToolkit().getScreenSize().width; //获取屏幕宽度
9.         int height = Toolkit.getDefaultToolkit().getScreenSize().height; //获取屏幕高度
10. //        System.out.println("宽度："+width);//测试
11. //        System.out.println("高度："+height);//测试
12.         this.setLocation((width - 800) / 2, (height - 600) / 2); //设置窗口默认位置以屏幕居中
13.         this.addMouseListener(this);
14.         this.setVisible(true); //窗口是否显示=是
15.         first();
16.     }
17.     public static class Position {
18.         static int listx;
19.         static int listy;
20.     }
21.     public static class chessUI extends JPanel {
22.         public static Position[] ps = new Position[300];
23.         int i;
24.     }
25.     static chessUI ui = new chessUI();
26.     static Position p = new Position();

3、绘制界面

1.  //---------------------------------------------------------------------------------------------------------------------
2.     //覆写paint方法,绘制界面
3.     public void paint(Graphics g) {
4.         //双缓冲技术防止屏幕闪烁
5.         BufferedImage bi = new BufferedImage(800, 550, BufferedImage.TYPE_INT_ARGB);
6.         Graphics g2 = bi.createGraphics();
7.         //获取图片路径
8.         BufferedImage image = null;
9.         try {
10.             //获取项目文件夹路径
11.             File directory = new File("");
12.             //路径拼接
13.             image = ImageIO.read(new File(directory.getAbsolutePath() + "/tp/wzqbj.jpg"));
14.         } catch (IOException e) {
15.             e.printStackTrace();
16.         }
17.         g2.drawImage(image, 10, 10, this); //显示图片
18.         g2.setColor(Color.BLACK);//设置画笔颜色
19.         g2.setFont(new Font("华文行楷", 10, 50)); //设置字体
20.         g2.drawString("凝静五子棋", 525, 100); //绘制字符
21.         //棋盘
22.         g2.setColor(Color.getHSBColor(30, (float) 0.10, (float) 0.90)); //设置画笔颜色
23.         g2.fillRect(qx, qy, qw, qh); //绘制棋盘背景矩形
24.         //开始按钮
25.         g2.setColor(Color.WHITE); //设置画笔颜色
26.         g2.fillRect(bx, by, bw, bh); //绘制开始按钮
27.         g2.setFont(new Font("华文行楷", 10, 30)); //设置字体
28.         g2.setColor(Color.black); //设置画笔颜色
29.         g2.drawString("开始", 615, 185); //绘制字符
30.         //悔棋按钮
31.         g2.setColor(Color.LIGHT_GRAY); //设置画笔颜色
32.         g2.fillRect(bx, by + 60, bw, bh); //绘制悔棋按钮
33.         g2.setFont(new Font("华文行楷", 10, 30)); //设置字体
34.         g2.setColor(Color.WHITE); //设置画笔颜色  
35.         g2.drawString("悔棋", 615, 245); //绘制字符
36.         //认输按钮
37.         g2.setColor(Color.GRAY); //设置画笔颜色
38.         g2.fillRect(bx, by + 120, bw, bh); //绘制认输按钮
39.         g2.setFont(new Font("华文行楷", 10, 30)); //设置字体
40.         g2.setColor(Color.WHITE); //设置画笔颜色
41.         g2.drawString("认输", 615, 305); //绘制字符
42.         //游戏信息栏
43.         g2.setColor(Color.getHSBColor(30, (float) 0.10, (float) 0.90)); //设置画笔颜色
44.         g2.fillRect(550, 350, 200, 150); //绘制游戏状态区域
45.         g2.setColor(Color.black); //设置画笔颜色
46.         g2.setFont(new Font("黑体", 10, 20)); //设置字体
47.    

4、绘制棋盘格线

1.  //绘制棋盘格线
2.         for (int x = 0; x <= qw; x += 35) {
3.             g2.drawLine(qx, x + qy, qw + qx, x + qy); //绘制一条横线
4.             g2.drawLine(x + qx, qy, x + qx, qh + qy); //绘制一条竖线
5.         }
6.         //绘制标注点
7.         for (int i = 3; i <= 11; i += 4) {
8.             for (int y = 3; y <= 11; y += 4) {
9.                 g2.fillOval(35 * i + qx - 3, 35 * y + qy - 3, 6, 6); //绘制实心圆
10.             }
11.         }
12.  
13.         //绘制棋子
14.         for (int i = 0; i < 15; i++) {
15.             for (int j = 0; j < 15; j++) {
16.                 if (SaveGame[i][j] == 1) //黑子
17.                 {
18.                     int sx = i * 35 + qx;
19.                     int sy = j * 35 + qy;
20.                     g2.setColor(Color.BLACK);
21.                     g2.fillOval(sx - 13, sy - 13, 26, 26); //绘制实心圆
22.                     hq++;
23.                 }
24.                 if (SaveGame[i][j] == 2) //白子
25.                 {
26.                     int sx = i * 35 + qx;
27.                     int sy = j * 35 + qy;
28.                     g2.setColor(Color.WHITE);
29.                     g2.fillOval(sx - 13, sy - 13, 26, 26); //绘制实心圆
30.                     g2.setColor(Color.BLACK);
31.                     g2.drawOval(sx - 13, sy - 13, 26, 26); //绘制空心圆
32.                     bq++;
33.                 }
34.             }
35.         }
36.         g.drawImage(bi, 0, 0, this);
37.  
38. //        g.drawRect(20, 20, 20, 20);//绘制空心矩形
39.     }

5、判断输赢

 

1.     //---------------------------------------------------------------------------------------------------------------------
2.     //判断输赢
3.     private boolean WinLose() {
4.         boolean flag = false; //输赢
5.         int count = 1; //相连数
6.         int color = SaveGame[x][y]; //记录棋子颜色
7.  
8.         //判断横向棋子是否相连
9.         int i = 1; //迭代数
10.         while (color == SaveGame[x + i][y]) {
11.             count++;
12.             i++;
13.         }
14.  
15.         i = 1; //迭代数
16.         while (color == SaveGame[x - i][y]) {
17.             count++;
18.             i++;
19.         }
20.         if (count >= 5) {
21.             flag = true;
22.         }
23.  
24.  
25.         //判断纵向棋子是否相连
26.         count = 1;
27.         i = 1; //迭代数
28.         while (color == SaveGame[x][y + i]) {
29.             count++;
30.             i++;
31.         }
32.  
33.         i = 1; //迭代数
34.         if (y > 0) {
35.             while (color == SaveGame[x][y - i]) {
36.                 count++;
37.                 i++;
38.             }
39.         }
40.         if (count >= 5) {
41.             flag = true;
42.         }
43.  
44.  
45.         //判断斜向棋子是否相连（左上右下）
46.         count = 1;
47.         i = 1; //迭代数
48.         while (color == SaveGame[x - i][y - i]) {
49.             count++;
50.             i++;
51.         }
52.  
53.         i = 1; //迭代数
54.         while (color == SaveGame[x + i][y + i]) {
55.             count++;
56.             i++;
57.         }
58.         if (count >= 5) {
59.             flag = true;
60.         }
61.  
62.  
63.         //判断斜向棋子是否相连（左下右上）
64.         count = 1;
65.         i = 1; //迭代数
66.         while (color == SaveGame[x + i][y - i]) {
67.             count++;
68.             i++;
69.         }
70.  
71.         i = 1; //迭代数
72.         while (color == SaveGame[x - i][y + i]) {
73.             count++;
74.             i++;
75.         }
76.         if (count >= 5) {
77.             flag = true;
78.         }
79.  
80.         return flag;
81.     }

5、初始化游戏

1.  //---------------------------------------------------------------------------------------------------------------------
2.     //初始化游戏
3.     public void Initialize() {
4.         //遍历并初始化棋子位置数组
5.         for (int i = 0; i < 15; i++) {
6.             for (int j = 0; j < 15; j++) {
7.                 SaveGame[i][j] = 0;
8.             }
9.         }
10.         //遍历并初始化权值数组
11.         for (int i = 0; i < 15; i++) {
12.             for (int j = 0; j < 15; j++) {
13.                 score[i][j] = 0;
14.             }
15.         }
16.         //黑子先行
17.         qc = 1;
18.         go = "轮到黑子";
19.         first();
20.     }
21.     /**
22.      * 判断谁先走
23.      */
24.     public void first() {
25.         Object[] objects = {"玩家先走", "电脑先走"};
26.         int a = JOptionPane.showOptionDialog(null, "请选择先行者", "请选择", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, objects, objects[0]);
27.         if (a == -1) {
28.             System.exit(0);
29.         }
30.         if (a == 1) {
31.             machine = 1;
32.         }
33.         if (a == 0) {
34.             machine = 0;
35.         }
36.         // 如果电脑先走，在中间位置下棋
37.         if (machine == 1) {
38.             SaveGame[7][7] = 1;
39.             qc = 2;
40.             go = "轮到白子";
41.             this.repaint();
42.         }
43.     }
44.     /**
45.      * 计算五元组分数
46.      */
47.     public int score(int blackNum, int whiteNum) {
48.         // 通过电脑是否先行判断电脑棋子颜色
49.         //  如果电脑执黑
50.         if (machine == 1) {
51.             // 如果五元组中两种棋子都有，分值为0
52.             if (blackNum > 0 && whiteNum > 0) {
53.                 return 0;
54.             }
55.             // 都没有，分值为7
56.             if (blackNum == 0 && whiteNum == 0) {
57.                 return 7;
58.             }
59.             // 判断其中白棋数量计算分数
60.             if (blackNum == 1) {
61.                 return 35;
62.             }
63.             if (blackNum == 2) {
64.                 return 800;
65.             }
66.             if (blackNum == 3) {
67.                 return 15000;
68.             }
69.             if (blackNum == 4) {
70.                 return 800000;
71.             }
72.             // 判断其中白棋数量计算分数
73.             if (whiteNum == 1) {
74.                 r

6、电脑执白棋

1. // 如果电脑执白
2.         if (machine == 0) {
3.             // 如果五元组中两种棋子都有，分值为0
4.             if (blackNum > 0 && whiteNum > 0) {
5.                 return 0;
6.             }
7.             // 都没有，分值为7
8.             if (blackNum == 0 && whiteNum == 0) {
9.                 return 7;
10.             }
11.             // 判断其中白棋数量计算分数
12.             if (blackNum == 1) {
13.                 return 15;
14.             }
15.             if (blackNum == 2) {
16.                 return 400;
17.             }
18.             if (blackNum == 3) {
19.                 return 1800;
20.             }
21.             if (blackNum == 4) {
22.                 return 100000;
23.             }
24.             // 判断其中白棋数量计算分数
25.             if (whiteNum == 1) {
26.                 return 35;
27.             }
28.             if (whiteNum == 2) {
29.                 return 800;
30.             }
31.             if (whiteNum == 3) {
32.                 return 15000;
33.             }
34.             if (whiteNum == 4) {
35.                 return 800000;
36.             }
37.    }
38.         return -1;
39.     }
40.  
41.     /**
42.      * 判断人机最佳下棋位置
43.      */
44.     public void machineGo(int pieces) {
45.  
46.         int blackNum = 0;
47.         int whiteNum = 0;
48.         // 横向
49.         for (int i = 0; i < 15; i++) {
50.             for (int j = 0; j < 11; j++) {
51.                 int k = j;
52.                 while (k < j + 5) {
53.                     if (SaveGame[i][k] == 1) {
54.                         blackNum++;
55.                     } else if (SaveGame[i][k] == 2) {
56.                         whiteNum++;
57.                     }
58.                     k++;
59.                 }
60.                 // 给五元组每个没有落子的位置添加分数
61.                 for (k = j; k < j + 5; k++) {
62.                     if (score[i][k] == 0) {
63.                         score[i][k] += score(blackNum, whiteNum);
64.                     }
65.                 }
66.                 // 将上次值归零，以便下次计算
67.                 blackNum = 0;
68.                 whiteNum = 0;
69.             }
70.         }
71.         // 纵向
72.         for (int i = 0; i < 15; i++) {
73.             for (int j = 0; j < 11; j++) {
74.                 int k = j;
75.                 while (k < j + 5) {
76.                     if (SaveGame[k][i] == 1) {
77.                         blackNum++;
78.                     } else if (SaveGame[k][i] == 2) {
79.                         whiteNum++;
80.                     }
81.                     k++;
82.                 }
83.                 // 给五元组每个没有落子的位置添加分数
84.                 for (k = j; k < j + 5; k++) {
85.                     score[k][i] += score(blackNum, whiteNum);
86.                 }
87.                 // 将上次值归零，以便下次计算
88.                 blackNum = 0;
89.                 whiteNum = 0;
90.             }
91.         }

1. //右上左下，上部分
2.         for (int i = 14; i >= 4; i--) {
3.             for (int k = i, j = 0; j < 15 && k >= 0; j++, k--) {
4.                 int m = k;
5.                 int n = j;
6.                 while (m > k - 5 && k - 5 >= -1) {
7.                     if (SaveGame[m][n] == 1) {
8.                         blackNum++;
9.                     } else if (SaveGame[m][n] == 2) {
10.                         whiteNum++;
11.                     }
12.                     m--;
13.                     n++;
14.                 }
15.                 // 斜向判断时，可能无法构成五元组，进行判断对其忽略
16.                 if (m == k - 5) {
17.                     for (m = k, n = j; m > k - 5; m--, n++) {
18.                         score[m][n] += score(blackNum, whiteNum);
19.                     }
20.                 }
21.                 // 将上次值归零，以便下次计算
22.                 blackNum = 0;
23.                 whiteNum = 0;
24.             }
25.         }
26.         //右上左下，下部分
27.         for (int i = 1; i < 15; i++) {
28.             for (int k = i, j = 14; j >= 0 && k < 15; j--, k++) {
29.                 int m = k;
30.                 int n = j;
31.                 while (m < k + 5 && k + 5 <= 15) {
32.                     if (SaveGame[n][m] == 1) {
33.                         blackNum++;
34.                     } else if (SaveGame[n][m] == 2) {
35.                         whiteNum++;
36.                     }
37.                     m++;
38.                     n--;
39.                 }
40.                 // 斜向判断时，可能无法构成五元组，进行判断对其忽略
41.                 if (m == k + 5) {
42.                     for (m = k, n = j; m < k + 5; m++, n--) {
43.                         score[n][m] += score(blackNum, whiteNum);
44.                     }
45.                 }
46.                 // 将上次值归零，以便下次计算
47.                 blackNum = 0;
48.                 whiteNum = 0;
49.             }
50.         }
51. // 左上右下，上部分
52.         for (int i = 0; i < 11; i++) {
53.             for (int k = i, j = 0; j < 15 && k < 15; j++, k++) {
54.                 int m = k;
55.                 int n = j;
56.                 while (m < k + 5 && k + 5 <= 15) {
57.                     if (SaveGame[m][n] == 1) {
58.                         blackNum++;
59.                     } else if (SaveGame[m][n] == 2) {
60.                         whiteNum++;
61.                     }
62.                     m++;
63.                     n++;
64.                 }
65.                 // 斜向判断时，可能无法构成五元组，进行判断对其忽略
66.                 if (m == k + 5) {
67.                     //为该五元组的每个位置添加分数
68.                     for (m = k, n = j; m < k + 5; m++, n++) {
69.                         score[m][n] += score(blackNum, whiteNum);
70.                     }
71.                 }
72.                 // 将上次值归零，以便下次计算
73.                 blackNum = 0;
74.                 whiteNum = 0;
75.             }
76.         }
77.         // 左上右下，下部分
78.         for (int i = 1; i < 11; i++) {
79.             for (int k = i, j = 0; j < 15 && k < 15; j++, k++) {
80.                 int m = k;
81.                 int n = j;
82.                 while (m < k + 5 && k + 5 <= 15) {
83.                     if (SaveGame[n][m] == 1) {
84.                         blackNum++;
85.                     } else if (SaveGame[n][m] == 2) {
86.                         whiteNum++;
87.                     }
88.                     m++;
89.                     n++;
90.                 }
91.                 // 斜向判断时，可能无法构成五元组，进行判断对其忽略
92.                 if (m == k + 5) {
93.                     //为该五元组的每个位置添加分数
94.                     for (m = k, n = j; m < k + 5; m++, n++) {
95.                         score[n][m] += score(blackNum, whiteNum);
96.                     }
97.                 }
98.                 // 将上次值归零，以便下次计算
99.                 blackNum = 0;
100.                 whiteNum = 0;
101.             }
102.         }
103.         int maxScore = 0;
104.         // 从没有落子的位置，找到分数最大的
105.         for (int i = 0; i < 15; i++) {
106.             for (int j = 0; j < 15; j++) {
107.                 if (SaveGame[i][j] == 0 && score[i][j] > maxScore) {
108.            x = i;
109.                     y = j;
110.                     maxScore = score[i][j];
111.                 }
112.             }
113.         }
114.         SaveGame[x][y] = pieces;
115.  
116.         ui.ps[ui.i].listx = x;
117.         ui.ps[ui.i].listy = y;
118.         ui.i++;
119.  
120.         this.repaint(); //重新执行一次paint方法
121.  
122.         // 弹出胜利对话框
123.         boolean wl = this.WinLose();
124.         if (wl) {
125.             JOptionPane.showMessageDialog(this, "游戏结束，" + (SaveGame[x][y] == 1 ? "黑方赢了" : "白方赢了")); //弹出提示对话框
126.             canplay = false;
127.         }
128.  
129.         //弹出平局对话框
130.         if (bq + hq == 255) {
131.             JOptionPane.showMessageDialog(this, "游戏结束，平局！"); //弹出提示对话框
132.             canplay = false;
133.         }
134.     }

7、鼠标控制

1. //---------------------------------------------------------------------------------------------------------------------
2.     @Override //鼠标点击
3.     public void mouseClicked(MouseEvent e) {
4.  
5.     }
6.  
7.     @Override //鼠标按下
8.     public void mousePressed(MouseEvent e) {
9.         //判断是否已开始游戏
10.         if (canplay) {
11.             //获取鼠标点击位置
12.             x = e.getX();
13.             y = e.getY();
14.  
15.             ui.ps[ui.i] = p;
16.             //判断点击是否为棋盘内
17.             if (x > qx && x < qx + qw && y > qy && y < qy + qh) {
18.                 //计算点击位置最近的点
19.                 if ((x - qx) % 35 > 17) {
20.                     x = (x - qx) / 35 + 1;
21.                 } else {
22.                     x = (x - qx) / 35;
23.                 }
24.                 if ((y - qy) % 35 > 17) {
25.                     y = (y - qy) / 35 + 1;
26.                 } else {
27.                     y = (y - qy) / 35;
28.                 }
29.  
30.                 ui.ps[ui.i].listx = x;
31.                 ui.ps[ui.i].listy = y;
32.                 ui.i++;
33.  
34.                 //判断当前位置有没有棋子
35.                 if (SaveGame[x][y] == 0) {
36.                     SaveGame[x][y] = qc;
37.                     qn = 0;
38.                 } else {
39.                     qn = 1;
40.                 }
41.  
42.                 //切换棋子
43.                 if (qn == 0) {
44.                     if (qc == 1) {
45.                         qc = 2;
46.                         go = "轮到白子";
47.                     } else {
48.                         qc = 1;
49.                         go = "轮到黑子";
50.                     }
51.                 }
52.  
53.                 this.repaint(); //重新执行一次paint方法

8、弹出胜利对话框

1. //                弹出胜利对话框
2.                 boolean wl = this.WinLose();
3.                 if (wl) {
4.                     JOptionPane.showMessageDialog(this, "游戏结束，" + (SaveGame[x][y] == 1 ? "黑方赢了" : "白方赢了")); //弹出提示对话框
5.                     canplay = false;
6.                 }
7.                 //弹出平局对话框
8.                 if (bq + hq == 255) {
9.                     JOptionPane.showMessageDialog(this, "游戏结束，平局！"); //弹出提示对话框
10.                     canplay = false;
11.                 }
12. //            System.out.println(1); //测试
13.             }
14.         }
15.  
16.         //实现开始按钮
17.         //判断是否点击开始按钮
18.         if (e.getX() > bx && e.getX() < bx + bw && e.getY() > by && e.getY() < by + bh) {
19.             //判断游戏是否开始
20.             if (!canplay) {
21.                 //如果游戏结束，则开始游戏
22.                 canplay = true;
23.                 JOptionPane.showMessageDialog(this, "游戏开始");
24.                 //初始化游戏
25.                 Initialize();
26.                 this.repaint(); //重新执行一次paint方法
27.             } else {
28.                 //如果游戏进行中，则重新开始
29.                 JOptionPane.showMessageDialog(this, "重新开始");
30.                 //初始化游戏
31.                 Initialize();
32.                 this.repaint(); //重新执行一次paint方法
33.             }
34.         }

9、悔棋

1. //实现悔棋按钮
2.         //判断是否点击悔棋按钮
3.         if (e.getX() > bx && e.getX() < bx + bw && e.getY() > by + 60 && e.getY() < by + 60 + bh) {
4.             //判断游戏是否开始
5.             if (canplay) {
6.                 //遍历棋盘上是否有棋子
7.                 int z = 0;
8.                 for (int i = 0; i < 15; i++) {
9.                     for (int j = 0; j < 15; j++) {
10.                         if (SaveGame[i][j] != 0) {
11.                             z++;
12.                         }
13.                     }
14.                 }
15.                 //判断是否有棋子
16.                 if (z != 0) {
17.                     int result = JOptionPane.showConfirmDialog(this, "确认要悔棋吗？");
18.                     if (result == 0) {
19.                         int x = ui.ps[ui.i - 1].listx;
20.                         int y = ui.ps[ui.i - 1].listy;
21.                         if (SaveGame[x][y] == 0) {
22.                             JOptionPane.showMessageDialog(this, "已悔过一次棋了！");
23.                         } else {
24.                             if (SaveGame[x][y] == 1) {
25.                                 qc = 1;
26.                                 go = "轮到黑子";
27.                             } else if (SaveGame[x][y] == 2) {
28.                                 qc = 2;
29.                                 go = "轮到白子";
30.                             }
31.                             SaveGame[x][y] = 0;
32.                             ui.i--;
33.                             this.repaint();
34.                         }
35.                     }
36.                 } else {
37.                     JOptionPane.showMessageDialog(this, "棋盘上已无棋子");
38.                 }
39.             } else {
40.                 JOptionPane.showMessageDialog(this, "请先开始游戏");
41.             }
42.         }

10、认输

1.  //实现认输按钮
2.         //判断是否点击认输按钮
3.         if (e.getX() > bx && e.getX() < bx + bw && e.getY() > by + 120 && e.getY() < by + 120 + bh) {
4.             //判断游戏是否开始
5.             if (canplay) {
6.                 //判断是谁认输
7.                 if (qc == 1) {
8.                     JOptionPane.showMessageDialog(this, "黑方认输，白方获胜");
9.                     canplay = false;
10.                 } else if (qc == 2) {
11.                     JOptionPane.showMessageDialog(this, "白方认输，黑方获胜");
12.                     canplay = false;
13.                 }
14.             } else {
15.                 JOptionPane.showMessageDialog(this, "请先开始游戏");
16.             }
17.         }
18.  
19.  
20.     }

11、鼠标抬起

1. @Override//鼠标抬起
2.     public void mouseReleased(MouseEvent e) {
3.         //如果电脑先行，就也代表电脑执黑子，否则反之。在相应回合时让电脑做出反应
4.         if (machine == 1) {
5.             if (qc == 1) {
6.                 machineGo(qc);
7.                 qc = 2;
8.                 go = "轮到白子";
9.             }
10.         } else {
11.             if (qc == 2) {
12.                 machineGo(qc);
13.                 qc = 1;
14.                 go = "轮到黑子";
15.             }
16.         }
17.     }
18.  
19.     @Override//鼠标进入
20.     public void mouseEntered(MouseEvent e) {
21.  
22.     }
23.  
24.     @Override//鼠标离开
25.     public void mouseExited(MouseEvent e) {
26.  
27.     }
28. }