Java扩展问题

Question

我有一系列类和扩展：

Class Base1{  .... }

Class Base1Extend1 extends Base1 {.....}

Class Base1Extend2 extends Base1 {......}

我现在有另一组使用它们：

Class Base2 {
   Base1 base1; 
   }

Class Base2Extend1{
   base1 = new Base1Extend1();}

Class Base2Extend1{
   base1 = new Base1Extend2();}

现在，Base2 对 Base1 的实例化执行一些工作。

此外，Base2Extend1 和 Base2Extend2 需要对其特定扩展类执行工作。例如，它们调用仅存在于子类中的特定方法。有没有什么方法可以做到这一点，而不必每次在 Base2 的扩展类中都使用强制转换？

---

确切的情况是这样的：

这是一款纸牌游戏，有两种类型的玩家：用户和“计算机”。 有许多基本方法适用于它们（pickupCards()、discardCards() 等）。 然后还有仅特定于用户的方法（checkMove() 等）和特定于“计算机”的方法（doTurn() 等）。

接下来是对象playerHand，它保存着用户的牌。 同样，还有处理手牌的基本方法（addCards()、removeCards() 等）。 然后还有仅适用于用户手的特定方法（checkCards() 等）和特定于“计算机”的方法（decideWhatToDo() 等）。

现在我想也许简单地将类合并在一起会更正确。 将 Base1 和 Base2 合并为一个类，然后对子类进行等效合并。

Answer 1

您可能希望使用字段 T base1 来参数化您的类。那么编译器就知道你正在使用 T =>; Base1Extend1 或 Base1Extend2，并且您不必进行强制转换。

Answer 2

在这种情况下，您要么必须每次都进行强制转换，要么创建更具体类型的字段/变量。

我不确定你在哪里，但要小心这个设计。通常这表明您错误地使用了继承。

如果您需要在子类上调用新方法，因为它需要它来完成超类中定义的某些任务，则意味着子类违反了其父类的契约（谷歌里氏替换原则）。

如果子类确实具有一些不与父类的功能交织在一起的新功能，则您可能希望从一开始就显式地使用子类（即变量声明）。或者，如果它并不真正相关，您可能应该使用全新的类和组合而不是继承。

---

这是相当广泛的，但是卡牌游戏的这种设计怎么样？我认为这是一个多回合的技巧游戏，需要检查一步是否有效以及谁采取了技巧。我不太确定你所说的丢弃、添加或删除牌是什么类型的游戏。

• 创建一个 Player 类，但它除了一个名称之外就没有太多内容。它还可以有一系列卡片。
• 另一个类是 GameController，它协调正在发生的事情并检查规则。它可以有这样的方法：
  • playCard(Player, Card)，验证移动并将卡片添加到记住谁玩过的游戏中。
  • score() 计算每回合结束时的得分。
• 另一个类是CPUController。这就是人工智能存在的地方。
• 最后是主循环。

主循环可以这样工作：

controller.shuffle();
// Either of:
// 1. push: controller.shuffle() calls player.pickupCards(cards)
// 2. pull: main loop calls player.pickupCards() which in turn calls controller.giveMeMyCards()

while(playersHaveMoreCards()) {
    awaitPlayerMove();
    // Now is the only time when player can make a move. If there is some
    // GUI the main loop could `wait()` on a mutex (until it's awoken when
    // player makes move), in text mode it could simply await input from keyboard.

    // When player makes a move, it calls controller.playCard(player, card)

    cpuController.move();
    // Again, when it controller calculates its move, eventually it simply calls controller.playCard()

    controller.score();
}
announceWinner(controller.getScore());

现在，这就是您通过这种方法获得的好处：

• 所有与游戏规则和计分相关的东西都在一个地方，这是 GameController 中唯一的东西。它非常容易掌握和维护。
• CPU AI也是如此。一切都集中在一处，CPUController 中唯一的东西就是 AI 实现。
• 从外部看，控制器是完全相同的，无论是人与 CPU、CPU 与 CPU 还是人与人。如果您想要多人游戏，那么您在这里唯一需要更改的是主循环（这是一个微不足道的更改）。
• 如果你想实现另一个拿技巧的游戏，你可能唯一需要改变的是 GameController（不同的规则）和 CPUController（不同的 AI）。
• 如果您想要 AI 的另一种实现（例如更智能的算法），您只需替换 CPUController 即可。

最后两种情况是继承有意义的地方。您希望 CPUController 和 GameController 具有相同的接口（当然每个接口都不同），以便主循环和 Player 可以与控制器的不同实现无缝协作。

如果您想了解有关这些设计原则的更多信息，请搜索 SOLID。这个例子就全部讲完了。 :-)

Answer 3

不，没有。您必须执行强制转换，否则编译器无法判断该函数是否存在。

如果子类的功能相同，那么您可以在接口中实现它们，并让子类实现这些功能并扩展基类。然后你可以简单地转换到接口，但你仍然必须进行转换。

Answer 4

为了避免强制转换，请考虑泛型：

class Base2<T extends Base1> { T base1; }

// base1 does not need to be cast to Base1Extends1
class Base2Extends1 extends Base2<Base1Extends1> { base1 = new Base1Extends1(); }

// base1 does not need to be cast to Base1Extends2
class Base2Extends2 extends Base2<Base1Extends2> { base1 = new Base1Extends2(); }