java五子棋游戏课程设计报告(java五子棋游戏课程设计报告总结)
五子棋游戏用Java设计
可以写一个仿的五子棋 ,图片可以绘制,
主要逻辑:
1.用二维数组存储整个棋盘
2. 每一个格子,存在三种状态, 0,1,2
0代表空白 ,1代表白棋 ,2代表黑棋 . 只有0的状态(没有棋子)才能改变成其他状态
3. 每走一步, 就判断是否有输赢(横向,纵向,两条斜线)是否有5连的情况
效果如下
java游戏五子棋论文
%@ page contentType="text/html;charset=utf-8"%
html
head
title五子棋/title
meta http-equiv="Content-Type" content="text/html; charset=utf-8"
style type="text/css"
body{ word-break:break-word;
}
#aboutstep{
position:absolute;
right:45px;
top:300px;
width:200px;
vertical-align:bottom;
}
/style
script language="javascript"
//五子棋棋子亦称“棋石”分黑、白两色，形状为扁圆形，有一面凸起或两面凸起等形状，厚度不超过0.8厘米，直径为2.0～2.3厘米；
//一副棋子总数为225枚，其中黑子113枚，白子112枚。
var presentperson=false; //true表示人先下,否则表示机器先下
//谁先只需要改为true或false就可以了,不需要改其它东西
var maxsize=15;
var personstep=0;
var machinestep=0;
var _stack=new Array();//needn't to allocate space
var chese=new Array(maxsize*maxsize);
var chesevalue=new Array(maxsize*maxsize);
for(var i=0;imaxsize*maxsize;i++)//初始化棋盘
{ chese[i]=0;
}
/script
/head
body onload="startup()"
table id="chesetable" border="1px" width="auto" align="center" height="600px" style="background-color:#EED090;text-align:center;"
%
for(int i=0;i15;i++)
{out.print("tr");
for(int j=0;j15;j++)
{out.print("td onclick='putone(this,"+i+","+j+")' style='width:45px;height:45px;cursor:pointer;'??/td");
}
out.print("/tr");
}
%
/table
div id="aboutstep"!-- 加计时器会降低速度，这里就不加了 --
??人?img src="images/white_.gif" alt="white" width="50px" height="50px" style="vertical-align:middle;"/span id="aboutsteppeople" style="position:inline;"0/span
span style="display:inline;"input type="text" id="peopleusedtime" size=4 maxlength="8" //span
br /
机器?img src="images/black_.gif" alt="black" width="50px" height="50px" style="vertical-align:middle;"s/span id="aboutstepmachine" style="position:inline;"0/span
span style="display:inline;"input type="text" id="machineusedtime" size=4 maxlength="8" //span
/div
div align="center"
input type="button" name="restart" value="重新开始" onclick="reload()"/input type="button" name="turnout" value="交换顺序" /
input type="button" name="undo" value="悔棋" onclick="popstack()"/
/div
script language="JavaScript"
function startup()
{
if(!presentperson)//机器先下
{ var obj=document.getElementById("chesetable").rows[7].cells[7];
putone(obj,7,7);
}
}
function putone(obj,i,j)
{ //if(obj.firstChild.nodeValue=="◎"||obj.firstChild.nodeValue=="●")
if(obj.firstChild.nodeType==1) //表示放了棋子
{ return false;}
var node=null;
if(presentperson)
{ //node=document.createTextNode("◎"); //人的棋子颜色
if(document.uniqueID) //IE
node=document.createElement("img src='images/white_.gif' alt='white' width='40px' height='40px' /");
else { //for Firefox,Opera
node=document.createElement("img");
node.setAttribute("src","images/white_.gif");
node.setAttribute("alt","white");
node.setAttribute("width","40px");
node.setAttribute("height","40px");
}
presentperson=!presentperson;
chese[maxsize*i+j]=1;
personstep++;
document.getElementById("aboutsteppeople").innerHTML=personstep;
}
else {//node=document.createTextNode("●"); //机器的棋子颜色
if(document.uniqueID) //IE
node=document.createElement("img src='images/black_.gif' alt='black' width='40px' height='40px' /");
else { node=document.createElement("img");
node.setAttribute("src","images/black_.gif");
node.setAttribute("alt","black");
node.setAttribute("width","40px");
node.setAttribute("height","40px");
}presentperson=!presentperson;
chese[maxsize*i+j]=2;
machinestep++;
document.getElementById("aboutstepmachine").innerHTML=machinestep;
}
obj.replaceChild(node,obj.firstChild);
_stack.push(i);
_stack.push(j); //避免数据冗余，就不存储presentperson
var result=checkfinish(!presentperson,i,j);
if(result)
{ if(!presentperson) alert("Congratulation!You win.");
else alert("I am sorry that the machine wins,try your best to win next time.");
setTimeout(reload,4000); //刷新页面
}
if(!presentperson) {machinedecideposition();} //机器走。如果选择全部由人走就去掉这个
}
function checkfinish(presentperson,i,j)
{ //persentperson为true时表示刚才人下了一步
var checkword;
var result=false; //nobody wins
if(presentperson) checkword=1;
else checkword=2;
var total=1;
var tempj=j+1;
while(tempjmaxsize) //横
{ if(chese[maxsize*i+tempj]==checkword)
{total++; tempj++;}
else break;
}
tempj=j-1;
while(tempj=0)
{ if(chese[maxsize*i+tempj]==checkword)
{total++; tempj--;}
else break;
}
if(total4) { return true;}
total=1;
var tempi=i+1; //竖
while(tempimaxsize)
{ if(chese[maxsize*tempi+j]==checkword)
{total++; tempi++;}
else break;
}
tempi=i-1;
while(tempi=0)
{ if(chese[maxsize*tempi+j]==checkword)
{total++; tempi--;}
else break;
}
if(total4) { return true;}
total=1;
tempi=i+1; //一三象限斜
tempj=j+1;
while(tempimaxsizetempjmaxsize)
{ if(chese[maxsize*tempi+tempj]==checkword)
{total++; tempi++; tempj++;}
else break;
}
tempi=i-1;
tempj=j-1;
while(tempi=0tempj=0)
{ if(chese[maxsize*tempi+tempj]==checkword)
{total++; tempi--; tempj--;}
else break;
}
if(total4) { return true;}
total=1;
tempi=i+1; //二四象限斜
tempj=j-1;
while(tempimaxsizetempj=0)
{ if(chese[maxsize*tempi+tempj]==checkword)
{total++; tempi++; tempj--;}
else break;
}
tempi=i-1;
tempj=j+1;
while(tempi=0tempjmaxsize)
{ if(chese[maxsize*tempi+tempj]==checkword)
{total++; tempi--; tempj++;}
else break;
}
if(total4) { return true;}
return false;
}
function pushstack()
{
}
function popstack() //悔棋
{
if(_stack.length/21) return;
//var ispresentperson=(_stack.length/2)%2?true:false;//这个跟谁先下有关
var ispresentperson=presentperson; //now it has not matter with the length of _stack
var j=_stack.pop();
var i=_stack.pop();
removeone(ispresentperson,i,j);
}
function removeone(ispresentperson,i,j)
{ var obj=document.getElementById("chesetable");
//text,tbody
var tbody=obj.firstChild.nextSibling;
tbody.rows[i].cells[j].innerHTML="?";
chese[maxsize*i+j]=0; //也要初始化那个棋子所在的位置
presentperson=!presentperson;//也要回滚该谁走,who's turn now?
if(!ispresentperson) {personstep--;
document.getElementById("aboutsteppeople").innerHTML=personstep;
}
else {machinestep--;
document.getElementById("aboutstepmachine").innerHTML=machinestep;
}
}
function machinedecideposition() //机器决定下一步的位置
{ //在第一层节点选择的时候采用贪婪算法，直接找出相对分数比较高的几个形成第一层节点，目的是为了提高搜索速度和防止堆栈溢出。
if(machinestep==0) //机器走第一步
{ var obj=document.getElementById("chesetable").rows[7].cells[7];
if(putone(obj,7,7)==false)
{ obj=document.getElementById("chesetable").rows[6].cells[6];
putone(obj,6,6);
}
}
else if(machinestep==1) //机器走第二步
{ var obj=document.getElementById("chesetable").rows[7].cells[7];
if(putone(obj,7,7)==false) //7,7位置被占用
{ obj=document.getElementById("chesetable").rows[6].cells[6];
if(putone(obj,6,6)==false)//6,6位置被占用
{obj=document.getElementById("chesetable").rows[6].cells[7];
putone(obj,6,7);
}
}
}
else { var checkword=2; //先判断机器的，在设置为1判断这个位置对人的贡献
for(var tttt=0;ttttmaxsize*maxsize;tttt++)
chesevalue[tttt]=-10;//初始化
for(var i=0;imaxsize;i++)
for(var j=0;jmaxsize;j++)
{ if(chese[maxsize*i+j]!=0) //the position is occupied
continue;
var total=1;
var tempj=j+1;
var spacenumber=0; //中间空多少个
var befive=0; //成5,包括五连和长连
var livefour=0; //活四，有两个点可以成5地四
var befour=0; //冲四，只有一个点可以成为5的四
var deadfour=0; //死四，不能成为5的四
var livethree=0; //活三，再走一步就可以成为活四的三
//活三包括 连活三和跳活三
var bethree=0;
var livetwo=0;
var betwo=0;
//三三，一子落下同时形成两个活三
//四四，一子落下同时形成两个冲四
//四三,一子落下同时形成一个冲四和 活三
for(var tt=0;;tt++)
{ if(tt==0)
checkword=2; //machine
else checkword=1; //people
while(tempjmaxsize) //横
{ if(chese[maxsize*i+tempj]==checkwordcheckword==2) //是机器的
{total++; tempj++;}
else if(chese[maxsize*i+tempj]==0checkword==2) //对于防守不考虑空格
{ //is empty
spacenumber++; break;
if((++tempj)maxsizechese[maxsize*i+tempj]==checkwordspacenumber2)
total++;
else break;
}
else if(chese[maxsize*i+tempj]==checkwordcheckword==1) //防守
{ total++; tempj++;
}
else break;
}
var endj=tempj;
tempj=j-1;
while(tempj=0)
{ if(chese[maxsize*i+tempj]==checkwordcheckword==2)
{total++; tempj--;}
else if(chese[maxsize*i+tempj]==0checkword==2)
{ //is empty
spacenumber++; break;
if((--tempj)=0chese[maxsize*i+tempj]==checkwordspacenumber2)
total++;
else break;
}
else if(chese[maxsize*i+tempj]==checkwordcheckword==1) //防守
{ total++; tempj--;
}
else break;
}
var startj=tempj;
//由于checkword==2先运行，所以可以直接用befive=1,也可以用befive++;
if(total4) { //能组成五个或以上的
if(checkword==2)
{befive+=2
} //堵住成五
else befive++;
}//进攻要大于防守
else if(total==4) { //能组成四个
if(checkword==2) //表示考虑进攻
{ if(startj=0endjmaxsizechese[maxsize*i+startj]!=1chese[maxsize*i+endj]!=1) //两边为空格
livefour+=2; //放在这里可以形成一个活四
else if((startj=0chese[maxsize*i+startj]!=1)||(endjmaxsizechese[maxsize*i+endj]!=1))
befour+=2; //形成一个冲四
else deadfour+=2;
}
else //考虑防守
{ if(startj=0endjmaxsizechese[maxsize*i+startj]!=2chese[maxsize*i+endj]!=2)
livefour+=1; //放在这里可以形成一个活四
else if((startj=0chese[maxsize*i+startj]!=2)||(endjmaxsizechese[maxsize*i+endj]!=2))
befour+=1; //形成一个冲四
else deadfour+=1;
}
}
else if(total==3){if(checkword==2) //表示考虑进攻
{ if(startj=0endjmaxsizechese[maxsize*i+startj]!=1chese[maxsize*i+endj]!=1) //两边为空格
livethree+=2; //放在这里可以形成一个活三(算做连活三)
else if((startj=0chese[maxsize*i+startj]!=1)||(endjmaxsizechese[maxsize*i+endj]!=1))
bethree+=2; //形成一个眠三，即可以冲四的三
// else deadfour+=2;
//跳三
}
else //考虑防守
{ if(startj=0endjmaxsizechese[maxsize*i+startj]!=2chese[maxsize*i+endj]!=2) //两边为空格
livethree+=1; //放在这里可以形成一个活三(算做连活三)
else if((startj=0chese[maxsize*i+startj]!=2)||(endjmaxsizechese[maxsize*i+endj]!=2))
bethree+=1; //形成一个眠三，即可以冲四的三
}
}
else if(total==2){ if(checkword==2) //表示考虑进攻
{ if(startj=0endjmaxsizechese[maxsize*i+startj]!=1chese[maxsize*i+endj]!=1) //两边为空格
livetwo++; //放在这里可以形成一个活三(算做连活三)
}
else //考虑防守
{ if(startj=0endjmaxsizechese[maxsize*i+startj]!=2chese[maxsize*i+endj]!=2) //两边为空格
livetwo++; //放在这里可以形成一个活三(算做连活三)
}
}
java课程设计，做了网络五子棋，老师要我加复盘的功能，怎么实现？思路
这个很简单。五子棋棋盘是一个二维数组，然后2数组里面有每个位置上只能有3个值，0,1,2，0表示没有棋子，1表示白棋，2表示黑棋。然后你用一个类把二维数组封装起来，然后保存每一步时候的状态就OK了。
java 课程设计游戏 五子棋 如何实现 五子棋的存档和读档功能
public class test20 { public static void main(String[] args) { float fm = 1f; float fz = 1f; float temp; float sum = 0f; for (int i=0;i20;i++){
temp = fm;
fm = fz;
fz = fz + temp;
sum += fz/fm;
//System.out.println(sum);
}
System.out.println(sum);
}
}
java 五子棋 课程设计
呵呵，代码自己测试：
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
import java.awt.Color;
public class enzit extends Applet implements ActionListener,MouseListener,MouseMotionListener,ItemListener
{
int color_Qizi=0;//旗子的颜色标识 0:白子 1:黑子
int intGame_Start=0;//游戏开始标志 0未开始 1游戏中
int intGame_Body[][]=new int[16][16]; //设置棋盘棋子状态 0 无子 1 白子 2 黑子
Button b1=new Button("游戏开始");
Button b2=new Button("重置游戏");
Label lblWin=new Label(" ");
Checkbox ckbHB[]=new Checkbox[2];
CheckboxGroup ckgHB=new CheckboxGroup();
public void init()
{
setLayout(null);
addMouseListener(this);
add(b1);
b1.setBounds(330,50,80,30);
b1.addActionListener(this);
add(b2);
b2.setBounds(330,90,80,30);
b2.addActionListener(this);
ckbHB[0]=new Checkbox("白子先",ckgHB,false);
ckbHB[0].setBounds(320,20,60,30);
ckbHB[1]=new Checkbox("黑子先",ckgHB,false);
ckbHB[1].setBounds(380,20,60,30);
add(ckbHB[0]);
add(ckbHB[1]);
ckbHB[0].addItemListener(this);
ckbHB[1].addItemListener(this);
add(lblWin);
lblWin.setBounds(330,130,80,30);
Game_start_csh();
}
public void itemStateChanged(ItemEvent e)
{
if (ckbHB[0].getState()) //选择黑子先还是白子先
{
color_Qizi=0;
}
else
{
color_Qizi=1;
}
}
public void actionPerformed(ActionEvent e)
{
Graphics g=getGraphics();
if (e.getSource()==b1)
{
Game_start();
}
else
{
Game_re();
}
}
public void mousePressed(MouseEvent e){}
public void mouseClicked(MouseEvent e)
{
Graphics g=getGraphics();
int x1,y1;
x1=e.getX();
y1=e.getY();
if (e.getX()20 || e.getX()300 || e.getY()20 || e.getY()300)
{
return;
}
if (x1%2010)
{
x1+=20;
}
if(y1%2010)
{
y1+=20;
}
x1=x1/20*20;
y1=y1/20*20;
set_Qizi(x1,y1);
}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
public void mouseReleased(MouseEvent e){}
public void mouseDragged(MouseEvent e){}
public void mouseMoved(MouseEvent e){}
public void paint(Graphics g)
{
draw_qipan(g);
}
public void set_Qizi(int x,int y) //落子
{
if (intGame_Start==0) //判断游戏未开始
{
return;
}
if (intGame_Body[x/20][y/20]!=0)
{
return;
}
Graphics g=getGraphics();
if (color_Qizi==1)//判断黑子还是白子
{
g.setColor(Color.black);
color_Qizi=0;
}
else
{
g.setColor(Color.white);
color_Qizi=1;
}
g.fillOval(x-10,y-10,20,20);
intGame_Body[x/20][y/20]=color_Qizi+1;
if (Game_win_1(x/20,y/20)) //判断输赢
{
lblWin.setText(Get_qizi_color(color_Qizi)+"赢了!");
intGame_Start=0;
}
if (Game_win_2(x/20,y/20)) //判断输赢
{
lblWin.setText(Get_qizi_color(color_Qizi)+"赢了!");
intGame_Start=0;
}
if (Game_win_3(x/20,y/20)) //判断输赢
{
lblWin.setText(Get_qizi_color(color_Qizi)+"赢了!");
intGame_Start=0;
}
if (Game_win_4(x/20,y/20)) //判断输赢
{
lblWin.setText(Get_qizi_color(color_Qizi)+"赢了!");
intGame_Start=0;
}
}
public String Get_qizi_color(int x)
{
if (x==0)
{
return "黑子";
}
else
{
return "白子";
}
}
public void draw_qipan(Graphics G) //画棋盘 15*15
{
G.setColor(Color.lightGray);
G.fill3DRect(10,10,300,300,true);
G.setColor(Color.black);
for(int i=1;i16;i++)
{
G.drawLine(20,20*i,300,20*i);
G.drawLine(20*i,20,20*i,300);
}
}
public void Game_start() //游戏开始
{
intGame_Start=1;
Game_btn_enable(false);
b2.setEnabled(true);
}
public void Game_start_csh() //游戏开始初始化
{
intGame_Start=0;
Game_btn_enable(true);
b2.setEnabled(false);
ckbHB[0].setState(true);
for (int i=0;i16 ;i++ )
{
for (int j=0;j16 ;j++ )
{
intGame_Body[i][j]=0;
}
}
lblWin.setText("");
}
public void Game_re() //游戏重新开始
{
repaint();
Game_start_csh();
}
public void Game_btn_enable(boolean e) //设置组件状态
{
b1.setEnabled(e);
b2.setEnabled(e);
ckbHB[0].setEnabled(e);
ckbHB[1].setEnabled(e);
}
public boolean Game_win_1(int x,int y) //判断输赢 横
{
int x1,y1,t=1;
x1=x;
y1=y;
for (int i=1;i5 ;i++ )
{
if (x115)
{
break;
}
if (intGame_Body[x1+i][y1]==intGame_Body[x][y])
{
t+=1;
}
else
{
break;
}
}
for (int i=1;i5 ;i++ )
{
if (x11)
{
break;
}
if(intGame_Body[x1-i][y1]==intGame_Body[x][y])
{
t+=1;
}
else
{
break;
}
}
if (t4)
{
return true;
}
else
{
return false;
}
}
public boolean Game_win_2(int x,int y) //判断输赢 竖
{
int x1,y1,t=1;
x1=x;
y1=y;
for (int i=1;i5 ;i++ )
{
if (x115)
{
break;
}
if (intGame_Body[x1][y1+i]==intGame_Body[x][y])
{
t+=1;
}
else
{
break;
}
}
for (int i=1;i5 ;i++ )
{
if (x11)
{
break;
}
if(intGame_Body[x1][y1-i]==intGame_Body[x][y])
{
t+=1;
}
else
{
break;
}
}
if (t4)
{
return true;
}
else
{
return false;
}
}
public boolean Game_win_3(int x,int y) //判断输赢 左斜
{
int x1,y1,t=1;
x1=x;
y1=y;
for (int i=1;i5 ;i++ )
{
if (x115)
{
break;
}
if (intGame_Body[x1+i][y1-i]==intGame_Body[x][y])
{
t+=1;
}
else
{
break;
}
}
for (int i=1;i5 ;i++ )
{
if (x11)
{
break;
}
if(intGame_Body[x1-i][y1+i]==intGame_Body[x][y])
{
t+=1;
}
else
{
break;
}
}
if (t4)
{
return true;
}
else
{
return false;
}
}
public boolean Game_win_4(int x,int y) //判断输赢 左斜
{
int x1,y1,t=1;
x1=x;
y1=y;
for (int i=1;i5 ;i++ )
{
if (x115)
{
break;
}
if (intGame_Body[x1+i][y1+i]==intGame_Body[x][y])
{
t+=1;
}
else
{
break;
}
}
for (int i=1;i5 ;i++ )
{
if (x11)
{
break;
}
if(intGame_Body[x1-i][y1-i]==intGame_Body[x][y])
{
t+=1;
}
else
{
break;
}
}
if (t4)
{
return true;
}
else
{
return false;
}
}
}
系统框图如下 java实现五子棋程序 可以实现人人对战 人机对战 简单功能 悔棋 认输
一、实验题目
五子棋游戏。
二、问题分析
五子棋是双人博弈棋类益智游戏，由围棋演变而来，属纯策略型。棋盘通常15*15，即15行，15列，共225个交叉点，即棋子落点；棋子由黑白两色组成，黑棋123颗，白棋122颗。游戏规则为黑先白后，谁先五子连成一条直线谁赢，其中直线可以是横的、纵的、45度、135度。
本次Java编程我的目的是现实人机对战，即游戏者一方是人，另一方计算机。这就要求程序不仅要具备五子棋的基本界面，还要编程指导计算机与人进行对弈。为了使程序尽可能智能，我采用了贪心策略、传统搜索算法、极大极小博弈树算法，对应游戏玩家的3个等级：简单、中等、困难。
三、功能设计
我的程序基本功能是实现人机对弈五子棋。人和电脑交替下棋，谁先五子连成一条直线谁就赢。下面是我程序的功能模块：
1.等级设置
核心功能是实现不同策略与算法的对比运用，纯贪心策略实现简单等级对手，直接搜索算法实现中等等级对手，极大极小博弈树算法实现困难等级对手。对应程序中的3选1单选按钮。
2.悔棋功能
模拟栈机制实现人悔棋，不限步长的悔棋。对应程序中的悔棋按钮。
3.棋面绘制
根据不同机计算机的屏幕分辨率，绘制逼真的棋盘。
4.图片引入
两张古典的人物图片，生动模拟对弈双方。人物图片旁的黑白棋钵图片显示黑白棋归属。
5.背景设置
支持用户选择背景，包括棋盘、棋盘边框、窗口边框，彰显个性。
6.音乐播放
下棋时有棋子落地的声音，一方胜利时有五子连成一片的声音。同时在设置背景时相应的改变整个对弈过程中的背景音乐。
7.时间显示
在棋盘正上方有一模拟文本框显示当前棋局用时。
8.其他小功能
支持和棋、认输、开启新游戏、退出游戏等操作。
四、数据结构与算法设计
数据结构部分
1.当前棋局的存储结构
我的五子棋程序选择通常用到的15行*15列棋盘，可以开二维数组PositionFlag?=?new?int[15][15]，PositionFlag[i][j]为0表示(i,j)点尚无棋，为1表示(i,j)点是人的棋子，为2表示(i,j)点是机器的棋子。之所以选择二维数组，主要原因有两点：
1.本程序需要频繁随机访问15*15的交叉点，对应查询该点状态以及改变该点状态，随机访问是数组的特点。
2.15*15=225开二维数组的内存需求相对现在内存为2G及以上的计算机完全可以接受，且数组实现简单、操作方便。
基于以上两点，尽管创建动态的顺序表—链表可能可以节省少量内存（可以只存当前有棋的点，原数组对应位置为0的点可以不存），但选择数组的优势完全在上述两点体现了出来。
2.实现悔棋操作的数据结构
由于每次悔棋只需回退当前几步，后进先出原则，这正是栈这种典型数据结构的设计思想，于是我选择栈。我自己先写了用自定义数组模拟的栈，但由于是学Java语言且由于悔棋的存储空间需要随当前步数增大而增大（由于每局最多下225步，即最多要悔225步，所以自己开个225的数组完全可以避免存储空间自增长的问题且内存完全可以接受，之所以不用自定义数组而用ArrayList类主要是为了尝试Java中STL的用法），所有我最终改为用Java类库中的ArrayList类。
确定用ArrayList类实现栈机制后就必须考虑每个ArrayList单元具体存储什么。刚开始我存储的是当前的棋局，即整个局面，而每个局面对应一个二维数组，这样是很占用内存的。试想一下，在最坏情况下，225个ArrayList单元，每个单元存放一个15*15的二维数组，尽管225*15*15在Java的内存管理机制下不会爆栈，但也是极不划算的。之所以说不划算，是因为有更好的解决方案。由于每次悔棋只是在回退倒数一步，多步悔棋只需循环回退，所以可以只存储当前棋局最后一步的下法，对应一个二维点，完全可以自定义一个二维坐标类chessOneStep。
算法设计部分
Java语言是面向对象的语言。我在进行五子棋游戏编程是总共传创建了11个自定义的类。在编写程序的过程中，我有一个明显的体验就是面向对象编程就是一项有关对象设计和对象接口技术，很多关键的技术就是如何设计自定义的对象。
下面我先概括给出我的所有类的作用：
1.mainFrame类：主框架类，我应用程序的入口；
2.chessPositon类：主控类，这个类是我程序的核心类，负责控制双方的下棋，以及调用其他的类完成当前棋局的显示绘制；
3.chessPanel类：面板类，调用其他底层类完成当前棋局的显示绘制；
4.chessBoard类：棋盘绘制类，负责棋盘的绘制；
5.chessImage类：文件类，包含各种资源（背景图片、背景音乐）以及静态全局变量（public?static?Type）；
6.chessButton类：组件类，定义各种组件，包括按钮、单选按钮、文本框等；
7.chessMusic类：音乐类，负责调用Java库类完成背景音乐、下棋音乐、取胜音乐等的播放；
8.chessPiece类：棋局类，定义棋局二维数组数据结构并完成相关操作；
9.chessList类：栈类，完成悔棋等操作；
10.?chessOneStep类：棋子类，定义每步坐标以及下在该处获得的估价值；
11.myCompare类：排序类，完成chessOneStep类的自定义排序
详细设计
1.mainFrame类
作为我的五子棋程序的主类，mainFrame类主要实例化相关的对象，如chessbutton,chessborad等，从而完成框架的创建。更重要的是实例化chessposition，这是本程序的核心类，控制游戏双方行棋过程完成人机互动下棋，然后将MyChessPosition与鼠标响应addMouseListener（）关联起来。
2.chessMusic类
一个好的游戏必须给人一种身临其境的感觉，而声音是营造这种氛围的重要因素。参照网上各游戏运行商的音乐配置，我选择相关逼真的声音。包括背景音乐、下棋棋子落到棋盘发出的声音以及一方胜出的配乐。所有这些功能的实现，依赖于自定义的chessMusic类，采用AudioInputStream配合Clip的方式完成音乐播放的软硬件工作，然后定义两个接口chessmusic(String?Name)和Stop(),前者完成播放功能，后者完成关闭当前音乐功能。因为音频文件相对较大，而我的程序提供在不同背景乐之间切换的功能，所以在打开另一个音频文件之前必须关闭前一个正在播放的音频文件，防止出现溢出。
3.chessImage类
适当的动画或图片能给游戏玩家带来美的体验。所以我的五子棋程序界面在不失和谐的前提下引入了尽可能多的图片，包括对弈双方、棋钵等。图片引入的具体工作通过语句import?javax.imageio.ImageIO完成。同时，由于图片要在用到它的类中被访问，为了避免频繁调用函数，我直接将图片相关联的对象定义为public?static，表明是公用的、静态的。进一步引申开去，我将程序中用到的静态全局变量都定义在chessImage类中。具体如下：
public?static?Date?begin;//每局开始时间
public?static?Date?cur;//每局结束时间
public?static?chessOneStep?LineLeft;//结束端点1
public?static?chessOneStep?LineRight;//结束端点2
public?static?boolean?IsGameOver;//是否只有一方获胜
public?static?int?ColorOfBackGround[][]=?{{255,?227,?132},{0,255,127},{218,165,32}};//背景颜色
public?static?int?ColorOfWindows[][]=?{{?60,179,113},{245,245,245},{122,122,122}};//背景颜色
public?static?int?WitchMatch;//背景搭配
public?static?String?MusicOfBackGround;//背景音乐
public?static?int?CurrentStep;//记录当前步数
public?static?int?Rank;//设置难度等级
public?static?boolean?IsSurrender;//判断是否认输
public?static?boolean?IsTie;//判断是否认输
public?static?String?Message;//输出提示信息
public?static?Image?IconImage;//?图标
public?static?Image?blackBoard;//白棋盘
public?static?Image?whiteBoard;//黑棋盘
public?static?Image?blackChess;//?白棋棋子图片
public?static?Image?whiteChess;//?白棋棋子图片
public?static?Image?RightPlayer;//白棋棋罐图片
public?static?Image?LeftPlayer;//白棋玩家头像图片
public?static?String?path?=?"src/";//?图片的保存路径
4.chessButton类
这个是程序的组件类。定义了各种功能键，完善程序功能，营造逼真的人机对战游戏效果。分为3类：效果。。
(1)、按钮组件
本程序有5个按钮，支持和棋、认输、新游戏、退出、悔棋等。认输和和棋按钮终止当前的棋局，给出相应的提示信息；退出按钮调用系统System.exit(0)的函数正常返回；悔棋按钮调用后面要介绍的chessList类实现悔棋；新游戏按钮则刷新当前棋局准备下一轮，要将记录当前棋局的二维数组全部置0，刷新当前棋局开始时间等。
(2)、单选按钮组件
游戏界面支持设置个性化界面，包括背景颜色与背景音乐，跟重要的一点是设置难度（简单、中等、困难）。单选按钮只能多选一。背景颜色主要是存储相关颜色搭配方案的RGB颜色，开2维数组，即对应RGB3原色数组的一维数组，然后通过改变WitchMatch全局变量的值来有用户自己选择颜色搭配，不同的颜色搭配对应不同的背景音乐表达一致的主题。难度设置主要是改变计算机的下棋算法，不同难度通过Rank判断进入不同的程序分支，实现不同智能等级的计算机下棋水平。
(3)、文本框
在不同的单选按钮前添加相应的文本框，提示用户可以实现的功能。同时我用颜色模拟出显示当前棋局耗用时间的文本框。
不论按钮还是单选按钮都要关联相应的消息，把相应功能的实现放在消息响应处理函数理。这些主要是实现Java库提供的消息响应接口里的方法。
5.chessPiece类
主要完成当前棋面的存储，存储棋面的数据结构为二维数组int[][]?PositionFlag；然后定义获取、设置某点以及整个棋面的状态的方法。
(1)、SetPositionFlag(int?x,?int?y,?int?flag)//设置（x,y）处的状态为flag
(2)、GetPositionFlag(int?x,?int?y)//获取（x,y）处的状态
(3)、SetAllFlag(int?[][]NewFlag)//设置当前整个棋面的状态为NewFlag
(4)、GetAllFlag()//获取当前整个棋面的状态
(5)、DrawChessPiece(Graphics?g)//绘制当前局面的棋子
由于本类比较重要，所以附上了代码，见源代码1。
6.chessBoard类
功能为绘制棋盘线。由于围棋的棋盘比较复杂，横线、竖线较多，且为了使棋盘美观，还要自定义窗口边框、棋盘边框、对弈双方边框等，对线宽、线型也有一定要求。有时要单像素线条，有时要多像素线条。对于多像素线条，我主要用了2种方法。
方法一：
在需要绘制多像素线条处首先绘制一条单像素线，然后根据线宽要求上下平移适当像素达到绘制多像素的目的。这样的方法适合绘制水平线或竖直线，绘制其他斜率的线条容易造成走样。在没有想到比较好的反走样编程思想后我选择了调用Java库中已经封装好的函数。
方法二：
为了克服方法一绘制非水平或竖直线时造成的走样，同时也为了更进一步学习Java语言，我猜想肯定会有类似OpenGL中设置线宽的画刷，于是上网百度找到了相应的画刷Stroke类。通过Java库实现绘制不同线宽的直线，达到了反走样效果。
7.chessOneStep类
这个类是为了配合chessList类实现悔棋以及在计算机下棋算法实现返回有效状态点而设计的。主要数据成员为
private??int??x,y,weight；//其中x,y表示点坐标，weight表示将棋下到该点获得的估价值。
主要方法如下：
(1)、GetX()//获得当前对象的x坐标
(2)、GetY()//获得当前对象的y坐标
(3)、GetWeight()//获得当前对象的(x,y)处的估价值
8.chessList类
程序支持悔棋功能，为了实现悔棋，自定义了chessList类。这个类主要通过引入java.util.ArrayList和java.util.List实现集合的数据类型。然后自定义一些方法，如下：
（1）、AddStep(chessOneStep?OneStep)//添加一步棋到List中
（2）、GetSize()//获得当前List的大小
（3）、ClearList()//清空List
（4）、RemoveLast()//删去List中的最后元素
由于每次删除当前List中的最后一个元素，实现后进先出，所以可以模拟栈的功能实现悔棋。
9.myCompare类
由于在计算机下棋的极大极小博弈树算法中需要对自定义对象chessOneStep按weight进行排序，所以引入了myCompare类，通过实现Comparator接口中的compare方法完成自定义对象排序。
10.chessPanel类
程序的自定义面板类，主要负责完成当前框架内容的显示。这是一个重要的与框架和图形显示密切相关的类。主要数据成员为
private?chessboard?MyChessBoard;//当前显示棋盘
private?chesspiece?MyChessPiece;//当前显示整个棋面的状态
主要方法如下：
（1）、chesspanel(chessboard?MyChessBoard1,?chesspiece?MyChessPiece1)//构造函数，分别用MyChessBoard1和MyChessPiece1初始化MyChessBoard和MyChessPiece
（2）display(chessboard?MyChessBoard1,?chesspiece?MyChessPiece1)//自定义显示回调函数，调用repaint()完成重新绘制游戏界面
（3）、paintComponent(Graphics?g)//核心方法，调用各种函数完成具体的绘制工作
11.chessPositon类
程序算法核心类，总的功能是控制人和计算机轮流下棋，以及调用chessPanel类中的display(chessboard?,?chesspiece?)方法完成界面的实时刷新。关于chessPositon类，我在此将重点介绍。chessPosition类的主要数据成员如下：
private?static?chessboard?MyChessBoard;//当前显示棋盘
public?static?chesspiece?MyChessPiece;//当前显示整个棋面的状态
private?static?chesspanel?Mychesspanel;////当前显示面板
public?static?chesslist?MyChessList=new?chesslist();//当前下棋集合，用于悔棋
final?private?static?int?INF?=?(1??30);?//?表示正无穷大的常量，用于极大极小博弈数搜索算法
public?static?boolean?CanGo;//控制当前下棋一方
类的设计集中体现在成员方法的设计上。实现人机对战，只有语言是远远不够的，还要加入算法，用算法引导计算机下棋。下面介绍该类的方法成员：
（1）、chessposition(chesspanel?,?chessboard?,chesspiece?)?//带有参数的构造函数
（2）、chessposition()
不带参数的构造函数
（3）、mouseClicked(MouseEvent?event)
鼠标响应函数，负责人的下棋，根据鼠标点击的位置转换得到所在棋盘的相对位置。如果该位置不合法，即超出棋盘有效范围，点击无响应；如果该位置上已有棋，弹出消息框给出提示。这二者都要求重新给出下棋位置，即当前鼠标响应无效…直到点击到棋盘有效区域。
（4）、IsOver(int[][]?Array,int?x,int?y)
判断当前int[][]Array对应的棋局是否结束，即一方五子连成一条直线。此处有两种思路，一种对当前棋面上的所有棋子都进行一次判断，具体为水平方向、竖直方向、与水平线成45度方向、与水平线成135度方向，只要有一个方向五子连成一条直线就说明有一方获胜，游戏结束；另一种思路为只在当前下棋的4个方向进行判断，我的程序采用的是第二种，所以IsOver方法除了int[][]Array参数外，还有x,y参数，（x,y）表示当前下棋的坐标点。
（5）display()
通过调用自定义面板类的显示回调函数用于重新显示游戏界面，达到每下一步棋及时更新游戏界面的目的。
（6）、GetValue(int?flag,?int?num)
估值函数，根据经验把棋局分成只有1颗棋相连，2颗棋相连且两端被封死，2颗棋相连且一端封死另一端活的，2颗棋相连且两端都是活的，同理3颗棋、4颗棋也各自可分3种情况。不同的情况对应不同的估价值。估价值的设定是决定计算机一方是否智能的一个关键因素。
（7）、GetPredictValue(int?flag,?int?num)
对未连成一片但通过再下一颗子就能连成一片的局面进行估值，这在双方下棋的有限步骤内是能产生重要影响的。如果每局棋仅考虑当前一步，是不可取的。
（8）、Evaluate(int[][]?Array,?int?x,?int?y)
根据棋面具体情况以及预先设定的估值函数，对某个点对应的局面进行评估。由于每次双方只能下一颗棋，所以可以每次取当前局面的所有点中对应估值最大值点的估值作为整个局面的估值。
（9）、GetGreedNext()
计算机下棋方法1，对应难度等级为简单，采用贪心思想。每次下棋前在求得最有利点下棋，而是否最有利只是通过一步评估。算法伪码描述为：
Max取负无穷大
for(行i从0到15)
{
For(列j从0到15)
{
If((i，j)对应的位置无棋)
{
a.假设放上一颗由人控制的棋，求估价值；
b.假设放上一颗由计算机控制的棋，求估价值；
c.取二者中较大值作为(i,j）处的估价值tmp；
d.取tmp与Max较大值赋值给Max.
}
}
}
最终Max对应的点就是当前整个局面中最大的估值点。至于上述为什么要考虑双方都在该点下棋的情况呢？主要原因为下五子棋是个攻防兼备的过程，不仅要考虑自己对自己最有利，还要考虑对对手最不利，通俗来讲就是在自己赢的时候不能让对手先赢。
（10）、GetSearchNext(int?LookLength)
derectSearch(int?[][]Array,boolean?who,int?deepth)
计算机下棋方法2：直接搜索法,对应难度等级为中等。
每步棋最多有225个不同下法，若采用直接搜索法则对应的孩子节点有225个（在下棋过程中会逐渐减少），即每层有最多225个节点待扩展，这就决定了直接搜索进行不超过2次—主要原因有两点：
a.采用深度优先搜索需要递归，递归中状态过多可能会爆栈，我们知道递归是用栈机制来实现的；采用宽度优先搜索又需要存储为扩展的节点，这对内存容量要求很高。
b.不管深搜还是广搜，在时间复杂度为O(N^m)的情况下都是不能接受的。其中N为当前棋局的待扩展节点，最大225;m为搜索的深度。
综上所述，在采用直接搜索法时搜索深度不能太深，严格来说是应该控制在2层以内，在计算机运算速度在10^7次每秒的情况下，理论和实验都表明超过2层就会变得很慢且这种趋势成指数级增长。
直接搜索算法伪代码为
GetSearch(boolean?flag，int?deep)
{
如果deep等于0，返回当前棋局估值；
for(行i从0到15)
{
For(列j从0到15)
{
If((i，j)对应的位置无棋)
{
如果轮到计算机下棋，置标志位为2
GetSearch(！flag，deep-1)；
如果轮到人下棋，置标志位为1；
GetSearch(！flag，deep-1)；
}
}
}
}
（11）、GetMinMaxsearchNext(int?LookLength)
MinMaxsearch(int?[][]Array,boolean?who,?int?deepth)
计算机下棋算法3：极大极小博弈树法,对应难度等级为困难。五子棋是个博弈游戏，当前在寻找对自己最有利的下棋点时要尽可能保证对对手最不利，这种思想可以用极大极小博弈树