Question

在这个扑克游戏代码中，我正在尝试创建一个Card类。但是，我想使用enum类型而不是constant，因为我听说它更好。唯一的问题是我多次尝试将suit的实例值和它们为faceValue变量的int分配给enum类型变量，但它表示不兼容的类型。怎么了？

public class Card {

    final static int MAX_SUITS = 4;
    final static int MAX_FACE_VALUES = 13;

    private int suit;
    private int faceValue;

    enum Suit {HEARTS, DIAMONDS, SPADES, CLUBS}
    enum Face {ACE, JACK, QUEEN, KING}

    public Card(int suit, int faceValue) {
        this.suit = suit;
        this.faceValue = faceValue;
    }

    public int getSuit() {
        if (suit == 0) {
            return suit = Suit.HEARTS; break;
        else if (suit == 1)
            return suit = Suit.DIAMONDS; break;
        else if (suit == 2)
            return suit = Suit.SPADES; break;
        else if (suit == 3)
            return suit = Suit.CLUBS; break;
    }

    public int getFaceValue() {
        if (faceValue == 1)
            return faceValue = Face.ACE; break;
         else if (faceValue == 11)
            return faceValue = Face.JACK; break;
         else if (faceValue == 12)
            return faceValue = Face.QUEEN; break;
         else if (faceValue == 13)
            return faceValue = Face.KING; break;
    }

    public void setFaceValue(int faceValue) {
        this.faceValue = faceValue;
    }

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

    @Override
    public String toString() {
        if (suit > MAX_SUITS || faceValue > MAX_FACE_VALUES)
            return "invalid entry";
        else if((suit < 0 || faceValue < 0))
            return "invalid entry";
        else
            return faceValue + " of " + suit;
    }
}

Answer 1

如何将枚举变量赋值给数值变量？

你做不到。您必须重构并更改int（代表诉讼时）对Suit的所有使用。

Answer 2

我犹豫了写这个答案，因为它击败了枚举的整个目的，并且没有意义来创建任何形式的＆＃34;映射＆＃34;在int值和enum常量之间。

不要这样做。

执行其他人的建议：将int值替换为相应的enum常量。然后你也不会需要MAX_SUITS等等这些丑陋的变通办法。

Card类的一个（相对）干净的实现可能如下所示：

public class Card {

    public static void main(String[] args)
    {
        Card c0 = new Card(Suit.HEARTS, Face.ACE);
        Card c1 = new Card(Suit.DIAMONDS, Face.QUEEN);
        System.out.println(c0);
        System.out.println(c1);
    }

    private final Suit suit;
    private final Face face;

    enum Suit {HEARTS, DIAMONDS, SPADES, CLUBS}
    enum Face {ACE, JACK, QUEEN, KING}

    public Card(Suit suit, Face face) {
        this.suit = suit;
        this.face = face;
    }

    public Suit getSuit() {
        return suit;
    }

    public Face getFace() {
        return face;
    }

    @Override
    public String toString() {
        return getFace() + " of " + getSuit();
    }
}

但是，仍然回答这个问题：可以使用内置方法在int和enum值之间建立映射。您可以使用Enum#ordinal方法获取int，使用（隐式）Enum#values方法获取可以使用int作为访问的常量数组索引。

所以不推荐实现它的方式可能就是这样：

public class Card {

    public static void main(String[] args)
    {
        Card c0 = new Card(Suit.HEARTS.ordinal(), Face.ACE.ordinal());
        Card c1 = new Card(Suit.DIAMONDS.ordinal(), Face.QUEEN.ordinal());
        System.out.println(c0);
        System.out.println(c1);
    }

    final static int MAX_SUITS = 4;
    final static int MAX_FACE_VALUES = 13;

    private int suit;
    private int faceValue;

    enum Suit {HEARTS, DIAMONDS, SPADES, CLUBS}
    enum Face {ACE, JACK, QUEEN, KING}

    public Card(int suit, int faceValue) {
        this.suit = suit;
        this.faceValue = faceValue;
    }

    public int getSuit() {
        return suit;
    }

    public int getFaceValue() {
        return faceValue;
    }

    public Suit getSuitEnum() {
        return Suit.values()[suit];
    }

    public Face getFaceValueEnum() {
        return Face.values()[faceValue];
    }

    public void setFaceValue(int faceValue) {
        this.faceValue = faceValue;
    }

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

    @Override
    public String toString() {
        if (suit > MAX_SUITS || faceValue > MAX_FACE_VALUES)
            return "invalid entry";
        else if((suit < 0 || faceValue < 0))
            return "invalid entry";
        else
            return getFaceValueEnum() + " of " + getSuitEnum();
    }
}

编辑：我想混淆来自于你想要存储＆＃34;面值＆＃34;作为一个枚举，并且只有一些面值的枚举常量（而其他的只是int，从2到10）。换句话说：将面值存储为枚举可能不是一个好主意......

Answer 3

另一种不推荐的做法你想要的方法：（我刚刚编写了这个代码，并没有运行它，所以对于任何拼写错误道歉：

public enum Suit {

  HEARTS( 1 ),
  DIAMONDS( 2 ),
  SPADES( 3 ),
  CLUBS( 4 );

  private int id = -1;

  public Suit( int id ) {
    this.id = id;
  }

  public int getId() {
    return id;
  }

  public static Suit parse( int suitId ) {
    for( Suit s : values() ) {
      if( s.getId() == suitId ) {
        return s;
      }
    }
    return null;
  }
}



public enum Face {

  ACE( 11 ),
  JACK( 12 ),
  QUEEN( 13 ),
  KING( 14 );

  private int val = -1;

  public Face( int val ) {
    this.val = val;
  }

  public int getVal() {
    return val;
  }

  public static Face parse( int faceVal ) {
    for( Face f : values() ) {
      if( f.getVal() == faceVal ) {
        return f;
      }
    }
    return null;
  }
}


public class Card {

    final static int MAX_SUITS = 4;
    final static int MAX_FACE_VALUES = 13;

    private Suit suit;
    private Face faceValue;

    public Card(int suit, int faceValue) {
        setSuit( suit );
        setFaceValue( faceValue );
    }

    public int getSuit() {
        return suit.getId();
    }

    public int getFaceValue() {
        return face.getVal();
    }

    public void setFaceValue(int faceValue) {
        this.faceValue = Face.parse( faceValue );
    }

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

    ...
}

但是在这种情况下你基本上使用枚举作为整数存储。卡片上的外部演员基本上只在整数方面与它互动，所以使用枚举纯粹是内部的，在这里有点无意义。

关于getSuit()和getFaceValue()的初始实现的另一点 - 我认为您可能打算在那里使用切换（break＆＃39}没有巨大的效果在那些if/else＆＃39; s中：

Suit returnVal;

switch( suit ) {
  case 0: returnVal = Suit.HEARTS; 
          break;
  case 1: returnVal = Suit.DIAMONDS; 
          break;
  case 2: returnVal = Suit.SPADES; 
          break;
  case 3: returnVal = Suit.CLUBS; 
          break;
  default: returnVal = null;
           break;
}

return returnVal;

如何将枚举变量赋给数值变量？ Java的

3 个答案: