根据 2 个输入参数的子类型更改方法行为

Question

我正在尝试创建一个具有干净类设计的纸牌游戏。 我想比较 2 张卡片并返回具有最高“价值”的一张。

我有一个抽象卡片类和从它继承的 2 个类：

    public abstract class Card {
      ...
      //common method
      public int getCardValue() { return this.cardValue; }
      //comparison methods
      public abstract Card compare(ColoredCard card);
      public abstract Card compare(TrumpCard card);
    }

    public class ColoredCard extends Card {
      //specific attribute
      private Color cardColor;
      ...
      //specific method
      public Color getColor() { return this.cardColor; }

      public Card compare(ColoredCard card) {
        if(this.getColor() == card.getColor())
          return this.getCardValue() > card.getCardValue() ? this : card;
        return this;
      }

      public Card compare(TrumpCard card) {
        return card;
      }
    }

    public class TrumpCard extends Card {
      ...
      public Card compare(ColoredCard card) {
        return this;
      }

      public Card compare(TrumpCard card) {
        return this.getCardValue() > card.getCardValue() ? this : card;
      }
    }

但是每当我尝试时它仍然会抛出错误：

Card c = new ColoredCard(5);
Card c2 = new TrumpCard(1);
c.compareTo(c2); //error method compareTo not applicable to type of argument "Card"

我需要访问整个子类接口来进行我的每个比较，但也要保持比较调用“通用”（通过 Card 超类）。

如果可能，我想避免使用instanceOf指令或反射。

谢谢，

Answer 1

如果可能的话，我会在基类上定义一个抽象方法，让子类提供它们的绝对值。 然后，您可以使基类Comparable并实现使用此值的compareTo()方法。 其价值甚至不需要公开披露。

public static abstract class Card implements Comparable<Card> {

    @Override
    public int compareTo(Card other) {
        return Integer.compare(this.value(), other.value());
    }

    protected abstract int value();
}

public static class ColoredCard extends Card {

    @Override
    protected int value() {
        return 1;
    }
}

public static class TrumpCard extends Card {

    @Override
    protected int value() {
        return 10;
    }
}

public static void main(String... args) throws Exception {
    System.out.println(new TrumpCard().compareTo(new ColoredCard()));
    System.out.println(new ColoredCard().compareTo(new TrumpCard()));
}

印刷：

1
-1

如果这不好，那么您将需要使用instanceof或诸如访问者模式之类的东西或重新考虑设计。

例如，您可以重新设计，而不是为每张卡片设置一个单独的类，而是将卡片类型作为一个字段（可能使用枚举）。 然后当您比较两张卡时，您可以比较两张卡的种类，不需要使用instanceof并且可以合并您喜欢的任何逻辑。

例如

public static enum Kind {
    COLORED,
    TRUMP;
}

public static class Card {
    private final Kind kind;

    public Card(Kind kind) {
        this.kind = kind;
    }

    public Kind kind() {
        return kind;
    }
}

public static void main(String... args) throws Exception {
    Card trumpCard = new Card(Kind.TRUMP);
    Card coloredCard = new Card(Kind.COLORED);

    int i = compare(trumpCard, coloredCard);
}

public static int compare(Card card, Card other) {
    if (card.kind().equals(other.kind())) {                
        return 0;
    }
    if (card.kind().equals(Kind.TRUMP)) {
        return 1;
    }
    return -1;
}

Answer 2

所以我找到了一种使用访问者模式的方法：

public interface ICardVisitor {
    public Card visit(TrumpCard card);
    public Card visit(ColoredCard card);
    public void setSecondCard(ColoredCard card);
    public void setSecondCard(TrumpCard card);
}

public class ComparisonVisitor implements ICardVisitor {
    private TrumpCard trumpCard;
    private ColoredCard coloredCard;
    ...
    //contains comparison logic & instances of card subtypes
}

我还必须向我的抽象 Card 类添加一个额外的函数（除了经典的 accept(Visitor v) 方法）：

public abstract void setThisCardAsParameter(ICardVisitor v);

在具体的 Card 实现中：

public Card accept(ICardVisitor visitor) {
    return visitor.visit(this);
}

public void setThisCardAsParameter(ICardVisitor v) {
    v.setSecondCard(this);
}

这样比较类就知道每张卡片的每个子类型，因此他可以访问给定子类的所有特定方法。 电话看起来像这样：

public static void main(String [] args) {
    ICardVisitor cmp = new ComparisonVisitor();
    Card c = new TrumpCard(1);
    Card c2 = new ColoredCard(CardTypes.SPADES,1);
    ICardVisitor cmp = new ComparisonVisitor();
    c.setThisCardAsParameter(cmp);
    Card winningCard = c2.accept(cmp);
}

如果该设计不好或可以改进，请告诉我！