Question

假设我创建了以下类：

public enum Position {

   Dealer(1), //1
   SB(2),     //2
   BB(3),     //3
   UTG(4),    //4
   UTG1(5),   //5
   UTG2(6),   //6
   UTG3(7),   //7
   HJ(8),     //8
   CO(9);     //9

   //Constructor
   int code;

   Position(int code) {
     this.code = code;
   }
}

如何使用括号中的数字来操作ENUM？例如，在我的扑克桌课程中，我发起新玩家。每个玩家都传递参数Position。所以最初，

player[1].getPosition() = Dealer  
player[2].getPosition() = SB  
player[3].getPosition() = BB   
etc etc etc

手牌结束后，所有位置需要翻转一个所以玩家[1]需要有CO（9）位置玩家[2]需要有经销商（1）的位置玩家[3]需要有SB（2）位置等等

我知道我可以通过数字1到9来循环变量循环，但是如何根据PositionENUM中的整数访问位置？

编辑：我已经有了吸气剂和制定者。

    public int getCode() {
        return code;
    }
    public void setCode(int code) {
        this.code = code;
    }

然而，吸气者和击球手并没有让我每轮都正确地改变球员的位置。

每轮下注后，我需要更改每个玩家的位置，所以我需要弄清楚如何在每轮下注后改变每个玩家的ENUM位置。

Answer 1

可以根据代码的值选择枚举实例。您可以使用静态Map<Integer, Position>来执行此操作。唯一的问题是它必须被安置在一个静态的内部类中：

public enum Position {

    ...

    Position(int code) {
        this.code = code;
        MapHolder.BY_CODE.put(code, this);
    }

    private static class MapHolder {
        private static final Map<Integer, Position> BY_CODE = new HashMap<Integer, Position>();
    }

    public static Position findByCode(int code) {
        return MapHolder.BY_CODE.get(code);
    }

我还建议将选择下一个位置的逻辑委托给枚举本身。只需将此方法添加到Position枚举：

即可

public Position nextPosition() {
     return findByCode((this.code + 1) % Position.values().length);
}

然后，您的客户端代码可以直接执行：

for (Player player : players) {
    player.setPosition(player.getPosition().nextPosition());
}

Answer 2

看这里是一个onlinepoker游戏样本

    #include <iostream>
#include <stdlib.h>
#include <cctype>
#include <memory.h>
#include "logic.h"

using namespace std;
// & means location
// * value of location

struct Cards {

enum Value {Two = 2, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace};
Value V;
int Suite;
enum Suite {Hearts, Diamonds, Clubs, Spades};
};

struct Hand {
Cards [5];

};

struct Deck {
Cards [52];

};

char * personsName [20]; //this means location with *
int numNames = 0;
char * Name;
char * search;
bool Continue;

int main ()
{
do {
for(int x = 0; x < 20; x++){
cout << "Enter a name, type END to stop: ";
Name = readString ();

if(strcmp (Name, "END") != 0){
personsName [x] = Name;
numNames++;
}
else{
Continue = (strcmp (Name, "END") != 0);
break;
}

}
cout << "Pre-sorted Names" << endl;
printNames(personsName,numNames);

bubbleSort(personsName,numNames);

cout << "Post-sorted Names" << endl;
printNames(personsName,numNames);

cout << "What would you like to find?" << endl;
search = readString();
cout << "The name is at index " << binarySearch(personsName,search,numNames) << endl;

} while (Continue);
delete [] * personsName;
return 0;
}

Answer 3

我不确定我是否正确理解了您的问题，但您可以为您的枚举声明getCode()方法：

public enum Position {

  Dealer(1), //1
  SB(2),     //2
  BB(3),     //3
  UTG(4),    //4
  UTG1(5),   //5
  UTG2(6),   //6
  UTG3(7),   //7
  HJ(8),     //8
  CO(9);     //9

  int code;

  //Constructor
  Position(int code) {
    this.code = code;
  }

  public int getCode() {
    return code;
  }
}

Answer 4

code是包访问范围。

如果你在包裹内打电话，那么你可以做一个

Position.BB.code

如果你从包外面打电话，那么你可能需要在枚举类中提供一个访问器。

public int getCode(){
    return this.code;
}

Answer 5

你可以使用ordinal（）作为位置（从下标开始，就像下标一样）。如果枚举以相反的顺序（因为交易传递到左边）可能会更容易，就像下面的代码一样。这在短暂的游戏中是行不通的（你需要以玩家的数量为模数）。

enum Position {
    Dealer, CO, HJ, UTG3, UTG2, UTG, BB, SS;
    Position next() {
        return values()[(ordinal() + 1) % values().length];
    }
}
class Player {
    Player(Position position) {
        this.position = position;
    }
    void next() {
        position = position.next();
    }
    Position position;
}
public class Main {
    public static void main(String[] args) {
        Player[] players = new Player[Position.values().length];
        for (Position position : Position.values())
            players[position.ordinal()] = new Player(position);
        for (Player player : players)
            System.out.println(player.position);
        for (int i = 0; i < Position.values().length; i++)
            for (Player player : players)
                player.next();
        for (Player player : players)
            System.out.println(player.position);
    }
}

Answer 6

我不太确定这是否是您的要求。请参阅下面给出的代码有助于：

public enum Position {

    Dealer(1), // 1
    SB(2), // 2
    BB(3), // 3
    UTG(4), // 4
    UTG1(5), // 5
    UTG2(6), // 6
    UTG3(7), // 7
    HJ(8), // 8
    CO(9); // 9

    // Constructor
    int code;

    Position(int code) {
        this.code = code;
    }

    private static Position[] currentPosition = Position.values();

    public static Position[] getCurrentPosition() {
        return currentPosition;
    }

    private static List<Position> positionWrap = Arrays.asList(currentPosition);

    public static void shiftPostion() {
        Collections.rotate(positionWrap, 1);
        updatePositions();
    }

    private static void updatePositions() {
        for (int i = 0; i < currentPosition.length; i++){
            currentPosition[i].code = i + 1;
        }
    }

    public static void main(String[] args) {
        Position[] pos = getCurrentPosition();
        System.out.println(Arrays.toString(pos));
        Position.shiftPostion();
        System.out.println(Arrays.toString(pos));
        Position.shiftPostion();
        System.out.println(Arrays.toString(pos));

    }

    @Override
    public String toString() {

        return this.name() + "(" + code + ")";
    }
}

（如何操纵）使用ENUM进行扑克定位

6 个答案: