每个不可变的类都应该是最终的吗？

Question

我正在设计一个用于二十一点游戏的 Card 类。

我的设计是创建一个带有 getValue() 的 Card 类，该类返回 J 11、Q 12 和 K 13，然后使用 BlackjackCard 类扩展它以覆盖该方法，以便这些卡返回 10。

然后我突然想到：Card 类的对象应该是不可变的。所以我重新阅读了Effective Java 2nd Edition，看看该怎么做，我发现不可变类需要是final的，以避免子类破坏不可变性。

我也在网上查了一下，大家似乎都同意这一点。

那么 Card 类应该是最终的吗？

如何打破此类的不变性，扩展它：

class Card {
  private final Rank rank;
  private final Suit suit;
  public Card(Rank rank, Suit suit) {
    this.rank = rank;
    this.suit = suit;
  }
  public Rank getRank() {
    return rank;
  }
  public Suit getSuit() {
    return suit;
  }
  public int getValue() {
    return rank.getValue();
  }
}

谢谢。

Answer 1

子类实际上无法修改其父类中的 private final 属性的值，但它可以表现，就好像它已经修改一样，这就是 Effective Java 警告：

确保课程无法延长。
这可以防止粗心或恶意
子类免受损害
类的不可变行为
表现得好像对象的状态已经
改变了。

Answer 2

答案是肯定的，卡必须是最终的。

结合 K.Claszen 和 lwburk 的响应，请参阅以下内容：

public class MyCard extends Card {
    private Rank myRank;
    private Suit mySuit;

    public MyCard(Rank rank, Suit suit) {
        this.myRank = rank;
        this.mySuit = suit;
    }

    @Override public Rank getRank() { return myRank; }

    public void setRank(Rank rank) { this.myRank = rank; }

    @Override public Suit getSuit() { return mySuit; }

    public void setSuit(Suit suit) { this.mySuit = suit; }

    @Override public int getValue() { return myRank.getValue(); }
}

此扩展完全忽略父状态，并将其替换为自己的可变状态。现在，在多态上下文中使用 Card 的类不能依赖它的不可变性。

Answer 3

您可以这样做：

class MyCard extends Card {

  public MyCard(Rank rank, Suit suit) {
    super(rank, suit);
  }

  @Override
  public Rank getRank() {
    // return whatever Rank you want
    return null;
  }

  @Override
  public Suit getSuit() {
    // return whatever Suit you want
    return null;
  }

  @Override
  public int getValue() {
    // return whatever value you want
    return 4711;
  }

}

扩展类甚至不必声明与父类相同的构造函数。它可以有一个默认的构造函数，并且不关心父类的最终成员。 [该陈述是错误的 - 请参阅评论]。

Answer 4

当他们说不可变类应该是最终的时，他们指的是如何确保不变性，而不是因为某些东西是不可变的，所以它必须是最终的。这是一个很小的区别。如果您不希望延长课程时间，则应以最终决定为准。

Answer 5

总的来说，这是一个很好的建议。但是，如果您控制所有代码，那么有时能够扩展不可变类（可能使用附加信息创建另一个不可变类）会很有用。与大多数建议一样，您必须做出明智的选择，确定它们何时有意义、何时无效。

Answer 6

如果任意代码可以扩展不可变类，那么任意代码都可以生成行为与不可变类非常相似的对象，但不是不可变的。如果编写这种代码的人除了自己之外无法损坏任何东西，那么这种情况可能是可以容忍的。如果有人可以使用这样的类来绕过安全措施，那么就不应该容忍。

请注意，有时拥有一个可扩展的类会很有用，但它代表所有派生类保证不变性。当然，这样的类及其使用者必须依赖该类的继承者不要做任何奇怪的事情，但有时这种方法可能仍然比任何替代方法更好。例如，一个人可能有一个类，该类应该在某个特定时间执行某些操作，但该类的对象可以任意别名。如果该类、其任何字段、其任何派生类中的任何字段等都不能使用派生类型，则这样的类不会非常有用，因为类的定义将限制可以执行的操作类型执行。最好的方法可能是不将该类声明为最终类，但在文档中明确指出可变子类的行为将不一致或不可预测。

Answer 7

您可以有一个与游戏绑定的 Valuator 并从类中删除 getValue，这样 Card 就可以是final：

final class Card {
  private final Rank rank;
  private final Suit suit;
  public Card(Rank rank, Suit suit) {
    this.rank = rank;
    this.suit = suit;
  }
  public Rank getRank() {
    return rank;
  }
  public Suit getSuit() {
    return suit;
  }
}

评估器的工作方式如下：

interface CardValuator {
  int getValue(Card card);
}

class StandardValuator implements CardValuator {
  @Override
  public int getValue(Card card) {
    return card.getRank().getValue();
  }
}

class BlackjackValuator implements CardValuator {
  @Override
  public int getValue(Card card) {
    ...
  }
}

现在，如果您仍然想保留 Card 层次结构，请标记 Card 的方法 final 将阻止子类覆盖它们。