Java骰子游戏生成新数字时出现问题

我正在尝试学习OOP，从Java开始，正如我所读到的，并且有人告诉我这是最好的开始。话虽如此，我正在尝试创建一个有趣的游戏来帮助我学习，但我也知道游戏编程和设计可能更具挑战性

因此，我的目标是从RollDice D20生成一个新值，而无需重置或重新启动程序。您会注意到，当我打印出值时，我会打印同一个实例两次，以证明我在避免什么，并打印一个新实例，以表明新实例确实生成了一个新值。也许，我没有以正确的方式处理这一问题，但这是我希望通过一些帮助克服的障碍

我最终想要的是弄清楚如何生成一个新实例，或者至少是一个新的滚动值，只要我愿意。非常感谢您的任何帮助！我添加了下面的代码作为示例。此外，任何其他反馈也将不胜感激

import java.util.Random;

class RollDice
{// Begin RollDice Class


    // Initiate method rollDice
    public static int rollDice(int number, int nSides)
    {
        // System.out.println( "--- Welcome to the Dice Game v2! ---" ); //
        // welcomes player

        Random r = new Random();
        // Declare class variables
        int num = 0;
        int roll = 0;

        if (nSides >= 3)
        {
            for (int i = 0; i < number; i++)
            {
                roll = r.nextInt(nSides) + 1;
                // System.out.println("Roll is: " + roll);
                num = num + roll;
            }
        }

        else
        {
            System.out.println("Error num needs to be from 3");
        }
        return num;
    } // end method rollDice

    int d4 = rollDice(1, 4);
    int d6 = rollDice(1, 6);
    int d8 = rollDice(1, 8);
    int d10 = rollDice(1, 10);
    int d12 = rollDice(1, 12);
    int d20 = rollDice(1, 20);

    public RollDice()

    {
        this.d4 = d4;
    }

    public void setD4(int D4)
    {
        this.d4 = D4;
    }

    public int getD4()
    {
        return d4;
    }

    // ////////////////
    {
        this.d6 = d6;
    }

    public void setD6(int D6)
    {
        this.d6 = D6;
    }

    public int getD6()
    {
        return d6;
    }

    // ////////////////
    {
        this.d8 = d8;
    }

    public void setD8(int D8)
    {
        this.d8 = D8;
    }

    public int getD8()
    {
        return d8;
    }

    // ////////////////
    {
        this.d10 = d10;
    }

    public void setD10(int D10)
    {
        this.d10 = D10;
    }

    public int getD10()
    {
        return d10;
    }

    // ////////////////
    {
        this.d12 = d12;
    }

    public void setD12(int D12)
    {
        this.d12 = D12;
    }

    public int getD12()
    {
        return d12;
    }

    // ////////////////
    {
        this.d20 = d20;
    }

    public void setD20(int D20)
    {
        this.d20 = D20;
    }

    public int getD20()
    {
        return d20;
    }
    // ////////////////
}// End RollDice Class

class Champion
{// Begin Champion Class

    RollDice champDice = new RollDice();
    int champroll = champDice.getD20();

    public Champion()
    {
        this.champroll = champroll;
    }

    public void setChampRoll(int ChampRoll)
    {
        this.champroll = ChampRoll;
    }

    public int getChampRoll()
    {
        return champroll;
    }
}// End Champion Class

public class DiceRollTest
{
    public static void main(String ars[])
    {
        Champion tChampion = new Champion();
        Champion pChampion = new Champion();
        System.out.println("Your Champion defends with a " + tChampion.getChampRoll() + "\n");
        System.out.println("Your Champion defends with a " + tChampion.getChampRoll() + "\n");
        System.out.println("Your Champion defends with a " + pChampion.getChampRoll() + "\n");
    }
}

import java.util.Random；
类滚动骰子
{//Begin RollDice类
//初始化方法rollDice
公共静态int rollDice（int编号，int nSides）
{
//System.out.println（“--欢迎来到骰子游戏v2！”//
//欢迎玩家
随机r=新随机（）；
//声明类变量
int num=0；
int roll=0；
如果（nSides>=3）
{
for（int i=0；i

您的RollDice类没有完成您想要的任务。它所做的只是为您拥有的每种类型的骰子存储一个骰子掷骰结果。因此，当您对Champion对象调用getChampRoll（）时，它所做的只是返回在构建RollDice类时已经发生的掷骰

相反，应该使rollDice（）成为rollDice类的成员函数。然后，RollDice应该在其构造函数中接受一个参数，该参数指示在调用RollDice（）时应该滚动哪个骰子。这样，当您调用getD20（）时，它将滚动D20并给出结果

我将以此作为起点：

import java.util.Random;

public class Die {

    private int mSides;
    private Random mRandom;

    public Die(int sides) {
        this.mSides = sides;
        mRandom = new Random(System.currentTimeMillis());
    }

    public int roll() {
        return mRandom.nextInt(mSides + 1);
    }

    public int roll(int times) {
        int sum = 0;
        for (int i = 0; i < times; i++) {
            sum += roll();
        }
        return sum;
    }
}

import java.util.Random；
公共级模具{
私有int-mSides；
私有随机域；
公共模具（内部侧）{
this.mSides=边；
mRandom=新随机（System.currentTimeMillis（））；
}
公共int roll（）{
返回mRandom.nextInt（mSides+1）；
}
公共整数滚动（整数次）{
整数和=0；
for（int i=0；i

---

该类可以为您想要创建的每个骰子继承/子类化。然后你可以把其中一些扔到冠军的口袋里：）

你的掷骰子课没有完成你想要的。它所做的只是为您拥有的每种类型的骰子存储一个骰子掷骰结果。因此，当您对Champion对象调用getChampRoll（）时，它所做的只是返回在构建RollDice类时已经发生的掷骰

相反，应该使rollDice（）成为rollDice类的成员函数。然后，RollDice应该在其构造函数中接受一个参数，该参数指示在调用RollDice（）时应该滚动哪个骰子。这样，当您调用getD20（）时，它将滚动D20并给出结果

我将以此作为起点：

import java.util.Random;

public class Die {

    private int mSides;
    private Random mRandom;

    public Die(int sides) {
        this.mSides = sides;
        mRandom = new Random(System.currentTimeMillis());
    }

    public int roll() {
        return mRandom.nextInt(mSides + 1);
    }

    public int roll(int times) {
        int sum = 0;
        for (int i = 0; i < times; i++) {
            sum += roll();
        }
        return sum;
    }
}

import java.util.Random；
公共级模具{
私有int-mSides；
私有随机域；
公共模具（内部侧）{
这是mSides
public int roll(){
    return rand.nextInt(x);
}

public int roll(int x){
    return rand.nextInt(x);
}