我正在尝试使用Java对象创建一个简单的数学游戏。我的目标是创建一个问题类，其中包含一个使用随机数显示问题的方法，一种检查答案的方法以及一个问题结构。 如何使用这些对象生成10个随机问题？带有加法，减法和乘法问题。并在最后打印多少个正确答案。
我已经创建了我的问题类，并且我的第一种方法使用变量“ a”和“ b”显示了一个随机问题。并存储答案。 我的第二种方法用用户输入检查答案并打印结果。到目前为止，当我运行程序时，它只会一遍又一遍地显示相同的问题。
这是我的Question类
import java.util.*;
public class Question {
private int a;
private int b;
private String Question;
private int correct;
Random rand = new Random();
Scanner input = new Scanner(System.in);
int count = 0;
Question(int c, int d) {
x = rand.nextInt(20);
y = rand.nextInt(20);
}
public void askQuestion() {
if (a > b) {
System.out.println("What is " + a + " - " + b + " ?\n");
correct = a - b;
} else {
System.out.println("What is " + a + " + " + b + " ?\n");
correct = a + b;
}
}
public void Check() {
int response = Integer.parseInt(input.next());
if (response == correct) {
System.out.printf("yes.\n");
count++;
} else {
System.out.printf("No. It is " + correct + ".\n");
}
}
}
我的主要方法如下
public class Main {
public static void main(String[] args) {
Question q1 = new Question(1,2);
for (int i = 1; i < 10; i++) {
q1.askQuestion();
q1.check();
}
}
}
在我的输出中，它显示了带有两个随机数的问题，但是它一次又一次地打印相同的问题。例如：
What is 13 - 1 ?
12
That is correct.
What is 13 - 1 ?
12
That is correct.
What is 13 - 1 ?
3
Wrong!. The answer is 12.
What is 13 - 1 ?
最终我希望我的输出看起来像：
What is 4 + 6?
What is 7 - 3?
有任何解决方法吗？并使游戏更具互动性？赞赏。
答案 0 :(得分：0)
您的问题是由于您正在创建一个问题对象，该对象会生成两个随机数（在您的情况下为13和1）。然后，您将经历一个询问10个问题的循环，但是您使用相同的Question对象-因此每次都使用相同的随机数。要解决此问题，请进行以下更改：
在您的Question构造函数中，摆脱掉参数，您不需要它们。分配给变量a和b：
private Question(){
a = rand.nextInt(20);
b = rand.nextInt(20);
}
因此，每次创建问题时，都会生成两个随机数，这些随机数将分配给您在顶部的代码中先前声明的变量（在您的代码中，声明a和b ，但未使用）。
然后在您的主目录中，将其更改为以下内容：
public static void main(String[] args) {
for(int i = 0; i < 10; i++) {
Question q1 = new Question();
q1.askQuestion();
q1.check();
}
System.out.println("Number correct: " + count); //print amount correct, to use this make variable "count" static.
}
更改是，现在每次循环时您都在创建一个新的Question对象，并获得新的随机值。每次询问新问题时，都会创建一个具有新随机值的新Question对象，并覆盖旧值。输入并确认答案后，它将询问10次，然后程序将输出正确答案的数量并停止。
3个问题的示例输出：
What is 17 - 15 ?
2
yes.
What is 8 + 11 ?
19
yes.
What is 9 - 0 ?
5
No. It is 9.
Number correct: 2
答案 1 :(得分：0)
如果您想要一种使用随机数和运算符动态地提出问题的方法，则可以创建一个Operator枚举，如下所示，以处理左手值和右手值的计算结果。
此外，对System.out.print的调用应尽可能在主程序中。相反，您应该从Question返回字符串。
您需要做的就是将两个随机生成的数字传递给Operator枚举，并要求其计算结果。
package exam;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Exam {
private static int correctCount = 0;
private static List<Question> questions = randomQuestions(10);
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
questions.stream().forEach(question -> ask(question, input));
input.close();
stats();
}
private static void ask(Question question, Scanner input) {
System.out.print(question.askQuestion());
double guess = input.nextDouble();
boolean isCorrect = question.makeGuess(guess);
System.out.println(question.explain(isCorrect));
System.out.println();
correctCount += isCorrect ? 1 : 0;
}
private static void stats() {
double percentage = (correctCount * 1.0d) / questions.size() * 100;
System.out.printf("Correct: %.2f%% (%d/%d)%n", percentage, correctCount, questions.size());
}
private static List<Question> randomQuestions(int count) {
List<Question> questions = new ArrayList<Question>();
while (count --> 0) questions.add(new Question());
return questions;
}
}
package exam;
import java.util.Random;
public class Question {
private static final Random RAND = new Random(System.currentTimeMillis());
private double left;
private double right;
private Operator operator;
public Question(double left, double right, Operator operator) {
this.left = left;
this.right = right;
this.operator = operator;
}
public Question(int max) {
this(randInt(max), randInt(max), Operator.randomOperator());
}
public Question() {
this(10); // Random 0 -> 10
}
public String askQuestion() {
return String.format("What is %s? ", operator.expression(left, right));
}
public String explain(boolean correct) {
return correct ? "Correct" : String.format("Incorrect, it is: %.2f", calculate());
}
public boolean makeGuess(double guess) {
return compareDouble(guess, calculate(), 0.01);
}
private double calculate() {
return operator.calculate(left, right);
}
@Override
public String toString() {
return String.format("%s = %.2f", operator.expression(left, right), calculate());
}
private static boolean compareDouble(double expected, double actual, double threshold) {
return Math.abs(expected - actual) < threshold;
}
private static double randInt(int range) {
return Math.floor(RAND.nextDouble() * range);
}
}
package exam;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public enum Operator {
ADD("+", (left, right) -> left + right),
SUB("-", (left, right) -> left - right),
MUL("*", (left, right) -> left * right),
DIV("/", (left, right) -> left / right);
private static final Random RAND = new Random(System.currentTimeMillis());
private static final List<Operator> VALUES = Collections.unmodifiableList(Arrays.asList(values()));
private static final int SIZE = VALUES.size();
public static Operator randomOperator() {
return VALUES.get(RAND.nextInt(SIZE));
}
private String symbol;
private Operation operation;
private Operator(String symbol, Operation operation) {
this.symbol = symbol;
this.operation = operation;
}
public double calculate(double left, double right) {
return operation.calculate(left, right);
}
public String expression(double left, double right) {
return String.format("%.2f %s %.2f", left, symbol, right);
}
@Override
public String toString() {
return symbol;
}
}
package exam;
public interface Operation {
double calculate(double left, double right);
}