中国象棋打谱系统-Java语言毕业设计(内附详细Java程序)

JAVA语言课程设计设计题目：中国象棋打谱系统
目录
JA V A语言课程设计
目录
1 设计 (1)
1.1 设计内容 (1)
1.2 设计要求 (1)
1.3 总体设计 (2)
2 具体设计 (3)
2.1运行效果和程序设计 (3)
2.2 主类Chess (5)
2.3对弈棋盘ChessBoard (9)
2.4 棋子ChesePiece (19)
2.5棋点ChessPoint (21)
2.6 走棋规则Rule (23)
2.7步骤MoveStep………………………………………….2
3.
2.8记录棋谱MakeChessManual…………………………..24.
2.9棋谱演示Demon (24)
3课程总结 (25)
1.1 设计内容
中国象棋打谱系统使用户能够将对弈过程保存成文件，并能够重新演示对弈过程，即复盘。

1.2 设计要求
1．中国象棋是双方在由9条和10条横线分割而成的棋盘对弈。

竖线与横线的交叉点称做棋点，每个棋子都放置在棋点上，而不是方格中。

河界将棋盘分为两个等分=份，没一边都有一个由9个点组成的区域“将”，“帅”，“士”只能在“九宫”内移动，并且“将”，“帅”，的每一步只可以水平或垂直移动一个棋点。

士：“士”只能在“九宫”内移动，并且每一步只可以沿对角线方向移动一个棋点。

象；一步必须沿对角线方向走两个棋点。

但它既不能过河，也不能跳过或穿越障碍，即象征走的过程不能被“别眼”。

马：每一步只可以水平或垂直移动一个棋点。

但它必须沿对角线方向，向左或向右移动，中国象棋的马不能跳过障碍，即在走的过程不能被“别腿”。

车：可以沿水平或垂直方向移动任意个无障碍的点。

炮：行走规则和车很类似，但它必须跳过一个棋子来吃掉对方的一个棋子。

被跳过的棋子被称为桥或者屏风。

兵：过河前每步只能向前移动一个棋点。

过河后，它便增加了向左右移动的能力。

并不允许向后移动。

2．单击“中国象棋”菜单可以选择“制作棋谱”，“保存棋谱”和“演示棋谱”菜单项。

3．选择“制作棋谱”，将出现相应的棋盘，该棋盘可进行实战对弈，可以随时选择“保存棋谱”，将对弈过程保存成一个棋谱文件。

选择“演示棋谱”将显示打开文件对话框供用户选择以保存的棋谱文件。

选择棋谱文件后，将显示用来演示棋谱的棋盘，用户可以选择自动或者手动来演示对弈过程。

1.3 总体设计
中国象棋打谱系统共有8个Java源文件。

重要之间的关系如下图；
图1.1 类之间的关系
Chess.Java
该Java文件生成的类负责创建程序的主窗口。

该类含有main方法，程序从该类开始执行。

ChessBoard.java
该文件生成的类负责创建“对弈棋盘”,用户可以用鼠标拖动棋盘上的棋子，当松开鼠标是则将棋子放在棋点。

该棋盘不允许用户将棋子拖放到非棋点上。

棋盘上的rule对象负责判断走棋是否遵守了中国象棋的规则，例如“马”走日，“象”走田，“小卒”一去不回头等等。

如果用户的走法不符合规则，棋子将被放回原处，重新走着。

棋盘的MakeChessManual对象负责记录棋谱，当用户选择“保存棋谱”菜单项时，可以将当前棋谱保存成文件。

另外，该棋盘还能进行悔棋，悔棋将不被记录到棋谱。

Chesspoint.Java
该文件生成的类负责创建棋点对象。

棋点对象可以判断该棋点上是否有棋子，指定当前棋点上的棋子，获取当前棋点上的棋子，移动当前棋点上的棋子。

ChessPiece.java
该文件生成的类负责创建棋子对象。

并绘制棋子的外观。

棋子对象可以获取本身的颜色，大小，名字，也可以设置和获取本身的类别，即红棋和黑棋。

MakeChessManual,java
该文件生成的类负责创建记录棋谱的对象，该对象可以将棋谱记录到一个链接表中，并在一个文本区显示棋谱。

当对弈者悔棋时，该对象将修改棋谱，并更新文本区域的信息。

Ruler.java
该文件生成的类负责创建“走棋规则”对象，该对象负责用户用户的走法是否符合规则。

Demon.java
该文件生成的类负责创建“棋谱演示”对象，该对象可以演示以保存的棋谱。

MoveStep.java
该类创建的对象记录一个棋步。

2 具体设计
2.1运行效果和程序设计
1.将8个Java文件保存到一个文件夹中，例如C\chese。

将8个Java文件分别编译生成相应的字节码（class）文件。

然后用Java解释器运行主类：
C:\chess\java Chess
效果如图2.1、2.2所示。

图1
图2.11棋谱的制作
图2.12棋谱对弈和保存
2.可以使用jar.exe把一些文件夹压缩成JAR文件，来发布我们的应用程序。

我们可以把本Java应用程序中涉及到的类压缩成一个JAR文件，例如：Chese.jar。

首先，用文本编辑器（例如Windows下的记事本）编写一个清单文件（Manifestfiles）：
Manifest-Version：1.0
Main-Class：Chess
Created-By：1.2.2(Sun Microsystems Inc.)
例如，清单文件命名为moon.mf，保存到C:\Class。

然后，如下生成JAR文件：
c:\chess\jar cfm chess.jar moon.mf*.class
其中，参数c表示要生成一个新的JAR文件；f表示要生成的JAR文件的名字；m表示文件清单文件的名字。

现在就可以将Chess.jar拷贝到任何一个安装了java运行环境（版本号需高于1.2.2）的计算机上，只要用鼠标双击该文件就可以运行本java应用程序了。

另外创建一个帮助文件help.txt,内容如下：
您可以用鼠标双击Chess.jar或Chess.bat来运行本程序，但是，如果您的
计算机上安装了中文版WinRAR解压压缩软件，并将jar文件与该解压缩软件
做了关联，那么，用鼠标双击Chess.jar文件夹时，WinRAR 解压缩软件会自
动运行进行解压缩操作，这时您可以双击Chess.bat来运行本程序。

最后，将.bat文件、.jar文件、帮助文件一同发布。

2.2 主类Chess
1.成员变量（见表11.1）
表11.1 主要成员变量（属性）
成员变量描述变量类型名称
菜单条JMenuBar bar
菜单JMenuItem fileMenu
菜单项JMenuBar 制作棋谱，保存棋谱，演示棋谱对弈的棋盘ChessBoard board
演示棋谱的棋盘Demon demon
棋谱记录者MakeChessManual record
保存棋谱的链表LinkedList 棋谱
2.方法（见表11.2）
表11.2 主要方法
名称功能备注
Chess 创建程序主窗口构造方法actionPerformed 处理ActionEvent事件接口方法
main 程序开始运行
3.代码
Chess.java
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.LinkedList;
import 中国象棋打谱系统.ChessBoard;
import 中国象棋打谱系统.Demon;
import 中国象棋打谱系统.MakeChessManual;
public class Chess extends JFrame implements ActionListener {
ChessBoard board=null;
Demon demon=null;
MakeChessManual record=null;
Container con=null;
JMenuBar bar;
JMenu fileMenu;
JMenuItem 制作棋谱,保存棋谱,演示棋谱;
JFileChooser fileChooser=null;
LinkedList 棋谱=null;
public Chess()
{
bar=new JMenuBar();
fileMenu=new JMenu("李东亚的课程设计之中国象棋");
制作棋谱=new JMenuItem("制作棋谱");
保存棋谱=new JMenuItem("保存棋谱");
演示棋谱=new JMenuItem("演示棋谱");
fileMenu.add(制作棋谱);
fileMenu.add(保存棋谱);
fileMenu.add(演示棋谱);
bar.add(fileMenu);
setJMenuBar(bar);
setTitle(制作棋谱.getText());
制作棋谱.addActionListener(this);
保存棋谱.addActionListener(this);
演示棋谱.addActionListener(this);
board=new ChessBoard(45,45,9,10);
record=board.record;
con=getContentPane();
JSplitPane split=new
JSplitPane(JSplitPane.HORIZONTAL_SPLIT,true,board,record); split.setDividerSize(5);
split.setDividerLocation(460);
con.add(split,BorderLayout.CENTER);
addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e) { System.exit(0);
}
});
setVisible(true);
setBounds(60,20,670,540);
fileChooser=new JFileChooser();
con.validate();
validate();
}
public void actionPerformed(ActionEvent e)
{
if(e.getSource()==制作棋谱)
{
con.removeAll();
保存棋谱.setEnabled(true);
this.setTitle(制作棋谱.getText());
board=new ChessBoard(45,45,9,10);
record=board.record;
JSplitPane split=new
JSplitPane(JSplitPane.HORIZONTAL_SPLIT,true,board,record);
split.setDividerSize(5);
split.setDividerLocation(460);
con.add(split,BorderLayout.CENTER);
validate();
}
if(e.getSource()==保存棋谱)
{
int state=fileChooser.showSaveDialog(null);
File saveFile =fileChooser.getSelectedFile();
if(saveFile!=null&&state==JFileChooser.APPROVE_OPTION) {try
{
FileOutputStream outOne=new FileOutputStream(saveFile);
ObjectOutputStream outTwo=new ObjectOutputStream(outOne);
outTwo.writeObject(record.获取棋谱()) ;
outOne.close();
outTwo.close();
}
catch(IOException event)
{
}
}
}
if(e.getSource()==演示棋谱)
{
con.removeAll();
con.repaint();
con.validate();
validate();
保存棋谱.setEnabled(false);
int state=fileChooser.showOpenDialog(null);
File openFile =fileChooser.getSelectedFile();
if(openFile!=null&&state==JFileChooser.APPROVE_OPTION)
{try
{
FileInputStream inOne=new
FileInputStream(openFile);
ObjectInputStream inTwo=new
ObjectInputStream(inOne);
棋谱=(LinkedList)inTwo.readObject() ;
inOne.close();
inTwo.close();
ChessBoard board=new ChessBoard(45,45,9,10);
demon=new Demon(board);
demon.set棋谱(棋谱);
con.add(demon,BorderLayout.CENTER);
con.validate();
validate();
this.setTitle(演示棋谱.getText()+":"+openFile); }
catch(Exception event)
{
JLabel label=new JLabel("不是棋谱文件");
label.setFont(new Font("隶书",Font.BOLD,60)); label.setForeground(Color.red);
label.setHorizontalAlignment(SwingConstants.CENTER);
con.add(label,BorderLayout.CENTER);
con.validate();
this.setTitle("没有打开棋谱");
validate();
}
}
else
{
JLabel label=new JLabel("没有打开棋谱文件呢");
label.setFont(new Font("隶书",Font.BOLD,50));
label.setForeground(Color.pink);
label.setHorizontalAlignment(SwingConstants.CENTER);
con.add(label,BorderLayout.CENTER);
con.validate();
this.setTitle("没有打开棋谱文件呢");
validate();
}
}
}
public static void main(String args[])
{
new Chess();
}
}
2.3对弈棋盘ChessBoard
1.成员变量（见表11.3）
表11.3 主要成员变量（属性）
描述变量类型名称
棋点数组ChessPoint[][] point
棋点的水平和垂直距离int UnitWidth,unit Height 棋盘的行数和列数int X轴长，y轴长
棋子颜色String 红方颜色、黑方颜色棋子对象ChessPiece 红车1……黑炮2
走棋规则对象Rule rule
负责记录棋谱的对象MakeChessManual record
2.方法（见表11.4）
表11.4 主要方法
名称功能备注
ChessBoard 创建对弈棋盘构造方法paintComponent 绘制棋盘
mousePressed 返回棋子接口方法mouseMoved 无接口方法mouseDragged 拖动棋子移动接口方法mouseReleased 将棋子放到棋点接口方法mouseEntered 无接口方法mouseExited 无接口方法mouseClicked 无接口方法
3.代码
chessboard.java
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class ChessBoard extends JPanel implements MouseListener,MouseMotionListener
{
public ChessPoint point[][];
public int unitWidth,unitHeight;
int x轴长,y轴长; int x,y;
boolean move=false;
public String 红方颜色="红色",黑方颜色="黑色";
ChessPiece 红车1,红车2,红马1,红马2,红相1,红相2,红帅,红士1,红士2,
红兵1,红兵2,红兵3,红兵4,红兵5,红炮1,红炮2;
ChessPiece 黑车1,黑车2,黑马1,黑马2,黑将,黑士1,黑士2,
黑卒1,黑卒2,黑卒3,黑卒4,黑卒5,黑象1,黑象2,黑炮1,黑炮2;
int startX,startY;
int startI,startJ;
public boolean 红方走棋=true,黑方走棋=false;
Rule rule=null;
public MakeChessManual record=null;
public ChessBoard(int w,int h,int r,int c)
{
setLayout(null);
addMouseListener(this);
addMouseMotionListener(this);
Color bc=getBackground();
unitWidth=w;
unitHeight=h;
x轴长=r;
y轴长=c;
point=new ChessPoint[r+1][c+1];
for(int i=1;i<=r;i++)
{
for(int j=1;j<=c;j++)
{
point[i][j]=new
ChessPoint(i*unitWidth,j*unitHeight,false);
}
}
rule=new Rule(this,point);
record=new MakeChessManual(this,point) ;
红车1=new ChessPiece("车",Color.red,bc,w-4,h-4,this);
红车1.set棋子类别(红方颜色);
红车2=new ChessPiece("车",Color.red,bc,w-4,h-4,this);
红车2.set棋子类别(红方颜色);
红马1=new ChessPiece("马",Color.red,bc,w-4,h-4,this);
红马1.set棋子类别(红方颜色);
红马2=new ChessPiece("马",Color.red,bc,w-4,h-4,this);
红马2.set棋子类别(红方颜色);
红炮1=new ChessPiece("炮",Color.red,bc,w-4,h-4,this);
红炮1.set棋子类别(红方颜色);
红炮2=new ChessPiece("炮",Color.red,bc,w-4,h-4,this);
红炮2.set棋子类别(红方颜色);
红相1=new ChessPiece("相",Color.red,bc,w-4,h-4,this);
红相1.set棋子类别(红方颜色);
红相2=new ChessPiece("相",Color.red,bc,w-4,h-4,this);
红相2.set棋子类别(红方颜色);
红士1=new ChessPiece("士",Color.red,bc,w-4,h-4,this);
红士1.set棋子类别(红方颜色);
红士2=new ChessPiece("士",Color.red,bc,w-4,h-4,this);
红士2.set棋子类别(红方颜色);
红帅=new ChessPiece("帅",Color.red,bc,w-4,h-4,this);
红帅.set棋子类别(红方颜色);
红兵1=new ChessPiece("兵",Color.red,bc,w-4,h-4,this);
红兵1.set棋子类别(红方颜色);
红兵2=new ChessPiece("兵",Color.red,bc,w-4,h-4,this);
红兵2.set棋子类别(红方颜色);
红兵3=new ChessPiece("兵",Color.red,bc,w-4,h-4,this);
红兵3.set棋子类别(红方颜色);
红兵4=new ChessPiece("兵",Color.red,bc,w-4,h-4,this);
红兵4.set棋子类别(红方颜色);
红兵5=new ChessPiece("兵",Color.red,bc,w-4,h-4,this);
红兵5.set棋子类别(红方颜色);
黑将=new ChessPiece("将",Color.blue,bc,w-4,h-4,this);
黑将.set棋子类别(黑方颜色);
黑士1=new ChessPiece("士",Color.blue,bc,w-4,h-4,this);
黑士1.set棋子类别(黑方颜色);
黑士2=new ChessPiece("士",Color.blue,bc,w-4,h-4,this);
黑士2.set棋子类别(黑方颜色);
黑车1=new ChessPiece("车",Color.blue,bc,w-4,h-4,this);
黑车1.set棋子类别(黑方颜色);
黑车2=new ChessPiece("车",Color.blue,bc,w-4,h-4,this);
黑车2.set棋子类别(黑方颜色);
黑炮1=new ChessPiece("炮",Color.blue,bc,w-4,h-4,this);
黑炮1.set棋子类别(黑方颜色);
黑炮2=new ChessPiece("炮",Color.blue,bc,w-4,h-4,this);
黑炮2.set棋子类别(黑方颜色);
黑象1=new ChessPiece("象",Color.blue,bc,w-4,h-4,this);
黑象1.set棋子类别(黑方颜色);
黑象2=new ChessPiece("象",Color.blue,bc,w-4,h-4,this);
黑象2.set棋子类别(黑方颜色);
黑马1=new ChessPiece("马",Color.blue,bc,w-4,h-4,this);
黑马1.set棋子类别(黑方颜色);
黑马2=new ChessPiece("马",Color.blue,bc,w-4,h-4,this);
黑马2.set棋子类别(黑方颜色);
黑卒1=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
黑卒1.set棋子类别(黑方颜色);
黑卒2=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
黑卒2.set棋子类别(黑方颜色);
黑卒3=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
黑卒3.set棋子类别(黑方颜色);
黑卒4=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
黑卒4.set棋子类别(黑方颜色);
黑卒5=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
黑卒5.set棋子类别(黑方颜色);
point[1][10].setPiece(红车1,this);
point[2][10].setPiece(红马1,this);
point[3][10].setPiece(红相1,this);
point[4][10].setPiece(红士1,this);
point[5][10].setPiece(红帅,this);
point[6][10].setPiece(红士2,this);
point[7][10].setPiece(红相2,this);
point[8][10].setPiece(红马2,this);
point[9][10].setPiece(红车2,this);
point[2][8].setPiece(红炮1,this);
point[8][8].setPiece(红炮2,this);
point[1][7].setPiece(红兵1,this);
point[3][7].setPiece(红兵2,this);
point[5][7].setPiece(红兵3,this);
point[7][7].setPiece(红兵4,this);
point[9][7].setPiece(红兵5,this);
point[1][1].setPiece(黑车1,this);
point[2][1].setPiece(黑马1,this);
point[3][1].setPiece(黑象1,this);
point[4][1].setPiece(黑士1,this);
point[5][1].setPiece(黑将,this);
point[6][1].setPiece(黑士2,this);
point[7][1].setPiece(黑象2,this);
point[8][1].setPiece(黑马2,this);
point[9][1].setPiece(黑车2,this);
point[2][3].setPiece(黑炮1,this);
point[8][3].setPiece(黑炮2,this);
point[1][4].setPiece(黑卒1,this);
point[3][4].setPiece(黑卒2,this);
point[5][4].setPiece(黑卒3,this);
point[7][4].setPiece(黑卒4,this);
point[9][4].setPiece(黑卒5,this);
}
public void paintComponent(Graphics g)
{
super.paintComponent(g);
for(int j=1;j<=y轴长;j++)
{
g.drawLine(point[1][j].x,point[1][j].y,point[x轴
长][j].x,point[x轴长][j].y);
}
for(int i=1;i<=x轴长;i++)
{
if(i!=1&&i!=x轴长)
{
g.drawLine(point[i][1].x,point[i][1].y,point[i][y轴长-5].x,point[i][y轴长-5].y);
g.drawLine(point[i][y轴长-4].x,point[i][y轴长
-4].y,point[i][y轴长].x,point[i][y轴长].y);
}
else
{
g.drawLine(point[i][1].x,point[i][1].y,point[i][y轴长].x,point[i][y轴长].y);
}
}
g.drawLine(point[4][1].x,point[4][1].y,point[6][3].x,point[6][3].y);
g.drawLine(point[6][1].x,point[6][1].y,point[4][3].x,point[4][3].y);
g.drawLine(point[4][8].x,point[4][8].y,point[6][y轴
长].x,point[6][y轴长].y);
g.drawLine(point[4][y轴长].x,point[4][y轴
长].y,point[6][8].x,point[6][8].y);
for(int i=1;i<=x轴长;i++)
{
g.drawString(""+i,i*unitWidth,unitHeight/2);
}
int j=1;
for(char c='A';c<='J';c++)
{
g.drawString(""+c,unitWidth/4,j*unitHeight);
j++;
}
}
public void mousePressed(MouseEvent e)
{
ChessPiece piece=null;
Rectangle rect=null;
if(e.getSource()==this)
move=false;
if(move==false)
if(e.getSource() instanceof ChessPiece)
{
piece=(ChessPiece)e.getSource();
startX=piece.getBounds().x;
startY=piece.getBounds().y;
rect=piece.getBounds();
for(int i=1;i<=x轴长;i++)
{
for(int j=1;j<=y轴长;j++)
{
int x=point[i][j].getX();
int y=point[i][j].getY();
if(rect.contains(x,y))
{
startI=i;
startJ=j;
break;
}
}
}
}
}
public void mouseMoved(MouseEvent e)
{
}
public void mouseDragged(MouseEvent e)
{
ChessPiece piece=null;
if(e.getSource() instanceof ChessPiece)
{
piece=(ChessPiece)e.getSource();
move=true;
e=SwingUtilities.convertMouseEvent(piece,e,this); }
if(e.getSource()==this)
{
if(move&&piece!=null)
{
x=e.getX();
y=e.getY();
if(红方走棋&&((piece.棋子类别()).equals(红方颜色))) {
piece.setLocation(x-piece.getWidth()/2,y-piece.getHeight()/2);
}
if(黑方走棋&&(piece.棋子类别().equals(黑方颜色))) {
piece.setLocation(x-piece.getWidth()/2,y-piece.getHeight()/2);
}
}
}
}
public void mouseReleased(MouseEvent e)
{
ChessPiece piece=null;
move=false;
Rectangle rect=null;
if(e.getSource() instanceof ChessPiece)
{
piece=(ChessPiece)e.getSource();
rect=piece.getBounds();
e=SwingUtilities.convertMouseEvent(piece,e,this); }
if(e.getSource()==this)
{
boolean containChessPoint=false;
int x=0,y=0;
int m=0,n=0;
if(piece!=null)
{
for(int i=1;i<=x轴长;i++)
{
for(int j=1;j<=y轴长;j++)
{
x=point[i][j].getX();
y=point[i][j].getY();
if(rect.contains(x,y))
{
containChessPoint=true;
m=i;
n=j;
break;
}
}
}
}
if(piece!=null&&containChessPoint)
{
Color pieceColor=piece.获取棋子颜色();
if(point[m][n].isPiece())
{
Color c=(point[m][n].getPiece()).获取棋子颜色();
if(pieceColor.getRGB()==c.getRGB())
{
piece.setLocation(startX,startY);
(point[startI][startJ]).set有棋子(true);
}
else
{
boolean
ok=rule.movePieceRule(piece,startI,startJ, m,n);
if(ok)
{
ChessPiece
pieceRemoved=point[m][n].getPiece();
point[m][n].reMovePiece(pieceRemoved,this);
point[m][n].setPiece(piece,this);
(point[startI][startJ]).set有棋子
(false);
record.记录棋谱
(piece,startI,startJ,m,n) ;
record.记录吃掉的棋子(pieceRemoved) ; if(piece.棋子类别().equals(红方颜色))
{
红方走棋=false;
黑方走棋=true;
}
if(piece.棋子类别().equals(黑方颜色))
{
黑方走棋=false;
红方走棋=true;
}
validate();
repaint();
}
else
{
piece.setLocation(startX,startY);
(point[startI][startJ]).set有棋子
(true);
}
}
}
else
{
boolean ok=rule.movePieceRule(piece,startI,startJ, m,n);
if(ok)
{
point[m][n].setPiece(piece,this);
(point[startI][startJ]).set有棋子(false);
record.记录棋谱(piece,startI,startJ,m,n) ;
record.记录吃掉的棋子("没吃棋子");
if(piece.棋子类别().equals(红方颜色))
{
红方走棋=false;
黑方走棋=true;
}
if(piece.棋子类别().equals(黑方颜色))
{
黑方走棋=false;
红方走棋=true;
}
}
else
{
piece.setLocation(startX,startY);
(point[startI][startJ]).set有棋子(true);
}
}
}
if(piece!=null&&!containChessPoint)
{
piece.setLocation(startX,startY);
(point[startI][startJ]).set有棋子(true);
}
}
}
public void mouseEntered(MouseEvent e)
{
}
public void mouseExited(MouseEvent e)
{
}
public void mouseClicked(MouseEvent e)
{
}
}
2.4 棋子ChesePiece
1.成员变量（见表11.5）
表11.5 主要成员变量（属性）
描述变量类型名称
棋子的名字String name
棋子的背景色（和棋盘颜色一致）Color backColor 棋子的前景色（作为棋子的颜色）Color foreColor 颜色的类别（黑方、红方）String颜色类别2.方法（见表11.6）
名称功能备注
ChesePiece 创建棋子对象构造方法paint 绘制棋子的外观
getWidth 获取棋子的宽度
getHeigt 获取棋子的高度
getName 获取棋子的名字
获取棋子颜色获取棋子的颜色
Set棋子类别设置棋子的类别
棋子类别获取棋子的类别
3.代码
ChessPiece.java
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class ChessPiece extends JLabel
{
String name;
Color backColor=null,foreColor;
String 颜色类别=null;
ChessBoard board=null;
int width,height;
public ChessPiece(String name,Color fc,Color bc,int width,int height,ChessBoard board)
{
=name;
this.board=board;
this.width=width;
this.height=height;
foreColor=fc;
backColor=bc;
setSize(width,height);
setBackground(bc);
addMouseMotionListener(board);
addMouseListener(board);
}
public void paint(Graphics g)
{
g.setColor(foreColor);
g.fillOval(2,2,width-2,height-2);
g.setColor(Color.white);
g.setFont(new Font("隶书",Font.BOLD,28));
g.drawString(name,7,height-8);
g.setColor(Color.yellow);
g.drawOval(2,2,width-2,height-2);
}
public int getWidth()
{
return width;
}
public int getHeight()
{
return height;
}
public String getName()
{
return name;
}
public Color 获取棋子颜色()
{
return foreColor;
}
public void set棋子类别(String 类别)
{
颜色类别=类别;
}
public String 棋子类别()
{
return 颜色类别;
}
}
2.5棋点ChessPoint
1．成员变量（见表11.7）
表11.7 主要成员变量（属性）
描述变量类型名称
棋点的位置坐标Int X, y 棋点上是否有棋子Booean 有棋子2.方法（见表11.8）
表11.8 主要方法
名称功能备注Chesspoint 创建棋点对象构造方法ispiece 判断棋点是否有棋子
set有棋子设置棋点上是否有棋子
setpiece 在棋点上放置棋子
getpiece 获取棋点上的棋子
removepiece 移掉棋点上的棋子
3．代码
Chesspoint.java
public class ChessPoint
{
int x,y;
boolean 有棋子;
ChessPiece piece=null;
ChessBoard board=null;
public ChessPoint(int x,int y,boolean boo)
{
this.x=x;
this.y=y;
有棋子=boo;
}
public boolean isPiece()
{
return 有棋子;
}
public void set有棋子(boolean boo)
{
有棋子=boo;
}
public int getX()
{
return x;
}
public int getY()
{
return y;
}
public void setPiece(ChessPiece piece,ChessBoard board)
{
this.board=board;
this.piece=piece;
board.add(piece);
int w=(board.unitWidth);
int h=(board.unitHeight);
piece.setBounds(x-w/2,y-h/2,w,h);
有棋子=true;
board.validate();
}
public ChessPiece getPiece()
{
return piece;
}
public void reMovePiece(ChessPiece piece,ChessBoard board) {
this.board=board;
this.piece=piece;
board.remove(piece);
board.validate();
有棋子=false;
}
}
2．6 走棋规则Rule
1.成员变量（见表11.9）
表11.9主要成员变量（属性）
描述变量类型名称
走着棋子的起始棋点int startI, startJ 走着棋子的终止棋点int endI, endJ
2.方法（见表11.10）
表11.10 主要方法
名称功能备注
Rule 创建走棋规则对象构造方法movepieceRule 判断走棋规则
2.7步骤MoveStep
代码MoveStep.java
import java.awt.Point;
public class MoveStep implements java.io.Serializable
{
public Point pStart,pEnd;
public MoveStep(Point p1,Point p2)
{
pStart=p1;
pEnd=p2;
}
}
2.8记录棋谱MakeChessManual
1.成员变量（见表11.11）
表11.11主要成员变量（属性）
描述变量类型名称
显示棋盘的文本区JTextArea text
激励棋谱列表LinkedList 棋谱
记录吃掉的棋子的列表，备悔棋用LinkedList 吃掉的棋子
2.方法（见表11.12）
表11.12主要方法
名称功能备注MakeChessManual 创建“记录棋谱”对象构造方法记录棋谱记录棋谱
actionperformed 处理Actionevent事件，悔棋接口方法3代码（略）
2.9棋谱演示Demon
1.成员变量（11.13）
11.13主要成员变量（属性）
描述变量类型名称
保存棋谱的链表LinkedList 棋谱
自动演示棋谱的线程Thread 自动演示用户输入的时间间隔JTextField 时间间隔
按顺序手动演示JButton next
重新演示JButton replay
开始自动演示JButton auto
暂停或继续自动演示JButton stop
2.方法（见表11.14）
表11.14 主要方法
名称功能备注
Demon 创建棋谱演示对象构造方法
Set棋谱设置棋谱
actionperformed 处理Actionevent事件接口方法
3.代码（略）
3.课程设计总结
通过对java的了解与掌握，可以把java与游戏灵活的结合在一起，编程jar 形式，可以进行运行，要了解其中的主类与方法，明白函数的调用和一些简单的构造方法。

中国象棋打谱系统，含有7个java程序，主要是通过构造与创建对象来完成的，里面有许多变量设置，并且把我们学的线程联系到了一起，整体显得很自然，结构得当，内容丰富。

（感谢）
很感谢我们的java老师，我感觉他就是个java大师，好厉害，他改程序好快，根本就不整体看，只是找错误，并且能够很快改过了，佩服!我们的陈老师讲解认真，并且容易接触，很能打成一片，可谓师中典范！我对java也很感兴趣，就是学着有点困难，有这么好的老师，我是对自己学好java很有信心的，老师您说的那句话我记得很清楚，“以后你们都是靠java吃饭的”,所以我一定会学好java的。

参考文献《Java课程设计》主编：耿祥义。