java - 抽象类中的枚举

Question

我试图弄清楚如何在扩展公共(public)抽象类的不同类中使用枚举。

简单的例子:

卡类

public class Card {
    private String name;
    private String value;
    private String suit;

   public Card(String name, String value, String suit) {
        this.value = value;
        this.suit= suit;
    }
}

抽象甲板类

public abstract class Deck {
    private enum SUITS{

    }

    private enum VALUES{

    }
    private int cardNumber;
    private ArrayList<Card> cardList;

    public Deck(VALUES valori,SUITS semi){
        ArrayList<Card> clist = new ArrayList<>();
        for (SUITS s: semi.values()){
            for (VALUES v: valori.values()){
                cardList.add(new Card(v.toString(),s.toString()));
            }
        }
        cardNumber = cardList.size();
    }

类布里斯科拉甲板

public class CarteBriscolaDeck extends Deck {
   private enum SUITS{
        COPPE,
        DENARE,
        BASTONI,
        SPADE
    }

    private enum VALUES{
        ASSO,
        DUE,
        TRE,
        QUATTRO,
        CINQUE,
        SEI,
        SETTE,
        FANTE,
        CAVALLO,
        RE
    }

    public CarteBriscolaDeck(){
        super(VALUES,SUITS);
    }
}

扑克牌类

public class PokerDeck extends Deck {
   private enum SUITS{
       SPADES,
       HEARTS,
       DIAMONDS,
       CLUBS
   }

    private enum VALUES{
        ACE,
        TWO,
        THRRE,
        FOUR,
        FIVE,
        SIX,
        SEVEN,
        EIGHT,
        NINE,
        TEN,
        JACK,
        QUEEN,
        KING
    }

    public PokerDeck(){
        super(VALUES,SUITS);
    }
}

我做对了吗？是否可以优化？

先感谢您。

Answer 1

您不能声明 enum在要被子类覆盖的基类中，如 enum s 总是隐含的 final .此外，子类’enum s 不能扩展任意类型，它们总是隐式扩展 java.lang.Enum .

您可以做的是声明 interface在子类的基类中'enum将实现。但是由于您没有在枚举中指定任何可以抽象的功能，因此(目前)没有任何意义。另一种方法是为基类指定类型参数，子类将用它们的实际类型填充这些参数。

要解决的另一件事是使用“套件”和“值”类型而不是 String在您的 Card 中类，因为在那里使用字符串会破坏使用的全部优势 enum s。

例如。

public final class Card<S,V> {
    final S suit;
    final V value;
    public Card(S suit, V value) {
        this.suit = suit;
        this.value = value;
    }
    @Override
    public String toString() {
        return suit+" "+value;
    }
}
public class Deck<S extends Enum<S>,V extends Enum<V>> {
    protected final Set<S> allSuits;
    protected final Set<V> allValues;
    protected final List<Card<S,V>> allCards;

    public Deck(Class<S> suitType, Class<V> valueType) {
        Set<S> suits =EnumSet.allOf(suitType);
        Set<V> values=EnumSet.allOf(valueType);
        List<Card<S,V>> cardList=new ArrayList<>(suits.size()*values.size());
        for(S suite: suits){
            for(V value: values) {
                cardList.add(new Card<>(suite, value));
            }
        }
        allSuits =Collections.unmodifiableSet(suits);
        allValues=Collections.unmodifiableSet(values);
        allCards =Collections.unmodifiableList(cardList);
    }

    @Override
    public String toString() {
        return getClass().getSimpleName()+allCards;
    }
}
public class PokerDeck extends Deck<PokerDeck.Suits,PokerDeck.Values> {
    enum Suits  { SPADES, HEARTS, DIAMONDS, CLUBS }
    enum Values { ACE, TWO, THREE, FOUR, FIVE, SIX, SEVEN,
                  EIGHT, NINE, TEN, JACK, QUEEN, KING }

    public PokerDeck(){
        super(Suits.class, Values.class);
    }
}
public class CarteBriscolaDeck
       extends Deck<CarteBriscolaDeck.Suits,CarteBriscolaDeck.Values> {
    enum Suits  { COPPE, DENARE, BASTONI, SPADE }
    enum Values { ASSO, DUE, TRE, QUATTRO, CINQUE, SEI, SETTE, FANTE, CAVALLO, RE }

    public CarteBriscolaDeck(){
        super(Suits.class, Values.class);
    }
}