Question

我从其他来源了解到，让对象相互了解，尤其是同一级别的对象，并不是一个好主意。它应该更像是层次结构。

我的问题很独特，因为我还没有想办法解决。同样，我很不幸遇到任何专门解决我的问题的话题。

问题我正在构建一个国际象棋应用程序，并且正在构建该应用程序的模型。现在，我有一个抽象对象，例如java.util.Date，其他对象（例如Piece，Queen）和其他对象将继承。我还有一个Knight类，用于处理所有棋盘模型和游戏状态。现在，我的每个作品都有一个Board方法，可以根据自己的位置计算出可能的移动，为此，他们需要知道棋盘的状态。棋子也在启动时由董事会实例化。

问题我会继续通过例如

实例化碎片吗？

generateMove()

然后使用Knight类方法

public class ChessBoard{
   Boardbit = 64bit
   Knight = new Knight(start_position, this) 

  //calculate

}

如果否，我还能采取其他什么方法？

Answer 1

更好的是使用方法generateMove(boardState)，因此董事会应调用您所拥有的任何部件，并将所需的信息传递给他们。它甚至可以用于某些优化，因为电路板每轮只能预生成一些良好使用的结构，然后将其传递给所有部件（例如某些二维数组）。

Answer 2

让Chessboard知道Knight，反之亦然，这并不好。我同意这一点。坚持“不要问”规则会迫使“更高级别”的元素（在本例中为棋盘）在提供所有必需信息的同时告诉棋子移动。 Chessboard本身不知道正在移动的棋子（在这种情况下，预测所有棋子可能的移动），但是肯定不会知道关于棋子如何移动或允许移动的任何细节。这只是使用某种策略模式的一种可能解决方案。（此处也可以使用Visitor或类似的模式）：

Main() {
    chessboard = new Chessboard()
    PiecesCollection = new PiecesCollection(new Knight(KnightStrategy, Color.Black))
    chessboard.AddPieces(PiecesCollection)

    CollectionOfAllPossibleMoveCollections = chessBoard.CallculateAllPossibleMoves()

    Move selectedMove = ShowOrSelectMove(CollectionOfAllPossibleMoveCollections)
    chessboard.ExecuteMove(selectedMove)
}

public class Chessboard{
   // fields
   PiecesCollectionWhite
   // where 'PiecesCollectionWhite' is a collection of `Piece`

   PiecesCollectionBlack
   // where 'PiecesCollectionBlack' is a collection of `Piece`

   CurrentlyVisitedPositionsCollection
   // where 'CurrentlyVisitedPositionsCollection' is a collection of `Position`

   // methods
   AddPieces(PiecesCollection, Color)

   CallculateAllPossibleMoves(Color) {
     CollectionOfPossibleMoveCollections = 
         FOREACH Piece IN PiecesCollection OF Color
             DO Piece.CalculateMoves(this.CurrentlyVisitedPositionsCollection)
     return CollectionOfAllPossibleMoveCollections // where 'CollectionOfAllPossibleMoveCollections ' is a collection that holds a collection of `Move` of which each nested collection represents the possible moves of a chess piece.
   }

   ExecuteMove(Move) {
       RemovePieceFromBoardIfNecessary(Move.ToPosition)
   }
} 

public class Piece 
{
   // fields
   Strategy
   Position
   Color

   // methods
   CallculateMoves(CurrentlyVisitedPositionsCollection) {
       PossibleMovesCollection = this.Strategy.Execute(CurrentlyVisitedPositionsCollection, this.Position)
       return PossibleMovesCollection where `PossibleMovesCollection` is a collection of `Move`
   }
}

public class Knight extends Piece
{
   ctor(Strategy, Color)
}

public class Stragtegy
{
  abstract Execute(currentPosition, allPiecesPositions) : PossibleMovesCollection 
}

public class KnightStrategy extends Strategy
{
  Execute(currentPosition, allPiecesPositions) {
      PossibleMovesCollection = ApplyKnightMoveAlgorithm()
      return PossibleMovesCollection 
  }

  private ApplyKnightMoveAlgorithm() : PossibleMovesCollection 
}

public class Move
{
  Position fromPosition
  Position toPosition
}

public class Color
{
  Black
  White
}

public class Position
{
  Color
  xCoordinate
  yCoordinate
}

这只是一个草图，而不是完整的示例。缺少某些状态信息或操作。例如。也许您必须将最后移动的Color存储在棋盘上。

由于Chessboard返回了所有可能的移动（有关所有当前访问的坐标的信息），因此您可以通过实施一些智能来从此信息中预测最佳移动来轻松增强算法。因此，在控制器或本例中的Main()将调用Chessboard.ExecuteMove(Move)之前，它可以调用PredictionEngine.PredictBestMove(CollectionOfAllPossibleMoveCollections)。

我要为相互依存的类使用什么模式

2 个答案: