Question

在完成Monopoly类型的基于文本的游戏时，我在使用Java将可变数据从类转移到类时遇到了一些问题。

我一直在尝试将roll1和roll2变量从Dice类传输到Board Class，但由于某种原因，数据没有正确传输，当我从2 Rollin the Board类返回组合数据时，它只是回到了0。

以下是我的课程：

Exception in thread "main" java.lang.StackOverflowError
    at java.util.HashMap$KeyIterator.<init>(HashMap.java:1459)
    at java.util.HashMap$KeySet.iterator(HashMap.java:916)
    at java.util.HashSet.iterator(HashSet.java:172)
    at java.util.AbstractSet.hashCode(AbstractSet.java:122)
    at java.util.AbstractSet.hashCode(AbstractSet.java:126)
    at java.util.AbstractSet.hashCode(AbstractSet.java:126)
    at java.util.AbstractSet.hashCode(AbstractSet.java:126)
    at java.util.AbstractSet.hashCode(AbstractSet.java:126)

public class Dice {

    static int dots, roll1, roll2, flag;
    Random number = new Random();

    public Dice(){
         dots = number.nextInt(6)+1 ;
    }

    public void roll1(){
        roll1 = number.nextInt(dots)+1;
    }

    public void roll2(){
        roll2 = number.nextInt(dots)+1;
    }

    public int getDots1(){
        return roll1;
    }

    public int getDots2(){
        return roll2;
    }

    public String getSame(){
        if(roll1 == roll2){
            flag++;
            return("Your rolls were the same");
        }
        else{
            return(" ");
        }

    }
}

public class Board {
    static int roll1 = Dice.roll1;
    static int roll2 = Dice.roll2;
    public static int i;
    public int Turn = 0;
    public int totalP = 0;
    public static int Pos = 0;
    public static int[] Players= {1, 2, 3, 4};
    public static int[] Square = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25};
    public static int Money = 40000;
    static ArrayList<Integer> pPos = new ArrayList<Integer>();
    void pPosList(){}

    public Board(int totalP){
        this.totalP = totalP;
    }

    public static int getPos(){
           while(Money != 0){
           for(i=0;i<Players.length;i++){ 
               System.out.println("Player Turn: Player "+(i));
               Pos = Square[roll1 + roll2];
               pPos.set(0, Pos);
               return roll1;
           }
        }
    }
}

Answer 1

缩小你出错的地方的一种方法是检查你的课程结构，并问自己你是如何定义它们的（因为它们可能比他们需要的更复杂），并确保你'我们简化了缩小其要求的范围：

“骰子”的卷可能有限吗？

通常游戏决定你掷骰子的次数，以及你一次需要多少骰子，所以单个roll（）函数就足够了，Dice的数量由类使用它

骰子是否记得过去曾经做过的骰子，所以你可以稍后再问它曾经滚过的东西？（换句话说，你会掷骰子，用骰子甚至与你正在玩的游戏的其他部分进行一些其他动作，然后回来看看骰子滚动了什么？可能不是）。

游戏会立即使用游戏提供的价值并由游戏中的某些动作存储或使用，而不是游戏本身

如果您创建100个Dice实例，每个实例都有自己的Roll值，还是可以掷骰子24并期望在dice81上显示相同的值？

关于在全局/静态变量中存储成员值的提示

或者简而言之，是否会使用以下方法而不是来实现Dice类旨在提供的功能？

public getRoll() {
    return number.nextInt(6) + 1;
}
public boolean compareValues(int roll1, int roll2) {
    return roll1 == roll2;
}

奖金问题：什么是骰子旗？

接下来让我们看一下Board类：你要做的第一件事是存储值，或者Dice.roll1和Dice.roll2，它们是0，因为在属于Board的变量中还没有发生任何其他事情。您现在可以对Dice类执行任何操作，并且这两个属于Board的值不会受到影响。您可以采用与上述类似的方式剖析所有预期的功能：

董事会的实例是否只能获得2个骰子卷？

可能不是，所以不要使用静态变量

是否只有一个通用主板，如果不退出游戏并重新启动，游戏就无法再使用另一个主板？（否则所有这些Dice掷骰值仍然存在）

可能不是，你应该创建一个Board 的实例

更多东西，你可以进一步剖析

最后Blobfish ......看起来你指的是通用板，但创建了一个与Board没有关系的Dice实例，滚动它们并询问Board现在的玩家，这仍然是他们开始的地方因为你正在使用不同的骰子。

将现实生活中发生的所有事情写成短句，然后慢慢将其转换为Java，即游戏开始：每个玩家掷两个骰子，如果滚动是相同的说“yay”，然后移动玩家滚动的组合距离

变为：

// create the game, and a Dice for it
Board myGame = new Board();
Dice dice = new Dice();
int player = 0;

// roll the dice twice
int roll1 = dice.roll();
int roll2 = dice.roll();

// celebrate if the rolls double up
if (roll1 == roll2) {
    System.out.println("yay");
}
int distanceToMove = roll1 + roll2;

// move the player
myGame.movePlayer(player, distanceToMove);

每当你遇到困难时，请简化

Answer 2

你的代码的问题是你掷骰子但是你没有在Board类中更新骰子的值

这可能会解决您的问题，但不能解决您的布局问题。

public class Blobfish {

    public void main(String[] args) {
        System.out.println(" " +Board.getPos());
        Dice dice = new Dice();
        dice.roll1();
        dice.roll2();
        Board.roll1 = dice.getDots1();
        Board.roll2 = dice.getDots2();
        System.out.println("First Roll: " + dice.getDots1());
        System.out.println("Second Roll: " + dice.getDots2());
        System.out.println(dice.getSame());
        System.out.println("Your Current Position = " + Board.getPos());
    } 
}

您的代码布局不佳。我的意思是

您应该声明Board的实例而不是使用静态变量。即Board b = new Board(0);
并非所有内容都应该是静态的，因为通常应该通过类的实例访问变量，除非您使用单身人士
并非一切都应该是公开的。相反，应使用私有变量，然后通过Getters and Setters进行操作（换句话说，您想要查看encapsulation）
" " + someInt System.out.println(...)中不需要

实现我刚才谈到的大部分内容的示例类可能看起来像这样。

public class Test {
    //Private int that can be manipulated via the use of getters and setters.
    private int someInt;

    private Test() {
        someInt = 0;
    }

    //Setter
    public void setSomeInt(int valToSet) {
        someInt = valToSet;
    }

    //Getter
    public int getSomeInt() {
        return someInt;
    }

    public static void main(String[] args) {
        //Instance of Test
        Test t = new Test();

        //Updates the value of the instance
        t.setSomeInt(10);

        //Prints the value from that same instance
        System.out.println(t.getSomeInt());
    }
}

Answer 3

我认为你的课程需要稍微重新设计。 Board课程做得太多了。这是您可能会考虑的粗略设计：

// Represents a single die
Dice
    int roll()  // Returns 1-6

// A single player. Maintains its own position on board
Player
    int getPosition()
    void move(int numSpaces)
    int bankAccount = 200

// This will contain all the spaces and whatever actions
// happen on those spaces
Board
    ?? getAction(int spaceNumber)

Bank
    payAmount(int amount)
    receiveAmout(int amount)

// The manager class. Maintains the board and players and bank
Game
    Dice dice1, dice2
    Player players[4]
    Board board
    Bank bank
    void nextTurn()
        int roll1, roll2;
        do {
            roll1 = dice1.roll()
            roll2 = dice2.roll()
            players[currentPlayer].move(roll1 + roll2)
            board.getAction(players[currentPlayer].getPosition()]
        } while roll1 == roll2
        currentPlayer = (currentPlayer + 1) % 4

没有static个变量。 Game类管理所有其他类之间的交互。

在Java中将变量从类转移到类

3 个答案: