[一天一项目]象棋

120+项目中有象棋，不会做swing就上网找了找，copy了一份。虽然不太认同他的命名方式，但作为例子容易看懂什么的就甚好。本例带有 棋盘记录回放的功能，有需要的朋友可以参考

package com.project.chineseChess;

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, unitHeight;
    private int x轴长, y轴长;
    private int x, y;
    private Image img;
    protected Image pieceImg;
    private 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);

        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);
            } 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);
                            rule.isWine(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) {
    }
}

package com.project.chineseChess;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

/**
 * 棋子类
 * 
 * @author cnlht
 */
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) {// 构造棋子
        this.name = 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.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() {
        return width;
    }

    public int getHeight() {
        return height;
    }

    public String getName() {
        return name;
    }

    public Color 获取棋子颜色() {
        return foreColor;
    }

    public void set棋子类别(String 类别) {
        颜色类别 = 类别;
    }

    public String 棋子类别() {
        return 颜色类别;
    }
}

package com.project.chineseChess;

/**
 * 棋点类
 * 
 * @author cnlht
 */
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;
    }
}

package com.project.chineseChess;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.LinkedList;

import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JSplitPane;
import javax.swing.SwingConstants;

/**
 * 象棋主类
 * 
 * @author cnlht
 */
public class ChineseChess 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 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.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, 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.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 ChineseChess();
    }
}

package com.project.chineseChess;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.LinkedList;

import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.SwingConstants;

/**
 * 演示棋谱类
 * 
 * @author cnlht
 */
public class Demon extends JPanel implements ActionListener, Runnable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    public JButton replay = null, next = null, auto = null, stop = null;
    LinkedList<?> 棋谱 = null;
    Thread 自动演示 = null;
    int index = -1;
    ChessBoard board = null;
    JTextArea text;
    JTextField 时间间隔 = null;
    int time = 1000;
    String 演示过程 = "";
    JSplitPane splitH = null, splitV = null;

    public Demon(ChessBoard board) {
        this.board = 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) {
        case 1:
            c = 'A';
            break;
        case 2:
            c = 'B';
            break;
        case 3:
            c = 'C';
            break;
        case 4:
            c = 'D';
            break;
        case 5:
            c = 'E';
            break;
        case 6:
            c = 'F';
            break;
        case 7:
            c = 'G';
            break;
        case 8:
            c = 'H';
            break;
        case 9:
            c = 'I';
            break;
        case 10:
            c = 'J';
            break;
        }
        return c;
    }

    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == next) {
            index++;
            if (index < 棋谱.size()) {
                演示一步(index);
            } else {
                演示结束("棋谱演示完毕");
            }
        }
        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);
            try {
                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++) {
            try {
                Thread.sleep(time);
            } catch (InterruptedException e) {
            }
            while (演示过程.equals("暂停演示")) {
                try {
                    wait();
                } 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.pStart;
        Point pEnd = step.pEnd;
        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();
        } else {
            (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();
    }
}

package com.project.chineseChess;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.LinkedList;

/**
 * 制作棋谱类
 * 
 * @author cnlht
 */
public class MakeChessManual extends JPanel implements ActionListener {
    JTextArea text = null;
    JScrollPane scroll = null;
    ChessBoard board = null;
    ChessPoint[][] point;
    LinkedList 棋谱 = null;
    LinkedList 吃掉的棋子 = null;
    JButton buttonUndo;
    int i = 0;

    public MakeChessManual(ChessBoard board, ChessPoint[][] point) {
        this.board = board;
        this.point = 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) {
        case 1:
            c = 'A';
            break;
        case 2:
            c = 'B';
            break;
        case 3:
            c = 'C';
            break;
        case 4:
            c = 'D';
            break;
        case 5:
            c = 'E';
            break;
        case 6:
            c = 'F';
            break;
        case 7:
            c = 'G';
            break;
        case 8:
            c = 'H';
            break;
        case 9:
            c = 'I';
            break;
        case 10:
            c = 'J';
            break;
        }
        return c;
    }

    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.红方走棋 = true;
                    board.黑方走棋 = false;
                }
                if (piece.棋子类别().equals(board.黑方颜色)) {
                    board.黑方走棋 = true;
                    board.红方走棋 = false;
                }
            } else {
                ChessPiece removedPiece = (ChessPiece) qizi;
                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.红方走棋 = true;
                    board.黑方走棋 = false;
                }
                if (piece.棋子类别().equals(board.黑方颜色)) {
                    board.黑方走棋 = true;
                    board.红方走棋 = false;
                }
            }
        }
    }
}

package com.project.chineseChess;

import java.awt.Point;

/**
 * 走步类
 * 
 * @author cnlht
 * 
 */
public class MoveStep implements java.io.Serializable {
    public Point pStart, pEnd;

    public MoveStep(Point p1, Point p2) {
        pStart = p1;
        pEnd = p2;
    }
}

package com.project.chineseChess;

import javax.swing.JOptionPane;

/**
 * 走棋规则类
 * 
 * @author cnlht
 */
public class Rule {
    ChessBoard board = null;
    ChessPiece piece = null;
    ChessPoint point[][];
    int startI, startJ, endI, endJ;

    public Rule(ChessBoard board, ChessPoint point[][]) {
        this.board = board;
        this.point = point;
    }

    public void isWine(ChessPiece piece) {
        this.piece = piece;
        if (piece.getName() == "将" || piece.getName() == "帅") {
            if (piece.颜色类别 == "红方") {
                JOptionPane.showMessageDialog(null, "黑方  胜利！");
            } else {
                JOptionPane.showMessageDialog(null, "红方  胜利！");
            }
        }
    }

    public boolean movePieceRule(ChessPiece piece, int startI, int startJ,
            int endI, int endJ) {
        this.piece = 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 可否走棋 = false;
        if (piece.getName().equals("车")) {
            if (startI == endI) {
                int j = 0;
                for (j = minJ + 1; j <= maxJ - 1; j++) {
                    if (point[startI][j].isPiece()) {
                        可否走棋 = false;
                        break;
                    }
                }
                if (j == maxJ) {
                    可否走棋 = true;
                }
            } else if (startJ == endJ) {
                int i = 0;
                for (i = minI + 1; i <= maxI - 1; i++) {
                    if (point[i][startJ].isPiece()) {
                        可否走棋 = false;
                        break;
                    }
                }
                if (i == maxI) {
                    可否走棋 = true;
                }
            } else {
                可否走棋 = false;
            }

        } else if (piece.getName().equals("車")) {
            if (startI == endI) {
                int j = 0;
                for (j = minJ + 1; j <= maxJ - 1; j++) {
                    if (point[startI][j].isPiece()) {
                        可否走棋 = false;
                        break;
                    }
                }
                if (j == maxJ) {
                    可否走棋 = true;
                }
            } else if (startJ == endJ) {
                int i = 0;
                for (i = minI + 1; i <= maxI - 1; i++) {
                    if (point[i][startJ].isPiece()) {
                        可否走棋 = false;
                        break;
                    }
                }
                if (i == maxI) {
                    可否走棋 = true;
                }
            } else {
                可否走棋 = false;
            }

        }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()) {
                        可否走棋 = false;
                    } else {
                        可否走棋 = true;
                    }
                }
                if (endI < startI) {
                    if (point[startI - 1][startJ].isPiece()) {
                        可否走棋 = false;
                    } else {
                        可否走棋 = true;
                    }
                }

            }else if (xAxle == 1 && yAxle == 2) {
                if (endJ > startJ) {
                    if (point[startI][startJ + 1].isPiece()) {
                        可否走棋 = false;
                    } else {
                        可否走棋 = true;
                    }
                }
                if (endJ < startJ) {
                    if (point[startI][startJ - 1].isPiece()) {
                        可否走棋 = false;
                    } else {
                        可否走棋 = true;
                    }
                }

            } else {
                可否走棋 = false;
            }
        } 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()) {
                        可否走棋 = false;
                    } else {
                        可否走棋 = true;
                    }
                }
                if (endI < startI) {
                    if (point[startI - 1][startJ].isPiece()) {
                        可否走棋 = false;
                    } else {
                        可否走棋 = true;
                    }
                }

            }else if (xAxle == 1 && yAxle == 2) {
                if (endJ > startJ) {
                    if (point[startI][startJ + 1].isPiece()) {
                        可否走棋 = false;
                    } else {
                        可否走棋 = true;
                    }
                }
                if (endJ < startJ) {
                    if (point[startI][startJ - 1].isPiece()) {
                        可否走棋 = false;
                    } else {
                        可否走棋 = true;
                    }
                }

            } else {
                可否走棋 = false;
            }
        } 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()) {
                    可否走棋 = false;
                } else {
                    可否走棋 = true;
                }
            } else {
                可否走棋 = false;
            }
        } 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()) {
                    可否走棋 = false;
                } else {
                    可否走棋 = true;
                }
            } else {
                可否走棋 = false;
            }
        } 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()) {
                        number++;
                    }
                }
                if (number > 1) {
                    可否走棋 = false;
                } else if (number == 1) {
                    if (point[endI][endJ].isPiece()) {
                        可否走棋 = true;
                    }
                } else if (number == 0 && !point[endI][endJ].isPiece()) {
                    可否走棋 = true;
                }
            } else if (startJ == endJ) {
                int i = 0;
                for (i = minI + 1; i <= maxI - 1; i++) {
                    if (point[i][startJ].isPiece()) {
                        number++;
                    }
                }
                if (number > 1) {
                    可否走棋 = false;
                } else if (number == 1) {
                    if (point[endI][endJ].isPiece()) {
                        可否走棋 = true;
                    }
                } else if (number == 0 && !point[endI][endJ].isPiece()) {
                    可否走棋 = true;
                }
            } else {
                可否走棋 = false;
            }
        } 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) {
                    可否走棋 = true;
                }

                else {
                    可否走棋 = false;
                }
            } else if (endJ <= 5) {
                if ((startJ - endJ == 1) && (xAxle == 0)) {
                    可否走棋 = true;
                } else if ((endJ - startJ == 0) && (xAxle == 1)) {
                    可否走棋 = true;
                } else {
                    可否走棋 = false;
                }
            }
        } 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) {
                    可否走棋 = true;
                } else {
                    可否走棋 = false;
                }
            } else if (endJ >= 6) {
                if ((endJ - startJ == 1) && (xAxle == 0)) {
                    可否走棋 = true;
                } else if ((endJ - startJ == 0) && (xAxle == 1)) {
                    可否走棋 = true;
                } else {
                    可否走棋 = false;
                }
            }
        }

        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) {
                可否走棋 = true;
            } else {
                可否走棋 = false;
            }
        } 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) {
                可否走棋 = true;
            } else {
                可否走棋 = false;
            }
        } 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)) {
                    可否走棋 = true;
                } else {
                    可否走棋 = false;
                }
            } else {
                可否走棋 = false;
            }
        }

        return 可否走棋;

    }
}

如有错误请指正，如有更多更好的方法，烦请告知，谢谢！
代码合集：https://github.com/FanceTsui/Project
——Fance Tsui