java国际象棋中的多态性

我是java新手，正在尝试构建运行国际象棋游戏的逻辑。我有一个名为'Piece'的超类和king、knight、queen等的子类。我正在尝试实现一种移动方法，在这种方法中，我可以动态确定棋子的类型，然后调用该棋子相应的移动方法。例如：

int typeOfPiece = _board[startX][startY]._theKind;
Piece myPiece;

switch(typeOfPiece)
{
    case 1:
        myPiece = new Pawn(startX, startY, team);
    case 2: 
        myPiece = new Rook(startX, startY, team);
    case 3:
        myPiece = new Knight(startX, startY, team);
}

boolean myPiece.canMove(endX, endY);

在本例中，是否有一种方法可以确保正确类型的工件调用canMove方法

---

谢谢

在所有子类中覆盖

canMove

，并在父类

Piece

中将其抽象化

在所有子类中覆盖

canMove

，并在父类

Piece
中将其抽象化，如果您的电路板将持有
Piece
对象而不是
int
值，则您可以只要做：

Piece piece = _board[x][y];
piece.canMove(...);

Piece
类将定义一个
canMove
方法，它的所有子类将使用它们自己的策略来实现。
如果您的板将持有
Piece
对象而不是
int
值，那么您可以执行以下操作：

Piece piece = _board[x][y];
piece.canMove(...);

Piece
类将定义一个
canMove
方法，它的所有子类将使用自己的策略实现。
如果您的子类在超类“Piece”上重写canMove方法，myPiece.canMove（endX，endY）就足够了。根据myPiece引用所指向的对象类型，在运行时，jvm将决定应该调用哪个方法。如果您的子类覆盖了超类“Piece”上的canMove方法，则称之为动态方法调度，myPiece.canMove（endX，endY）就足够了。根据myPiece引用所指的对象类型，在运行时，jvm将决定它应该调用哪个方法。这称为动态方法分派。我要做的是创建一个抽象类或接口，表示
片段
对象的行为和属性

然后，我将拥有实现/扩展piece类的类，每个类都用
canMove
方法表示它们自己的行为

实例化对象，然后在代码中，只需获取位于位置（x，y）的
片段
对象，并调用
canMove
。这将把行为委托给适当的子类，使代码更干净、更易于维护和灵活

在我看来，拥有一个抽象类或接口，而不是为
片段
对象拥有一个具体的类，是一种优势，因为它迫使每个片段实现这样的行为，而不是简单地继承它。
我要做的是创建一个抽象类或接口，表示
片段
对象的行为和属性

然后，我将拥有实现/扩展piece类的类，每个类都用
canMove
方法表示它们自己的行为

实例化对象，然后在代码中，只需获取位于位置（x，y）的
片段
对象，并调用
canMove
。这将把行为委托给适当的子类，使代码更干净、更易于维护和灵活

在我看来，拥有一个抽象类或接口，而不是为
工件
对象拥有一个具体类，是一种优势，因为它迫使每个工件实现这种行为，而不是简单地继承它。
您可以使用
枚举
作为
工件
工厂。这样你就不需要
1意味着典当，
等，因为你有
件。典当
等。请注意，你仍然可以有一个名为
典当的
枚举
和一个名为
典当的
类
，没有歧义

private abstract static class Piece {
  // Current position.
  protected int x, y;

  // Returns true if this piece could move there.
  abstract boolean canMove ( int x, int y);
}

private static class Pawn extends Piece {
  @Override
  boolean canMove (int toX, int toY) {
    // Not handling en-passant and first-move etc.
    return toX == x && (toY == y + 1 || toY == y + 2);
  }
}
private static class Rook extends Piece {
  @Override
  boolean canMove (int toX, int toY) {
    return toX == x || toY == y;
  }
}

// A Piece factory.
private static enum Pieces {
  Pawn {
    @Override
    Piece make () {
      return new Pawn();
    }
  },
  Rook{
    @Override
    Piece make () {
      return new Rook();
    }
  };

  abstract Piece make();
}

// Make a Piece.
private static Piece makePiece ( Pieces type ) {
  return type.make();
}

您可以将
枚举
用作
工件
工厂。这样你就不需要
1意味着典当，
等，因为你有
件。典当
等。请注意，你仍然可以有一个名为
典当的
枚举
和一个名为
典当的
类
，没有歧义

private abstract static class Piece {
  // Current position.
  protected int x, y;

  // Returns true if this piece could move there.
  abstract boolean canMove ( int x, int y);
}

private static class Pawn extends Piece {
  @Override
  boolean canMove (int toX, int toY) {
    // Not handling en-passant and first-move etc.
    return toX == x && (toY == y + 1 || toY == y + 2);
  }
}
private static class Rook extends Piece {
  @Override
  boolean canMove (int toX, int toY) {
    return toX == x || toY == y;
  }
}

// A Piece factory.
private static enum Pieces {
  Pawn {
    @Override
    Piece make () {
      return new Pawn();
    }
  },
  Rook{
    @Override
    Piece make () {
      return new Rook();
    }
  };

  abstract Piece make();
}

// Make a Piece.
private static Piece makePiece ( Pieces type ) {
  return type.make();
}

我建议您使用哪个实现抽象类块而不是int的2d数组来表示电路板。您可以通过这样做来避免。
我建议您使用哪个实现抽象类块而不是int的2d数组来表示电路板，。您可以通过这样做来避免。
您在问题中所做的并不是真正利用多态性，因为您是通过程序代码决定工件的类型

我建议你改变一下你的设计：不是每次你试着移动它时都为每一块创建一个新的实例，而是为所有的块创建两个seet（黑色和白色）。让电路板存储对工件的引用，以便您可以直接从电路板检索工件的实例

从抽象基类片段中，derrive Pawns和实现抽象方法的其他字符canMove（）
您在问题中所做的并不是真正利用多态性，而是通过程序代码决定片段的类型

我建议你改变一下你的设计：不是每次你试着移动它时都为每一块创建一个新的实例，而是为所有的块创建两个seet（黑色和白色）。让电路板存储对工件的引用，以便您可以直接从电路板检索工件的实例

从抽象基类片段中，驱动典当和实现抽象方法的其他字符可以move（）
在您的案例中添加
break
，并提供
default
案例。在您的案例中添加
break
并提供
default
案例。