java课程设计中国象棋

课程设计说明书

NO.1

象棋程序设计

1.课程设计目的

Java语言是当今流行的网络编程语言，它具有面向对象、跨平台、分布应用等特点。面向对象的开发方法是当今世界最流行的开发方法，它不仅具有更贴近自然的语义，而且有利于软件的维护和继承，很好的融合了“面向对象”、“跨平台”和“编程简洁”等特性。随着Java语言的不断发展，它的应用前景将更为宽阔。

本课程设计主要是使用Swing这个Java自带的图形开发工具实现中国象棋棋子及棋盘的绘制，并根据相应的象棋规则，实现在电脑上虚拟出可以供两个人对弈的象棋游戏，从而达到了进一步巩固课堂上所学到的知识，深刻把握Java语言的重要概念及其面向对象的特性，熟练的应用面向对象的思想和设计方法解决实际问题的能力的目的。

2．设计方案论证

2.1程序功能

象棋是中国一种流传十分广泛的游戏。下棋双方根据自己对棋局形式的理解和对棋艺规律的掌握，调动车马，组织兵力，协调作战在棋盘－－这块特定的战场上进行着象征性的军事战斗。本程序的功能就是将棋盘和棋子在电脑上模拟出来，双方可以通过鼠标对己方棋子的操作进行对弈。

2.2设计思路

象棋，人人会走，把己方的棋子按不同棋子的规则放在棋盘合适的位置上。象棋包含三个要素：棋盘、棋子和规则。在本象棋程序的设计上，也大致遵循这三个要素，但是细化为四个方面：棋盘、棋盘上可以走棋的落子点、棋子和象棋规则。

棋盘其实就是一张棋盘的图形，我们要在计算机上的棋盘上落子并不像在现实生活中那么容易，这里说的棋盘充其量只是背景，真正落子的地方必须是我们在图形界面上设定的落子点，不同棋子只能按照各自的规则在这些设定的位置上摆放、搏杀。

2.3设计方法

根据前面的细化，程序中分别设计了四个类对应棋盘、落子点、棋子和象棋规则这

沈 阳 大 学

课程设计说明书

NO.2

四个方面。四个类几乎包括了程序的全部，程序框图如下图所示：

中国象棋

棋

子

落

子

点

棋

盘

象

棋

规

则

图1 程序功能框图

2.4详细设计

2.4.1棋子类Chess

Swing中并没有棋子这个组建类，所以我们必须设计一个组件，棋子其实就是圆形

的JLabel，但Swing中的JLabel组件是方形的，没关系，利用JLabel我们可以创建

圆形的JLabel组件——Chess。

运行结果：

图2 Chess类的运行结果“车”

沈 阳 大 学

课程设计说明书

NO.3

运行结果：

图3 Chess类的运行结果“帅”

2.4.2落子点类Point

在平面中确定一个点需要X坐标和Y 坐标，在图形界面中确定一个点同样也需要X坐标和Y坐标。图形界面的左上角的坐标为（0，0），X数值往右增大，Y数值往下增大。

落子点其实就是在图形界面上定义一个应该摆放棋子的点位置，棋子摆放在任何位置都视为非法，除了落子点。当然，描述一个点位置仅仅是类Point的基本功能之一，他还需要知道这个点上是否已有棋子以及是什么棋子。

2.4.3棋盘类ChessBord

棋盘其实就是我们看到的一个图形界面，将棋盘设计为JPanel类，在Jpanel这个容器上，我们可以利用坐标确定落子点，也可以加入我们自定义的棋子组件。

JPanel容器其实就像有底色的画布，有了落子点和棋子，还需要我们自己画横线和竖线。ChessBord继承了JPanel，覆写方法paintCompont，实例化JPanel时，会自动调用该方法。

沈 阳 大 学

课程设计说明书

NO.4

图4 中国象棋棋盘

2.4.4规则类ChessRule

ChessRule类的作用就是判断走棋是否合法。实现思路就是根据走棋的起点和终点计算走棋路线中是否有其他的棋子，再依据是何种棋子判断走棋是否合法。

沈 阳 大 学

课程设计说明书

NO.5

2.4.4类ChessFrame

虽然上面4个类实现了象棋程序的所有功能，但还需要一个底层窗口容器加载ChessBoard这个JPanel。并添加相应的菜单。

3.设计结果与分析

程序运行之后，可以实现两个人分别控制红方和黑方的棋子进行对弈，缺点就是程序过于简单，只能实现上述功能，不能悔棋，没有计时功能，也不能实现人机对弈功能。程序运行效果图如下所示：

图5 中国象棋程序运行效果图——开局

沈 阳 大 学

课程设计说明书

NO.6

图6 中国象棋程序运行效果图——残局

沈 阳 大 学

课程设计说明书

NO.7

4.设计体会

通过对java的课程设计，针对java的书本知识得到了进一步的巩固，具体化就是加深了我对图形用户界面理解，对程序的深层理解，清楚程序中每一步的功能，在程序的运行中是十分重要的，一个好的结构在运行中能够充分的发挥程序的功能。把书本上学习到的知识应用到实际中去，很好的锻炼了我编写java语言的能力。结构设计的合理性决定了这个程序的价值。在今后的学习中我要注意这方面，使得我的编程能力能有进一步的提高。

到此，一个完整的设计程序创建完毕。其功能基本符合需求，能够实现象棋的基本功能。但是由于课程设计时间较短，所以该设计还有许多不尽如人意的地方，但是这些都有待进一步改善。通过本课题的课程设计，我进一步了解和掌握了java这门学科。在完成此设计期间，我不仅提高了实际的编程能力，还深入了解了软件开发的全过，经历了这次课程设计，不仅对我的学习提供了帮助，而且在意志力方面也得到了锻炼，没有足够的耐力和信心就很难坚持对课程设计每一步的顺利进行。

在整个设计过程中，通过各种渠道获取资料。利用周末去大的书店查资料，把重要的东西记录下来，也去图书馆借了一些相关的参考资料，同时还充分利用网上资源查一些资料。最后再综合这些资料，在理工实验楼进行具体的操作。从做课题设计的过程中，我的体会挺多的，感觉到只要有信心与耐心，没有做不到的事情。因为在这个过程中写代码与调试的过程中确实需要耐心与信心，否则就不可能写完整。总之，本次课程设计使自己收益非浅，为自己以后进入社会工作提供了一次不可多得的锻炼和实践的机会。

沈 阳 大 学

课程设计说明书

NO.8

5.参考文献

[1]．胡书敏，陈宝峰，程炜杰.Java 第一步[M].北京:清华大学出版社.2009年1月:P257-287

[2]．朱站立，沈伟. Java程序设计实用教程[M]. 北京：电子工业出版社. 2006年7月:P90-134

[3].印旻. Java语言与面向对象程序设计[M].北京: 清华大学出版社，2003年2月：P99-146

[4].陈国君,陈磊,陈锡祯，刘洋. Java 2程序设计基础[M].北京:清华大学出版社，2008年6月：P45-67

[5].匡松，周永.百问白例Java语言程序设计[M].北京:中国铁道出版社，2009年1月：P99-146

[6].李文泽，郑逢斌，徐彬，沈夏炯.Java专家门诊[M].北京:清华大学出版社，2006年4月：P68-100

沈 阳 大 学

课程设计说明书

NO.9

import .*;

import .*;

import .*;

public class Chess extends JLabel

{

private String name;

//棋子名

private Color chessColor; //棋子颜色

private String player; //棋子所属方

public Chess(String name,String player,Color chessColor,int round)

{

=name;

=player;

olor=chessColor;

=round;

setBackground(); //设置背景色为白色

}

public void paint(Graphics g)

{

or(); //设置当前色

al(1,1,round-1,round-1); // 用当前色绘制椭圆边框

or();

al(1,1,round-1,round-1); //用当前色填充一个椭圆

or(chessColor); //设置当前色

t(new Font("隶书",,40)); //设置当前字体

ring(name,10,round-18); //绘制文本

}

public int getWidth()

{

return round;

}

public int getHeight()

{

return round;

}

public int getRound(){

return round;

private int round; //棋子直径

}

public String getName()

{

return name;

}

public Color getChessColor()

{

return chessColor;

}

public void setPlayer(String player)

{

=player;

}

public String getPlayer()

{

return player;

}

public static void main (String[] args) {

JFrame frame=new JFrame(); // TODO 自动生成方法存根

JPanel panel=new JPanel();

out(new GridLayout(1,1));

Chess chess=new Chess("车","red",,60);

(chess);

(panel);

e(100,100);

ible(true);

}

public static void main (String[] args) {

}

JFrame frame=new JFrame(); // TODO 自动生成方法存根

JPanel panel=new JPanel();

out(new GridLayout(1,1));

Chess chess=new Chess("帅","blue",,60);

(chess);

(panel);

e(100,100);

ible(true);

public class Point

{

int placeX; //X坐标值

int placeY; // Y坐标值

boolean hasChess=false; //是否有棋子

Chess chess=null;

public Point(int x,int y){

}

public int getPlaceX(){

}

public int getPlaceY(){

return placeY;

return placeX;

=x;

=y;

}

}

public void setHasChess(boolean hasChess){

}

ss=hasChess;

public boolean getHasChess(){

return hasChess;}

public void addChess(ChessBoard chessboard,Chess chess){

=chess;

hasChess=true;

nds(nd()/2,nd()/2,

nd(),nd()); //设置Chess的位置

}

}

seMotionListener(chessboard); //加入MouseMotionListener监听器

seListener(chessboard); //加入MouseListener

(chess); //棋盘中加入Chess

}

public Chess getChess(){

}

public void setChess(Chess chess){

=chess;

if(chess==null){

hasChess=false;

if(chess!=null){

}

return null;

return chess;

t(); //重绘棋盘

}else{

}

hasChess=true;

public void paintComponent(Graphics g){

}

public void drawBoard(Graphics g){

for(int i=0;i

{

ne(initX, i*interval+initY, (xPoint-1)*interval+initX, i*interval+initY);

}

ne(initX, initY, initX,(yPoint-1)*interval+initY ); //画最左侧的竖线

ne((xPoint-1)*interval+initX,initY,(xPoint-1)*interval+initX ,

(yPoint-1)*interval+initY); //画最右侧的竖线

for(int j=1;j

{

ne(j*interval+initX, initY, j*interval+initX, 4*interval+initY);

ne(j*interval+initX,5*interval+initY,j*interval+initX,(yPoint-1)*interval+initY);

}

ne(3*interval+initX, initY, 5*interval+initX,2*interval+initY );//画斜线

ne(3*interval+initY, 2*interval+initY,5*interval+initX, initY);

omponent(g);

drawBoard(g);

ne(3*interval+initX,(yPoint-1)*interval+initY,5*interval+initX,

(yPoint-3)*interval+initY);

ne(3*interval+initX,(yPoint-3)*interval+initY,5*interval+initX,

(yPoint-1)*interval+initY);

}

import ent;

public class ChessRule {

private Point startPoint;

private Point endPoint;

private int interval;

private int initX;

private int initY;

Point[][] choicePoint;

public ChessRule(Point startPoint,Point endPoint,int interval,int initX,int initY,Point[][] choicePoint){

}

private boolean isPoint(){

if(startPoint!=null&&endPoint!=null){

if(ss){

oint=startPoint;

nt=endPoint;

al=interval;

=initX;

=initY;

Point=choicePoint;

if(ss().getPlayer().equals(ss().getPlayer())){

}

private boolean checkRule(String name){

if(ceX()==ceX()||ceY()==ceY()){

}

if(("马")){

}

return false;

if(hasBlock(name)==0){

}

return true;

if(("车")){

}

return false;

}

return true;

}

return false;

if((ceX()-ceX())==2*interval&&(ceY()-ceY())==interval)

}

if((ceX()-ceX())==interval&&(ceY()-ceY())==2*interval)

}

if(("象")){

if(ss().getPlayer().equals("PlayerA")){

}

if(ss().getPlayer().equals("PlayerB")){

}

if(ceY()<5*interval+initY){

}

return false;

if(ceY()>4*interval+initY){

}

return false;

{

}

if(hasBlock(name)==0){

}

return true;

{

if(hasBlock(name)==0){

}

return true;

if((ceX()-ceX())==2*interval&&(ceY()-ceY())==2*interval){

if(hasBlock(name)==0){

}

}

}

return true;

if(("兵")){

if(ceY()

}

return false;

if(ceX()==ceX()&&(ceY()-ceY())==interval){

}

if(ceY()>4*interval+initY){return true;

if(ceY()==ceY()&&(ceX()-ceX())==interval){

}

if(("卒")){

if(ceY()>ceY()){

}return false;

}

}

return true;

if(ceX()==ceX()&&(ceY()-ceY())==interval){

}

if(ceY()<5*interval+initY){

return true;

if(ceY()==ceY()&&(ceX()-ceX())==interval){

return true;} } }

if(("士")){

if(ss().getPlayer().equals("PlayerA")){

}

if(ss().getPlayer().equals("PlayerB")){

}

if(ceX()<3*interval+initX||ceY()<7*interval+initY){

}

if(ceX()>5*interval+initX||ceY()<7*interval+initY){

}

return false;

return false;

if(ceX()<3*interval+initX||ceY()>2*interval+initY){

}

if(ceX()>5*interval+initX||ceY()>2*interval+initY){

}

return false;

return false;

if((ceX()-ceX())==interval&&(ceY()-ceY())==interval){

}

if(("将")){

if(ss().getPlayer().equals("PlayerA")){

if(ceX()<3*interval+initX||ceY()>2*interval+initY){

}

return false;

}

return true;

if(ceX()>5*interval+initX||ceY()>2*interval+initY){

}

}

return false;

if(ss().getPlayer().equals("PlayerB")){

}

if(ceX()<3*interval+initX||ceY()<7*interval+initY){

}

if(ceX()>5*interval+initX||ceY()<7*interval+initY){

}

return false;

return false;

if(ceX()==ceX()&&(ceY()-ceY())==interval){

}

return true;

if(ceY()==ceY()&&(ceX()-ceX())==interval){

if(ceX()==ceX()||ceY()==ceY()){

if(ss&&hasBlock(name)==1){

}

return true;

}

if(("炮")){

}

return true;

if(!ss&&hasBlock(name)==0){

}

}

return false;

}

return false;

}

return true;

private int hasBlock(String name){

int blocks=0;

int pointsX=(ceX()-ceX())/interval;

int pointsY=(ceY()-ceY())/interval;

int startX=(ceX()-initX)/interval;

int startY=(ceY()-initY)/interval;

//n("startX"+startX);

//n("startY"+startY);

int endX=(ceX()-initX)/interval;

int endY=(ceY()-initY)/interval;

n("endX"+endX);

n("endY"+endY);

n("pointsX"+pointsX);

n("pointsY"+pointsY);

if(("车")||("炮")){

if(pointsX==0){

if(endY>startY){

for(int i=1;i

if(choicePoint[startY+i][startX].hasChess){

}

if(pointsY==0){

}

}

blocks++;

}else{

}

for(int i=1;i

}

if(choicePoint[startY-i][startX].hasChess){

}

blocks++;

}

}

if(endX>startX){

for(int i=1;i

}

if(choicePoint[startY][startX+i].hasChess){

}

blocks++;

}else{

}

for(int i=1;i

}

if(choicePoint[startY][startX-i].hasChess){

}

blocks++;

if(("象")){

if(endXstartY){

}

if(endX

}

if(endX>startX&&endY>startY){

}

if(choicePoint[startY+1][startX+1].getHasChess()){

}

blocks=1;

if(choicePoint[startY-1][startX-1].getHasChess()){

}

blocks=1;

if(choicePoint[startY+1][startX-1].getHasChess()){

}

blocks=1;

}

}

if(endX>startX&&endY

}

if(choicePoint[startY-1][startX+1].getHasChess()){

}

blocks=1;

if(("马")){

if(pointsX==1){

if(endY>startY){

if(choicePoint[startY+1][startX].getHasChess()){

blocks=1;}

else{

}

n(""+blocks);

}

if(pointsX==2){

}

if(endX

if(choicePoint[startY][startX-1].getHasChess()){

}

blocks=1;

}

if(choicePoint[startY-1][startX].getHasChess()){

}

blocks=1;

}else{

}

if(choicePoint[startY][startX+1].getHasChess()){

}

blocks=1;

}

return blocks;

public boolean check(){

if(!isPoint()){

}

return checkRule(ss().getName());

//return false;}

return false;

public static void main(String[] args) {

}

import Event;

import Listener;

import .*;

public class ChessFrame extends JFrame implements ActionListener{

/**

* @param args

*/

private ChessBoard chessboard; //菜单条

private JMenuBar jMenuBar; //菜单项

private JMenu jMenu;

public ChessFrame(){

}

public void initComponents(){

jMenuBar=new JMenuBar(); //实例化菜单条

jMenu=createFileMenu(); //获得一个菜单项

(jMenu); //将菜单项加入菜单条

que(true); //菜单条设为不透明

super("中国象棋");

initComponents();

}

// TODO 自动生成方法存根

setJMenuBar(jMenuBar); //在容器中加入菜单条

chessboard=new ChessBoard(); //实例化象棋图形界面

}

getContentPane().add(chessboard); //加入象棋界面

setSize(700,700); //设置窗口大小

setVisible(true); //设置窗口可见

private JMenu createFileMenu(){

}

public static void main(String[] args) {

// TODO 自动生成方法存根

JMenu chessMenu=new JMenu("Chess"); //实例化菜单项

JMenuItem newGame=new JMenuItem("New"); //实例化菜单项选项

ionListener(this); //加入ActionListenter监听

(newGame); //将选项加入菜单项

JMenuItem exit=new JMenuItem("Exit");

ionListener(this);

(exit);

return chessMenu;

new ChessFrame();

}

public void actionPerformed(ActionEvent e) {

// TODO 自动生成方法存根

if(ionCommand().equals("Exit")){ //如果选择了“Exit”选项

(0); //退出

}

if(ionCommand().equals("New")){ //如果选择了“New”选项

(chessboard); //窗口删除原象棋界面

chessboard=new ChessBoard(); //实例化新的象棋界面

(chessboard); //加入窗口

}}}

te(); //刷新窗口

沈 阳 大 学

课程设计说明书

NO.10

沈 阳 大 学

课程设计说明书

NO.11

沈 阳 大 学

课程设计说明书

NO.12

沈 阳 大 学

课程设计说明书

NO.13

沈 阳 大 学

课程设计说明书

NO.14

沈 阳 大 学

课程设计说明书

NO.15

沈 阳 大 学

课程设计说明书

NO.16

沈 阳 大 学

课程设计说明书

NO.17

沈 阳 大 学

课程设计说明书

NO.18

沈 阳 大 学

课程设计说明书

NO.19

沈 阳 大 学

课程设计说明书

NO.20

沈 阳 大 学

课程设计说明书

NO.21

沈 阳 大 学

课程设计说明书

NO.22

沈 阳 大 学

课程设计说明书

NO.23

沈 阳 大 学

课程设计说明书

NO.24

沈 阳 大 学

课程设计说明书

NO.25

沈 阳 大 学