> 
 > 
 > 
如何用Java实现网络中国象棋室（一）
摘要：导读:Java语言的简洁和完美,以及java网络功能的优越性是每个java体验者所体会的感受。笔者在闲暇之余,开发出网络中国象棋(以下简称象棋)程序,在此愿与广大java编程爱好者共享,做以介绍供大家参考。如有问题可与我联系:网络象棋程序主要功能有象棋室(多象棋桌)功能、观棋功能、悔棋功能、下棋聊天功能、调取残局文件对弈功能、方便的人性化图形界面操作等功能。由象棋服务和客户端Applet组成,Applet实现象棋室的显示,象棋桌的显示和走步判断以及用户的一些操作如悔棋、认输等
Java语言的简洁和完美,以及java网络功能的优越性是每个java体验者所体会的感受。笔者在闲暇之余,开发出网络中国象棋(以下简称象棋)程序,在此愿与广大java编程爱好者共享,做以介绍供大家参考。如有问题可与我联系:
网络象棋程序主要功能有象棋室(多象棋桌)功能、观棋功能、悔棋功能、下棋聊天功能、调取残局文件对弈功能、方便的人性化图形界面操作等功能。由象棋服务和客户端Applet组成,Applet实现象棋室的显示,象棋桌的显示和走步判断以及用户的一些操作如悔棋、认输等功能的实现。为考虑资源使用情况和界面美观,象棋桌采用使用高效和优化的双缓冲图形界面处理技术,使用户操作更舒适,更方便。以下依次详细介绍象棋服务和客户端的实现过程。
首先介绍象棋服务,它是运行在服务器端的用于处理和转发用户登录到象棋室,进入离开游戏桌,走棋,悔棋,认输,退出等等应用。
1、登录处理:
//////////////////定义登录连接处理类
package sunstudio.chess.
import java.util.*;
import java.net.*;
import java.io.*;
import sunstudio.util.*;
import sunstudio.*;
public class ChessLogin implements Runnable{
ServerSocket ss=
boolean isrunning=
Vector listeners=new Vector();
int guestid=0;
public ChessLogin(ChessServer s){
addLoginListener(s);
new Thread(this).start();
public void run(){
while(isrunning){
Socket socket=ss.accept();
String un=chkLogin(socket.getInputStream());
if(un!=null)notifyListener(guestid++,un,socket);
}catch(IOException e){}
public void addLoginListener(LoginListener l){
listeners.addElement(l);
void notifyListener(int userid,String username,Socket sock){
LoginEvent evt=new LoginEvent(userid,username,sock);
for(Enumeration enu=listeners.elements();enu.hasMoreElements();){
((LoginListener)enu.nextElement()).onLoginEvent(evt);
public String chkLogin(InputStream is)throws IOException{
byte[] head=new byte[12];
HttpInputStream.readBytes(is,12,head);
int cmdtype=head[0];
int totalsize=Convert.byteToShort(head[1],head[2]);
if(totalsize==0)
byte[] data=new byte[totalsize];
HttpInputStream.readBytes(is,totalsize,data);
//System.out.print(&type=&+cmdtype+&,totalsize=&+totalsize+&,username=&+parseLoginData(data));
return parseLoginData(data);
public String parseLoginData(byte[] d){
return new String(d);
public static int byteToInt(byte j,byte k,byte m,byte n){
int a =j&;0
int b =k&;0
int c =m&;0
int d =n&;0
return (d }
//////////////////定义登录连接事件类
package sunstudio.chess.
import java.net.*;
public class LoginEvent{
public int userID;
public LoginEvent(int userID,String username,Socket sock){
this.userID=userID;
this.username=
this.socket=
//////////////////登录监听接口
package sunstudio.chess.
public interface LoginListener{
public void onLoginEvent(LoginEvent evt);
(待续......)
Java语言的简洁和完美,以及java网络功能的优越性是每个java体验者所体会的感受。笔者在闲暇之余,开发出网络中国象棋(以下简称象棋)程序,在此愿与广大java编程爱好者共享,做以介绍供大家参考。如有问题可与我联系:网络象棋程序主要功能有象棋室(多象棋桌)功能、观棋功能、悔棋功能、下棋聊天功能、调取残局文件对弈功能、方便的人性化图形界面操作等功能。由象棋服务和客户端Applet组成,Applet实现象棋室的显示,象棋桌的显示和走步判断以及用户的一些操作如悔棋、认输等功能的实现。为考虑资源使用情况和界面美观,象棋桌采用使用高效和优化的双缓冲图形界面处理技术,使用户操作更舒适,更方便。以下依次详细介绍象棋服务和客户端的实现过程。 首先介绍象棋服务,它是运行在服务器端的用于处理和转发用户登录到象棋室,进入离开游戏桌,走棋,悔棋,认输,退出等等应用。 1、登录处理://////////////////定义登录连接处理类 package sunstudio.chess. import java.util.*; import java.net.*; import java.io.*; import sunstudio.util.*; import sunstudio.*; public class ChessLogin implements Runnable{ ServerSocket ss= boolean isrunning= Vector listeners=new Vector(); int guestid=0; public ChessLogin(ChessServer s){ ss=s. addLoginListener(s); new Thread(this).start(); } public void run(){ while(isrunning){ try{ Socket socket=ss.accept(); String un=chkLogin(socket.getInputStream()); if(un!=null)notifyListener(guestid++,un,socket); }catch(IOException e){} } } public void addLoginListener(LoginListener l){ listeners.addElement(l); } void notifyListener(int userid,String username,Socket sock){ LoginEvent evt=new LoginEvent(userid,username,sock); for(Enumeration enu=listeners.elements();enu.hasMoreElements();){ ((LoginListener)enu.nextElement()).onLoginEvent(evt); } } public String chkLogin(InputStream is)throws IOException{ byte[] head=new byte[12]; HttpInputStream.readBytes(is,12,head); int cmdtype=head[0]; int totalsize=Convert.byteToShort(head[1],head[2]); if(totalsize==0) byte[] data=new byte[totalsize]; HttpInputStream.readBytes(is,totalsize,data); //System.out.print(&type=&+cmdtype+&,totalsize=&+totalsize+&,username=&+parseLoginData(data)); return parseLoginData(data); } public String parseLoginData(byte[] d){ return new String(d); } public static int byteToInt(byte j,byte k,byte m,byte n){ int a =j&;0 int b =k&;0 int c =m&;0 int d =n&;0 return (d
http://www.cn-java.com/www1/?action-viewnews-itemid-1840
以上是的内容，更多
的内容，请您使用右上方搜索功能获取相关信息。
若你要投稿、删除文章请联系邮箱：zixun-group@service.aliyun.com,工作人员会在五个工作日内给你回复。
云服务器 ECS
可弹性伸缩、安全稳定、简单易用
&40.8元/月起
预测未发生的攻击
&24元/月起
为您提供0门槛上云实践机会
你可能还喜欢
你可能感兴趣
阿里云教程中心为您免费提供
如何用Java实现网络中国象棋室（一）相关信息，包括
的信息，所有如何用Java实现网络中国象棋室（一）相关内容均不代表阿里云的意见！投稿删除文章请联系邮箱：zixun-group@service.aliyun.com，工作人员会在五个工作日内答复
售前咨询热线
支持与服务
资源和社区
关注阿里云
InternationalJava棋类游戏实践之中国象棋_java
作者：用户
本文讲的是Java棋类游戏实践之中国象棋_java，
本文实例讲述了java实现的中国象棋游戏代码，分享给大家供大家参考，具体代码如下
一、实践目的：
1.鼠标点击、拖动等事件的应用与区别
2.棋谱文件的保存与读取
3.完善象棋的规则。
二、实践内容：
中国象棋历史悠久，吸引了无数的人研究，
本文实例讲述了java实现的中国象棋游戏代码，分享给大家供大家参考，具体代码如下
一、实践目的：
1.鼠标点击、拖动等事件的应用与区别
2.棋谱文件的保存与读取
3.完善象棋的规则。
二、实践内容：
中国象棋历史悠久，吸引了无数的人研究，现对中国象棋的对战和实现棋谱的制作做如下的设计和说明，供大家参考学习。
1、机机对弈，红方先手。在符合规则的情况下拖动棋子到目的地，松鼠标落子。
人人对弈图
2、制作棋谱，选择制作棋谱菜单后，对弈开始，并记录了下棋过程。
选择“制作棋谱”菜单
棋谱制作完毕红方胜出
一方胜出后弹出胜利消息对话框。点击确定后，选择“保存棋谱”菜单，弹出保存文件对话框。
保存棋谱对话框
3.演示棋谱，选择演示棋谱菜单后，弹出打开对话框，选择保存好的棋谱，开始演示。
演示棋谱对话框
演示棋谱过程（自动和手动两种）
三、参考代码：
1.象棋主类 文件ChineseChess.java
package cn.edu.ouc.chineseC
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.LinkedL
* 象棋主类
* @author cnlht
public class ChineseChess extends JFrame implements ActionListener {
ChessBoard board =
Demon demon =
MakeChessManual record =
Container con =
JMenu fileM
JMenuItem 制作棋谱, 保存棋谱, 演示棋谱;
JFileChooser fileChooser =
LinkedList 棋谱 =
public ChineseChess() {
bar = new JMenuBar();
fileMenu = new JMenu("中国象棋");
制作棋谱 = new JMenuItem("制作棋谱");
保存棋谱 = new JMenuItem("保存棋谱");
保存棋谱.setEnabled(false);
演示棋谱 = 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.
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, 690, 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.
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) {
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) {
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();
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 ChineseChess();
2.象棋棋盘类文件ChessBoard.java
package cn.edu.ouc.chineseC
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
* @author cnlht
public class ChessBoard extends JPanel implements MouseListener,
MouseMotionListener {
public ChessPoint point[][];
public int unitWidth, unitH
private int x轴长, y轴长;
private int x,
protected Image pieceI
private boolean move =
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, 黑方走棋 =
Rule rule =
public MakeChessManual record =
public ChessBoard(int w, int h, int r, int c) {
setLayout(null);
addMouseListener(this);
addMouseMotionListener(this);
Color bc = getBackground();
unitWidth =
unitHeight =
point = new ChessPoint[r + 1][c + 1];
for (int i = 1; i &= i++) {
for (int j = 1; j &= j++) {
point[i][j] = new ChessPoint(i * unitWidth, j * unitHeight,
rule = new Rule(this, point);
record = new MakeChessManual(this, point);
img = Toolkit.getDefaultToolkit().getImage("board.jpg");
pieceImg = Toolkit.getDefaultToolkit().getImage("piece.gif");
红车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.black, bc, w - 4, h - 4, this);
黑将.set棋子类别(黑方颜色);
黑士1 = new ChessPiece("士", Color.black, bc, w - 4, h - 4, this);
黑士1.set棋子类别(黑方颜色);
黑士2 = new ChessPiece("士", Color.black, bc, w - 4, h - 4, this);
黑士2.set棋子类别(黑方颜色);
黑车1 = new ChessPiece("车", Color.black, bc, w - 4, h - 4, this);
黑车1.set棋子类别(黑方颜色);
黑车2 = new ChessPiece("车", Color.black, bc, w - 4, h - 4, this);
黑车2.set棋子类别(黑方颜色);
黑炮1 = new ChessPiece("炮", Color.black, bc, w - 4, h - 4, this);
黑炮1.set棋子类别(黑方颜色);
黑炮2 = new ChessPiece("炮", Color.black, bc, w - 4, h - 4, this);
黑炮2.set棋子类别(黑方颜色);
黑象1 = new ChessPiece("象", Color.black, bc, w - 4, h - 4, this);
黑象1.set棋子类别(黑方颜色);
黑象2 = new ChessPiece("象", Color.black, bc, w - 4, h - 4, this);
黑象2.set棋子类别(黑方颜色);
黑马1 = new ChessPiece("马", Color.black, bc, w - 4, h - 4, this);
黑马1.set棋子类别(黑方颜色);
黑马2 = new ChessPiece("马", Color.black, bc, w - 4, h - 4, this);
黑马2.set棋子类别(黑方颜色);
黑卒1 = new ChessPiece("卒", Color.black, bc, w - 4, h - 4, this);
黑卒1.set棋子类别(黑方颜色);
黑卒2 = new ChessPiece("卒", Color.black, bc, w - 4, h - 4, this);
黑卒2.set棋子类别(黑方颜色);
黑卒3 = new ChessPiece("卒", Color.black, bc, w - 4, h - 4, this);
黑卒3.set棋子类别(黑方颜色);
黑卒4 = new ChessPiece("卒", Color.black, bc, w - 4, h - 4, this);
黑卒4.set棋子类别(黑方颜色);
黑卒5 = new ChessPiece("卒", Color.black, 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);
int imgWidth = img.getWidth(this);
int imgHeight = img.getHeight(this);// 获得图片的宽度与高度
int FWidth = getWidth();
int FHeight = getHeight();// 获得窗口的宽度与高度
int x = (FWidth - imgWidth) / 2;
int y = (FHeight - imgHeight) / 2;
g.drawImage(img, x, y, null);
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);
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);
/**鼠标按下事件*/
public void mousePressed(MouseEvent e) {
ChessPiece piece =
Rectangle rect =
if (e.getSource() == this)
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)) {
public void mouseMoved(MouseEvent e) {
/**鼠标拖动事件*/
public void mouseDragged(MouseEvent e) {
ChessPiece piece =
if (e.getSource() instanceof ChessPiece) {
piece = (ChessPiece) e.getSource();
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 =
Rectangle rect =
if (e.getSource() instanceof ChessPiece) {
piece = (ChessPiece) e.getSource();
rect = piece.getBounds();
e = SwingUtilities.convertMouseEvent(piece, e, this);
if (e.getSource() == this) {
boolean containChessPoint =
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 =
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);
boolean ok = rule.movePieceRule(piece, startI, startJ,
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);
rule.isWine(pieceRemoved);
if (piece.棋子类别().equals(红方颜色)) {
红方走棋 =
黑方走棋 =
if (piece.棋子类别().equals(黑方颜色)) {
黑方走棋 =
红方走棋 =
validate();
repaint();
piece.setLocation(startX, startY);
(point[startI][startJ]).set有棋子(true);
boolean ok = rule
.movePieceRule(piece, startI, startJ, m, n);
point[m][n].setPiece(piece, this);
(point[startI][startJ]).set有棋子(false);
record.记录棋谱(piece, startI, startJ, m, n);
record.记录吃掉的棋子("没吃棋子");
if (piece.棋子类别().equals(红方颜色)) {
红方走棋 =
黑方走棋 =
if (piece.棋子类别().equals(黑方颜色)) {
黑方走棋 =
红方走棋 =
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) {
3.棋子类文件ChessPiece.java
package cn.edu.ouc.chineseC
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
* @author cnlht
public class ChessPiece extends JLabel {
S // 棋子名字
Color backColor = null, foreC// 背景色和前景色
String 颜色类别 =
ChessBoard board =
int width,// 大小
public ChessPiece(String name, Color fc, Color bc, int width, int height,
ChessBoard board) {// 构造棋子
this.name =
this.board =
this.width =
this.height =
foreColor =
backColor =
setSize(width, height);
setBackground(bc);
addMouseMotionListener(board);
addMouseListener(board);
// 绘制棋子
public void paint(Graphics g) {
g.drawImage(board.pieceImg, 2, 2, width-2, height-2, null);
g.setColor(foreColor);
g.setFont(new Font("楷体", Font.BOLD, 26));
g.drawString(name, 7, height - 8);// 在棋子上绘制 “棋子名”
g.setColor(Color.black);
//g.drawOval(1, 1, width - 1, height - 1);
float lineWidth = 2.3f;
((Graphics2D)g).setStroke(new BasicStroke(lineWidth));
((Graphics2D)g).drawOval(2, 2, width-2, height-2);
public int getWidth() {
public int getHeight() {
public String getName() {
public Color 获取棋子颜色() {
return foreC
public void set棋子类别(String 类别) {
颜色类别 = 类别;
public String 棋子类别() {
return 颜色类别;
4.棋子点坐标类文件
package cn.edu.ouc.chineseC
* @author cnlht
public class ChessPoint {
/** 棋子坐标 */
/** 该坐标 是否有子*/
boolean 有棋子;
/** 改坐标的棋子 */
ChessPiece piece =
/** 坐标所属棋盘 */
ChessBoard board =
public ChessPoint(int x, int y, boolean boo) {
public boolean isPiece() {
return 有棋子;
public void set有棋子(boolean boo) {
public int getX() {
public int getY() {
// 设置改点棋子
public void setPiece(ChessPiece piece, ChessBoard board) {
this.board =
this.piece =
board.add(piece);
int w = (board.unitWidth);
int h = (board.unitHeight);
piece.setBounds(x - w / 2, y - h / 2, w, h);// 棋子位置，宽度，高度
board.validate();
public ChessPiece getPiece() {
public void reMovePiece(ChessPiece piece, ChessBoard board) {
this.board =
this.piece =
board.remove(piece);
board.validate();
5.玩法规则类文件Rule.java
package cn.edu.ouc.chineseC
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
* 走棋规则类
* @author cnlht
public class Rule {
ChessBoard board =
ChessPiece piece =
ChessPoint point[][];
int startI, startJ, endI, endJ;
public Rule(ChessBoard board, ChessPoint point[][]) {
this.board =
this.point =
public void isWine(ChessPiece piece) {
this.piece =
if (piece.getName() == "将" || piece.getName() == "帅") {
if (piece.颜色类别 == "红方") {
JOptionPane.showMessageDialog(null, "黑方 胜利！");
JOptionPane.showMessageDialog(null, "红方 胜利！");
public boolean movePieceRule(ChessPiece piece, int startI, int startJ,
int endI, int endJ) {
this.piece =
this.startI = startI;
this.startJ = startJ;
this.endI = endI;
this.endJ = endJ;
int minI = Math.min(startI, endI);
int maxI = Math.max(startI, endI);
int minJ = Math.min(startJ, endJ);
int maxJ = Math.max(startJ, endJ);
boolean 可否走棋 =
if (piece.getName().equals("车")) {
if (startI == endI) {
int j = 0;
for (j = minJ + 1; j &= maxJ - 1; j++) {
if (point[startI][j].isPiece()) {
可否走棋 =
if (j == maxJ) {
可否走棋 =
} else if (startJ == endJ) {
int i = 0;
for (i = minI + 1; i &= maxI - 1; i++) {
if (point[i][startJ].isPiece()) {
可否走棋 =
if (i == maxI) {
可否走棋 =
可否走棋 =
} else if (piece.getName().equals("車")) {
if (startI == endI) {
int j = 0;
for (j = minJ + 1; j &= maxJ - 1; j++) {
if (point[startI][j].isPiece()) {
可否走棋 =
if (j == maxJ) {
可否走棋 =
} else if (startJ == endJ) {
int i = 0;
for (i = minI + 1; i &= maxI - 1; i++) {
if (point[i][startJ].isPiece()) {
可否走棋 =
if (i == maxI) {
可否走棋 =
可否走棋 =
}else if (piece.getName().equals("马")) {
int xAxle = Math.abs(startI - endI);
int yAxle = Math.abs(startJ - endJ);
if (xAxle == 2 && yAxle == 1) {
if (endI & startI) {
if (point[startI + 1][startJ].isPiece()) {
可否走棋 =
可否走棋 =
if (endI & startI) {
if (point[startI - 1][startJ].isPiece()) {
可否走棋 =
可否走棋 =
}else if (xAxle == 1 && yAxle == 2) {
if (endJ & startJ) {
if (point[startI][startJ + 1].isPiece()) {
可否走棋 =
可否走棋 =
if (endJ & startJ) {
if (point[startI][startJ - 1].isPiece()) {
可否走棋 =
可否走棋 =
可否走棋 =
} else if (piece.getName().equals("馬")) {
int xAxle = Math.abs(startI - endI);
int yAxle = Math.abs(startJ - endJ);
if (xAxle == 2 && yAxle == 1) {
if (endI & startI) {
if (point[startI + 1][startJ].isPiece()) {
可否走棋 =
可否走棋 =
if (endI & startI) {
if (point[startI - 1][startJ].isPiece()) {
可否走棋 =
可否走棋 =
}else if (xAxle == 1 && yAxle == 2) {
if (endJ & startJ) {
if (point[startI][startJ + 1].isPiece()) {
可否走棋 =
可否走棋 =
if (endJ & startJ) {
if (point[startI][startJ - 1].isPiece()) {
可否走棋 =
可否走棋 =
可否走棋 =
} else if (piece.getName().equals("象")) {
int centerI = (startI + endI) / 2;
int centerJ = (startJ + endJ) / 2;
int xAxle = Math.abs(startI - endI);
int yAxle = Math.abs(startJ - endJ);
if (xAxle == 2 && yAxle == 2 && endJ &= 5) {
if (point[centerI][centerJ].isPiece()) {
可否走棋 =
可否走棋 =
可否走棋 =
} else if (piece.getName().equals("相")) {
int centerI = (startI + endI) / 2;
int centerJ = (startJ + endJ) / 2;
int xAxle = Math.abs(startI - endI);
int yAxle = Math.abs(startJ - endJ);
if (xAxle == 2 && yAxle == 2 && endJ &= 6) {
if (point[centerI][centerJ].isPiece()) {
可否走棋 =
可否走棋 =
可否走棋 =
} else if (piece.getName().equals("炮")) {
int number = 0;
if (startI == endI) {
int j = 0;
for (j = minJ + 1; j &= maxJ - 1; j++) {
if (point[startI][j].isPiece()) {
if (number & 1) {
可否走棋 =
} else if (number == 1) {
if (point[endI][endJ].isPiece()) {
可否走棋 =
} else if (number == 0 && !point[endI][endJ].isPiece()) {
可否走棋 =
} else if (startJ == endJ) {
int i = 0;
for (i = minI + 1; i &= maxI - 1; i++) {
if (point[i][startJ].isPiece()) {
if (number & 1) {
可否走棋 =
} else if (number == 1) {
if (point[endI][endJ].isPiece()) {
可否走棋 =
} else if (number == 0 && !point[endI][endJ].isPiece()) {
可否走棋 =
可否走棋 =
} else if (piece.getName().equals("兵")) {
int xAxle = Math.abs(startI - endI);
int yAxle = Math.abs(startJ - endJ);
if (endJ &= 6) {
if (startJ - endJ == 1 && xAxle == 0) {
可否走棋 =
可否走棋 =
} else if (endJ &= 5) {
if ((startJ - endJ == 1) && (xAxle == 0)) {
可否走棋 =
} else if ((endJ - startJ == 0) && (xAxle == 1)) {
可否走棋 =
可否走棋 =
} else if (piece.getName().equals("卒")) {
int xAxle = Math.abs(startI - endI);
int yAxle = Math.abs(startJ - endJ);
if (endJ &= 5) {
if (endJ - startJ == 1 && xAxle == 0) {
可否走棋 =
可否走棋 =
} else if (endJ &= 6) {
if ((endJ - startJ == 1) && (xAxle == 0)) {
可否走棋 =
} else if ((endJ - startJ == 0) && (xAxle == 1)) {
可否走棋 =
可否走棋 =
else if (piece.getName().equals("士")) {
int xAxle = Math.abs(startI - endI);
int yAxle = Math.abs(startJ - endJ);
if (endI &= 6 && endI &= 4 && xAxle == 1 && yAxle == 1) {
可否走棋 =
可否走棋 =
} else if (piece.getName().equals("仕")) {
int xAxle = Math.abs(startI - endI);
int yAxle = Math.abs(startJ - endJ);
if (endI &= 6 && endI &= 4 && xAxle == 1 && yAxle == 1) {
可否走棋 =
可否走棋 =
} else if ((piece.getName().equals("帅"))
|| (piece.getName().equals("将"))) {
int xAxle = Math.abs(startI - endI);
int yAxle = Math.abs(startJ - endJ);
if (endI &= 6 && endI &= 4) {
if ((xAxle == 1 && yAxle == 0) || (xAxle == 0 && yAxle == 1)) {
可否走棋 =
可否走棋 =
可否走棋 =
return 可否走棋;
6.走步类文件MoveStep.java
package cn.edu.ouc.chineseC
import java.awt.P
* @author cnlht
public class MoveStep implements java.io.Serializable {
public Point pStart, pE
public MoveStep(Point p1, Point p2) {
pStart = p1;
pEnd = p2;
7.制作棋谱类MakeChessManual.java
package cn.edu.ouc.chineseC
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.LinkedL
* 制作棋谱类
* @author cnlht
public class MakeChessManual extends JPanel implements ActionListener {
JTextArea text =
JScrollPane scroll =
ChessBoard board =
ChessPoint[][]
LinkedList 棋谱 =
LinkedList 吃掉的棋子 =
JButton buttonU
int i = 0;
public MakeChessManual(ChessBoard board, ChessPoint[][] point) {
this.board =
this.point =
text = new JTextArea();
scroll = new JScrollPane(text);
棋谱 = new LinkedList();
吃掉的棋子 = new LinkedList();
buttonUndo = new JButton("悔棋");
buttonUndo.setFont(new Font("隶书", Font.PLAIN, 18));
setLayout(new BorderLayout());
add(scroll, BorderLayout.CENTER);
add(buttonUndo, BorderLayout.SOUTH);
buttonUndo.addActionListener(this);
public char numberToLetter(int n) {
char c = '\0';
switch (n) {
public void 记录棋谱(ChessPiece piece, int startI, int startJ, int endI,
int endJ) {
Point pStart = new Point(startI, startJ);
Point pEnd = new Point(endI, endJ);
MoveStep step = new MoveStep(pStart, pEnd);
棋谱.add(step);
String 棋子类别 = piece.棋子类别();
String name = piece.getName();
String m = "#" + 棋子类别 + name + ": " + startI + numberToLetter(startJ)
+ " 到 " + endI + numberToLetter(endJ);
text.append(m);
if (piece.棋子类别().equals(board.黑方颜色))
text.append("\n");
public void 记录吃掉的棋子(Object object) {
吃掉的棋子.add(object);
public LinkedList 获取棋谱() {
return 棋谱;
public void actionPerformed(ActionEvent e) {
int position = text.getText().lastIndexOf("#");
if (position != -1)
text.replaceRange("", position, text.getText().length());
if (棋谱.size() & 0) {
MoveStep lastStep = (MoveStep) 棋谱.getLast();
棋谱.removeLast();
Object qizi = 吃掉的棋子.getLast();
吃掉的棋子.removeLast();
String temp = qizi.toString();
if (temp.equals("没吃棋子")) {
int startI = lastStep.pStart.x;
int startJ = lastStep.pStart.y;
int endI = lastStep.pEnd.x;
int endJ = lastStep.pEnd.y;
ChessPiece piece = point[endI][endJ].getPiece();
point[startI][startJ].setPiece(piece, board);
(point[endI][endJ]).set有棋子(false);
if (piece.棋子类别().equals(board.红方颜色)) {
board.红方走棋 =
board.黑方走棋 =
if (piece.棋子类别().equals(board.黑方颜色)) {
board.黑方走棋 =
board.红方走棋 =
ChessPiece removedPiece = (ChessPiece)
int startI = lastStep.pStart.x;
int startJ = lastStep.pStart.y;
int endI = lastStep.pEnd.x;
int endJ = lastStep.pEnd.y;
ChessPiece piece = point[endI][endJ].getPiece();
point[startI][startJ].setPiece(piece, board);
point[endI][endJ].setPiece(removedPiece, board);
(point[endI][endJ]).set有棋子(true);
if (piece.棋子类别().equals(board.红方颜色)) {
board.红方走棋 =
board.黑方走棋 =
if (piece.棋子类别().equals(board.黑方颜色)) {
board.黑方走棋 =
board.红方走棋 =
8.演示棋谱类文件Demon.java
package cn.edu.ouc.chineseC
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
* 演示棋谱类
* @author cnlht
public class Demon extends JPanel implements ActionListener, Runnable {
public JButton replay = null, next = null, auto = null, stop =
LinkedList 棋谱 =
Thread 自动演示 =
int index = -1;
ChessBoard board =
JTextField 时间间隔 =
int time = 1000;
String 演示过程 = "";
JSplitPane splitH = null, splitV =
public Demon(ChessBoard board) {
this.board =
replay = new JButton("重新演示");
next = new JButton("下一步");
auto = new JButton("自动演示");
stop = new JButton("暂停演示");
自动演示 = new Thread(this);
replay.addActionListener(this);
next.addActionListener(this);
auto.addActionListener(this);
stop.addActionListener(this);
text = new JTextArea();
时间间隔 = new JTextField("1");
setLayout(new BorderLayout());
JScrollPane pane = new JScrollPane(text);
JPanel p = new JPanel(new GridLayout(3, 2));
p.add(next);
p.add(replay);
p.add(auto);
p.add(stop);
p.add(new JLabel("时间间隔(秒)", SwingConstants.CENTER));
p.add(时间间隔);
splitV = new JSplitPane(JSplitPane.VERTICAL_SPLIT, pane, p);
splitH = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, board, splitV);
splitV.setDividerSize(5);
splitV.setDividerLocation(400);
splitH.setDividerSize(5);
splitH.setDividerLocation(460);
add(splitH, BorderLayout.CENTER);
validate();
public void set棋谱(LinkedList 棋谱) {
this.棋谱 = 棋谱;
public char numberToLetter(int n) {
char c = '\0';
switch (n) {
public void actionPerformed(ActionEvent e) {
if (e.getSource() == next) {
if (index & 棋谱.size()) {
演示一步(index);
演示结束("棋谱演示完毕");
if (e.getSource() == replay) {
board = new ChessBoard(45, 45, 9, 10);
splitH.remove(board);
splitH.setDividerSize(5);
splitH.setDividerLocation(460);
splitH.setLeftComponent(board);
splitH.validate();
index = -1;
text.setText(null);
if (e.getSource() == auto) {
next.setEnabled(false);
replay.setEnabled(false);
time = 1000 * Integer.parseInt(时间间隔.getText().trim());
} catch (NumberFormatException ee) {
time = 1000;
if (!(自动演示.isAlive())) {
自动演示 = new Thread(this);
board = new ChessBoard(45, 45, 9, 10);
splitH.remove(board);
splitH.setDividerSize(5);
splitH.setDividerLocation(460);
splitH.setLeftComponent(board);
splitH.validate();
text.setText(null);
自动演示.start();
if (e.getSource() == stop) {
if (e.getActionCommand().equals("暂停演示")) {
演示过程 = "暂停演示";
stop.setText("继续演示");
stop.repaint();
if (e.getActionCommand().equals("继续演示")) {
演示过程 = "继续演示";
自动演示.interrupt();
stop.setText("暂停演示");
stop.repaint();
public synchronized void run() {
for (index = 0; index & 棋谱.size(); index++) {
Thread.sleep(time);
} catch (InterruptedException e) {
while (演示过程.equals("暂停演示")) {
} catch (InterruptedException e) {
notifyAll();
演示一步(index);
if (index &= 棋谱.size()) {
演示结束("棋谱演示完毕");
next.setEnabled(true);
replay.setEnabled(true);
public void 演示一步(int index) {
MoveStep step = (MoveStep) 棋谱.get(index);
Point pStart = step.pS
Point pEnd = step.pE
int startI = pStart.x;
int startJ = pStart.y;
int endI = pEnd.x;
int endJ = pEnd.y;
ChessPiece piece = (board.point)[startI][startJ].getPiece();
if ((board.point)[endI][endJ].isPiece() == true) {
ChessPiece pieceRemoved = (board.point)[endI][endJ].getPiece();
(board.point)[endI][endJ].reMovePiece(pieceRemoved, board);
board.repaint();
(board.point)[endI][endJ].setPiece(piece, board);
(board.point)[startI][startJ].set有棋子(false);
board.repaint();
(board.point)[endI][endJ].setPiece(piece, board);
(board.point)[startI][startJ].set有棋子(false);
String 棋子类别 = piece.棋子类别();
String name = piece.getName();
String m = "#" + 棋子类别 + name + ": " + startI + numberToLetter(startJ)
+ " 到 " + endI + numberToLetter(endJ);
text.append(m);
if (piece.棋子类别().equals(board.黑方颜色))
text.append("\n");
public void 演示结束(String message) {
splitH.remove(board);
splitH.setDividerSize(5);
splitH.setDividerLocation(460);
JLabel label = new JLabel(message);
label.setFont(new Font("隶书", Font.BOLD, 40));
label.setForeground(Color.blue);
label.setHorizontalAlignment(SwingConstants.CENTER);
splitH.setLeftComponent(label);
splitH.validate();
四、总结与要求1.理解8个文件，没有太复杂的代码。
2.理解鼠标的MouseListener,MouseMotionListener两个接口的区别，五子棋的实现不需要MouseMotionListener。
3.使用LinkedList记录棋谱的方法。
希望大家喜欢这篇，制作一款属于自己的中国象棋游戏。
以上是云栖社区小编为您精心准备的的内容，在云栖社区的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索Java棋类游戏
Java中国象棋
中国象棋 棋类、java象棋游戏、java手机象棋游戏源码、java 棋牌类定义、棋牌类游戏下载，以便于您获取更多的相关知识。
弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率
40+云计算产品，6个月免费体验
稳定可靠、可弹性伸缩的在线数据库服务，全球最受欢迎的开源数据库之一
云服务器9.9元/月，大学必备
云栖社区(yq.aliyun.com)为您免费提供相关信息，包括
，所有相关内容均不代表云栖社区的意见！
