国际象棋棋盘ASCII表示

Question

我已经有一个Board对象，包含一个碎片列表。Piece是一个抽象类，有一个位置(x，y)和一个颜色（黑色或白色）。然后是King、Queen、Knight这三个类，实现了Piece类。

谢谢

Answer 1

首先：如果您的意图是编写一个国际象棋引擎，那么您应该彻底阅读国际象棋编程wiki。

如果您还想尝试一下，那么您应该意识到面向对象编程的通常最佳实践并不一定适用于国际象棋编程。OOP的许多方面针对的是国际象棋根本不存在的目标。例如可扩展性。除了那些从一开始就存在的东西，你再也不会有其他的东西了。对于一个高效的国际象棋引擎，您可能根本不使用类形式的棋子的显式表示。对于板，您不希望使用列表 ，而是使用一个特殊的数组（有关大量（大量！）细节，请参阅板表示）。

但是，根据您当前的描述，除了通过instanceof检查检查它们的类之外，似乎没有办法区分这些部分。当然，这并不是很好，但是除非使用getType()方法扩展piece类（使整个继承无用），否则几乎没有其他选择。

K = King
Q = Queen
B = Bishop
N = Knight
R = Rook
P = Pawn

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


public class ChessBoardString
{
    public static void main(String[] args)
    {
        Board board = new Board();
        String s = createString(board);
        System.out.println(s);
    }

    private static String createString(Board board)
    {
        char empty = '.';
        char chars[] = new char[8*8+8];
        Arrays.fill(chars, empty);
        for (int y=0; y<8; y++)
        {
            chars[y*9+8] = '\n';
        }
        List<Piece> pieces = board.getPieces();
        for (Piece piece : pieces)
        {
            int x = piece.getX();
            int y = piece.getY();
            char c = charFor(piece);
            chars[x+y*9] = c;
        }
        String s = new String(chars);
        return s;
    }

    private static char charFor(Piece p)
    {
        char c = ' ';
        if (p instanceof King)
        {
            c = 'k';
        }
        else if (p instanceof Queen)
        {
            c = 'q';
        }
        else if (p instanceof Bishop)
        {
            c = 'b';
        }
        else if (p instanceof Knight)
        {
            c = 'n';
        }
        else if (p instanceof Rook)
        {
            c = 'r';
        }
        else if (p instanceof Pawn)
        {
            c = 'p';
        }
        if (p.getColor() == Color.WHITE)
        {
            c = Character.toUpperCase(c);
        }
        return c;
    }
}



class Board
{
    List<Piece> getPieces()
    {
        List<Piece> pieces = new ArrayList<Piece>();
        pieces.add(new King(Color.WHITE,3,4));
        pieces.add(new King(Color.BLACK,5,6));
        pieces.add(new Queen(Color.WHITE,7,2));
        pieces.add(new Queen(Color.BLACK,2,0));
        pieces.add(new Bishop(Color.WHITE,1,2));
        pieces.add(new Bishop(Color.BLACK,5,4));
        pieces.add(new Knight(Color.WHITE,5,1));
        pieces.add(new Knight(Color.BLACK,0,7));
        pieces.add(new Rook(Color.WHITE,2,2));
        pieces.add(new Rook(Color.BLACK,1,4));
        pieces.add(new Pawn(Color.WHITE,6,1));
        pieces.add(new Pawn(Color.BLACK,2,3));
        return pieces;
    }
}

enum Color
{
    BLACK,
    WHITE
}

abstract class Piece
{
    private Color color;
    private int x;
    private int y;
    Piece(Color color, int x, int y)
    {
        this.color = color;
        this.x = x;
        this.y = y;
    }
    Color getColor()
    {
        return color;
    }
    int getX()
    {
        return x;
    }
    int getY()
    {
        return y;
    }
}

class King extends Piece
{
    King(Color color, int x, int y)
    {
        super(color, x, y);
    }
}
class Queen extends Piece
{
    Queen(Color color, int x, int y)
    {
        super(color, x, y);
    }
}
class Bishop extends Piece
{
    Bishop(Color color, int x, int y)
    {
        super(color, x, y);
    }
}
class Knight extends Piece
{
    Knight(Color color, int x, int y)
    {
        super(color, x, y);
    }
}
class Rook extends Piece
{
    Rook(Color color, int x, int y)
    {
        super(color, x, y);
    }
}
class Pawn extends Piece
{
    Pawn(Color color, int x, int y)
    {
        super(color, x, y);
    }
}