Java实现简单的五子棋

发表于 更新于 分类于 Waline：

前言

我是参考csdn大佬的博客写的代码，不得不承认csdn是一个学习计算机语言的好地方，那里面有数不清的免费资源，挺好的，里面的博主个个都是大佬，在这里我就不过多介绍csdn了，切入正题，传送门：用Java实现简单的五子棋游戏，….

具体实现代码如下：

  1. 导入需要的类 
    1
    2
    import java.util.Random;
    import java.util.Scanner;
  1. 新建测试类，在类里定义静态变量 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    static int length=20;//初始化棋盘数据
    static String[][] goBang=new String[length][length];
    static String add="十";
    static String black="●";
    static String white="○";
    static boolean begin=true;
    static String zb=null;
    static int a,b;
    static int blackScore=1;
    static int whiteScore=1;
  1. 初始化棋局，用十填充
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
public static void main(String[] args)	{
		boolean goOn=true;  
	    for(int i=0;i<goBang.length;i++)	{
			for(int j=0;j<goBang.length;j++)	{
				goBang[i][j]=add;
			}
		}
		show();
		do	{
			boolean blackDo=true;
			//true时为黑方选手的落子，false时为白方选手的落子，黑方代表玩家
			@SuppressWarnings("resource")
			Scanner input=new Scanner(System.in);
			//开始下棋
			do {//赢面出现之前的循环走棋
				System.out.println("请输入您下棋的行和列，如：3,5"
						+ "表示第3行第5列，x范围[1,20]，y范围[1,"
						+ "20]：");
				zb=input.next();//输入走棋的位置
				String[] str=zb.split(",");
				//以,为界把一个字符串分成两个字符串
				a=Integer.valueOf(str[0])-1;
				b=Integer.valueOf(str[1])-1;
				//将字符串转int，并-1才能转换成数组的索引下标
				//用黑子填充棋局
				if(goBang[a][b].equals(add))	{
					//判断goBang[a][b]这个位置是否可用
	                if(blackDo)	{
						/*
						 * 是黑方走的棋时把黑子填充在输入的坐标里，并改变
						 * blackDo的值，使下一次为白方填充
						 */
						goBang[a][b]=black;
						blackDo=false;
					}	else	{
						/*
						 * 不是黑方走的棋时把白子填充在输入的坐标里，并改变
						 * blackDo的值，使下一次为黑方填充
						 */
						goBang[a][b]=white;
						blackDo=true;
					}
				}	else	{//输入的坐标位置不可用时
					do {
						System.out.println("输入位已经存在棋子，"
								+ "请从新输入：");
						zb=input.next();
						str=zb.split(",");
						//以,为界把一个字符串分成两个字符串
						a=Integer.valueOf(str[0])-1;
						b=Integer.valueOf(str[1])-1;
						//将字符串转int，并-1才能转换成数组的索引下标
	                    }	while(!goBang[a][b].equals(add));
					if(blackDo)	{
						/*
						 * 是黑方走的棋时把黑子填充在输入的坐标里，并改变
						 * blackDo的值，使下一次为白方填充
						 */
						goBang[a][b]=black;
						blackDo=false;
					}	else	{
						/*
						 * 不是黑方走的棋时把白子填充在输入的坐标里，并改变
						 * blackDo的值，使下一次为黑方填充
						 */
						goBang[a][b]=white;
						blackDo=true;
					}
				}
				PanDing();//调用判定方法进行判定
				//如果人赢了，机器就不需要再走
				if(blackScore<5)	{
					//机器走棋
	                Random rand=new Random();
					b=rand.nextInt(20);
					//生成[0,20)之间的随机整数，不包括20
					a=rand.nextInt(20);
					//生成[0,20)之间的随机整数，不包括20
					if(goBang[a][b].equals(add))	{
						goBang[a][b]=white;
						blackDo=true;
					}	else	{
						do {
							b=rand.nextInt(20);
							//生成[0,20)之间的随机整数，不包括20
							a=rand.nextInt(20);
							//生成[0,20)之间的随机整数，不包括20
						}	while(goBang[a][b].equals(add));
						goBang[a][b]=white;
						blackDo=true;
					}
				}
				show();
			}	while(begin);
	        if(blackScore>=5 || whiteScore>=5)	{
				System.out.println("是否再来一局？y/n：");
				if(input.next().equals("n"))	{
					goOn=false;
					System.out.println("游戏结束！");
				}	else	{
					for(int i=0;i<goBang.length;i++)	{
						for(int j=0;j<goBang.length;j++)	{
							goBang[i][j]=add;
						}
					}
					show();
				}
			}
		}	while(goOn);
	}//主方法结束
  1. 定义静态方法显示棋局
1
2
3
4
5
6
7
8
9
static void show()	{//静态方法显示棋局
		//输出棋局的方法用增强for循环
		for(String[] strs:goBang)	{
			for(String str:strs)	{
				System.out.print(str);
			}
			System.out.println();
		}
	}
  1. 定义判定方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
static void PanDing()	{
		/**
		 * 判断输赢，赢面出现时共有4种情况
		 * 定义blackScore为黑方棋子连续的连接个数，值为5时赢
		 * 定义whiteScore为白方棋子连续的连接个数，值为5时赢
		 */
		blackScore=1;
		whiteScore=1;
		//1. 5个横着的连续的相同颜色的棋子
		lableA:
			for(String[] strs:goBang)	{
				for(String str:strs)	{
					if(str.equals(black))	{
						blackScore++;
					}	else
						blackScore=0;
					if(str.equals(white))	{
						whiteScore++;
					}	else
						whiteScore=0;
					if(blackScore>5)	{
						begin=false;
						System.out.println("游戏结束，"
								+ "你赢了！");
						break lableA;
					}
					if(whiteScore>5)	{
						begin=false;
						System.out.println("游戏结束，"
								+ "你输了！");
						break lableA;
					}
				}
			}
		//2. 分两种情况竖线，分两种判定方式
		//2.1 最后落子在竖线的顶端构成五子连珠，由上往下判定
		if(a<16 && blackScore<5)	{
			blackScore=1;
			whiteScore=1;
			int a1=a;
			for(int i=0;i<4;i++)	{
				int a0=a1++;
	            if(goBang[a1][b].equals(goBang[a0][b])
						&& goBang[a1][b].equals(black))	{
					blackScore++;
				}
				if(goBang[a1][b].equals(goBang[a0][b])
						&& goBang[a1][b].equals(white))	{
					whiteScore++;
				}
				if(blackScore>=5)	{
					begin=false;
					System.out.println("游戏结束，你赢了！");
					break;
				}
				if(whiteScore>=5)	{
					begin=false;
					System.out.println("游戏结束，你输了！");
					break;
	            }
			}
		}
		//2.2 最后落子在竖线的底端构成五子连珠，由下往上判定
		if(a>3 && blackScore<5)	{
			blackScore=1;
			whiteScore=1;
			int a1=a;
			for(int i=0;i<4;i++)	{
				int a0=a1--;
				if(goBang[a1][b].equals(goBang[a0][b])
						&& goBang[a1][b].equals(black))	{
					blackScore++;
				}
				if(goBang[a1][b].equals(goBang[a0][b])
						&& goBang[a1][b].equals(white))	{
					whiteScore++;
				}
				if(blackScore>=5)	{
					begin=false;
					System.out.println("游戏结束，你赢了！");
	                break;
				}
				if(whiteScore>=5)	{
					begin=false;
					System.out.println("游戏结束，你输了！");
					break;
				}
			}
		}
		//3. "\"分两种判定方式
		//3.1 从左上往右下判定
		if(a<16 && b<16 && blackScore<5)	{
			blackScore=1;
			whiteScore=1;
			int a1=a;
			int b1=b;
	        for(int i=0;i<4;i++)	{
				int a0=a1++;
				int b0=b1++;
				if(goBang[a1][b1].equals(goBang[a0][b0])
						&& goBang[a1][b1].equals(black))	{
					blackScore++;
				}
				if(goBang[a1][b1].equals(goBang[a0][b0])
						&& goBang[a1][b1].equals(white))	{
					whiteScore++;
				}
				if(blackScore>=5)	{
					begin=false;
	                System.out.println("游戏结束，你赢了！");
					break;
				}
				if(whiteScore>=5)	{
					begin=false;
					System.out.println("游戏结束，你输了！");
					break;
				}
			}
		}
	    //3.2 从右下往左上判定
		if(a>3 && b>3 && blackScore<5)	{
			blackScore=1;
			whiteScore=1;
			int a1=a;
			int b1=b;
			for(int i=0;i<4;i++)	{
				int a0=a1--;
				int b0=b1--;
				if(goBang[a1][b1].equals(goBang[a0][b0])
						&& goBang[a1][b1].equals(black))	{
					blackScore++;
				}
				if(goBang[a1][b1].equals(goBang[a0][b0])
						&& goBang[a1][b1].equals(white))	{
					whiteScore++;
				}
				if(blackScore>=5)	{
					begin=false;
	                System.out.println("游戏结束，你赢了！");
					break;
				}
				if(whiteScore>=5)	{
					begin=false;
					System.out.println("游戏结束，你输了！");
					break;
				}
			}
		}
		//4. "/"分两种判定方式
		//4.1 从右上往左下判定
		if(a<16 && b>3 && blackScore<5)	{
			blackScore=1;
			whiteScore=1;
			int a1=a;
			int b1=b;
			for(int i=0;i<4;i++)	{
				int a0=a1++;
				int b0=b1--;
	            if(goBang[a1][b1].equals(goBang[a0][b0])
						&& goBang[a1][b1].equals(black))	{
					blackScore++;
				}
				if(goBang[a1][b1].equals(goBang[a0][b0])
						&& goBang[a1][b1].equals(white))	{
					whiteScore++;
				}
				if(blackScore>=5)	{
					begin=false;
					System.out.println("游戏结束，你赢了！");
					break;
				}
				if(whiteScore>=5)	{
					begin=false;
					System.out.println("游戏结束，你输了！");
					break;
	            }
			}
		}
		//4.2 从左下往右上判定
		if(a>3 && b<16 && blackScore<5)	{
			blackScore=1;
			whiteScore=1;
			int a1=a;
			int b1=b;
			for(int i=0;i<4;i++)	{
				int a0=a1--;
				int b0=b1++;
				if(goBang[a1][b1].equals(goBang[a0][b0])
						&& goBang[a1][b1].equals(black))	{
					blackScore++;
				}
	            if(goBang[a1][b1].equals(goBang[a0][b0])
						&& goBang[a1][b1].equals(white))	{
					whiteScore++;
				}
				if(blackScore>=5)	{
					begin=false;
					System.out.println("游戏结束，你赢了！");
					break;
				}
				if(whiteScore>=5)	{
					begin=false;
					System.out.println("游戏结束，你输了！");
					break;
				}
			}
		}
	}
  1. 保存，输出结果如图所示：