java - 从另一个类调用类时尝试获取新值

Question

我正在用 java 编写一个数学测验问题，基本上会问 10 个问题，并为用户提供 2 个问题 得到正确答案的机会。该程序还提出基于基本算术的问题， 减法、除法和乘法。 我的问题是当我运行该程序时，它运行良好，但稍后在程序中它会询问相同的问题 具有相同值的问题。如何让程序每次都使用新值 c类叫什么？ 我暂时留下了加、减、乘和除类。如果您需要它们，请告诉我 知道

 import java.util.Scanner;
 import java.math.*;


public class MathQ {
 public static void main(String[] args) {
    int credit = 0;
    int firstTry = 0;
    int secondTry = 0;
    int wrong = 0;
    System.out.print("What's your name?");
    Scanner sc = new Scanner(System.in);
    String name = sc.next();
    AdditionProblem q1 = new AdditionProblem();
    SubtractionProblem q2 = new SubtractionProblem();
    MultiplicationProblem q3 = new MultiplicationProblem();
    DivisionProblem q4 = new DivisionProblem();

    System.out.println("Nice to meet you , " + name + "!");
    System.out.println("**************MATH CHALLENGE*************");
    System.out.println(
            "This challenge will present you 10 problems in which you will have two chances to answer 
 the question correctly");
    System.out.println(
            "The questions that will be asked will be basic arithmetic ranging from addition, 
 subtraction, multiplication and division");
    System.out.println("You will receive full credit if you answer the question correctly on the 
 first try");
    System.out.println("You will only receive half credit if you answer it correctly on the second 
 try");
    System.out.println("You score will be tallied at the end of the quiz");
    System.out.println("Good luck!");
    System.out.println("---------------------");

    for (int i = 1; i <= 10; i++) {
        long rand1 = Math.round((Math.random() * 4) + 1);
        // System.out.println(rand1); //for testing random function

        if (rand1 == 1.0) {
            System.out.println("Problem #" + i);
            System.out.println("----------------------------");
            System.out.println(q1.getProblem());

            System.out.println("Type Your Answer Below:");
            Integer ans = sc.nextInt();
            System.out.println("Your answer was: " + ans);
            if (ans == q1.getAnswer()) {
                System.out.println("That is correct!");
                credit = credit + 10;
                firstTry = firstTry + 1;
                System.out.println("Your total points right now is: " + credit);
                System.out.println();
            } else {
                System.out.println("-------------------------");
                System.out.println();
                System.out.println("Sorry that is not correct");
                System.out.println("Lets try again");
                System.out.println();
                System.out.println(q1.getProblem());
                System.out.println("Type Your Answer:");
                Integer ans1 = sc.nextInt();
                if (ans1 == q1.getAnswer()) {
                    System.out.println("There ya go..good answer");
                    System.out.println("Lets move on");
                    credit = credit + 5;
                    secondTry = secondTry + 1;
                    System.out.println("You total points thus far is: " + credit);
                } else {
                    System.out.println();
                    System.out.println("Hmmmm.sorry thats still not correct");
                    System.out.println("The correct answer was: " + q1.getAnswer());
                    wrong = wrong + 1;
                    System.out.println("You have " + credit + " points");
                    System.out.println("Lets continue on!");
                    System.out.println();
                    System.out.println("-------------------------");
                }

            }

Answer 1

我假设您发布的 psvm 包含实际代码。如果不是这种情况，请帮我填补空白。

代码示例存在多个问题，我将一一解决。

您有 4 个本地属性 q1-q4 以及 4 个不同的实例。根据代码，我看到每个类都包含一个问题和一个答案。这已经将您限制为最多 4 个问题。您无法回答 10 个不同的问题。

要解决这个问题，您必须重新考虑您的方法。我现在不会过度讨论 OO-Aspect，因为这似乎不是您的目标。首先，我们必须修复您的“静态”局部变量，并添加一些实用程序来启用您的动态问题。假设您不太关心类型的分布(添加等)，我们可以从主类中删除这种分离。因此，我们添加一个新类(称为ProblemFactory)和一个接口(interface)(称为Problem)。您的 4 个类实现了问题。

public final class ProblemFactory {

    public static Problem createProblem(){
        long random = Math.round((Math.random() * 4) + 1);
        switch(random) {
            case 1:
                return new AdditionProblem();
            case 2:
                return new SubtractionProblem();
                ...
    }
}

public interface Problem {

    public String getProblem();

    public String getAnswer();

}

在主类中，将 Math.random() 行替换为

Problem problem = ProblemFactory.createProblem();

主类中不再需要 if(rand1 == 1.0)，并且可以删除除其中一个之前的 if-else block 之外的所有内容。 q1-q4 被新的问题变量替换。

现在您需要对 4 个问题类别进行最后一次更改。我假设你有某种类型的 map ，其中有 2 个字符串，其中键是问题，值是答案。如果是这种情况，您的类(class)可能如下所示

public class AdditionProblem(){

    private static Map<String, String> questions = createQuestions();

    private String problem;

    private String answer;

    private static Map<String, String> createQuestions() {
        Map<String, String> questions = new HashMap();
        questions.put("24 + 36 + 10", "70");
        //add as many more as you desire, but at least 10 total
        return questions;
    }

    public AdditionProblem(){
        //we first get the number of available questions
        int numberOfQuestions = questions.size();
        //we now generate a random again to choose which question to pick
        long random = Math.round((Math.random() * numberOfQuestions) + 1);
        //We pull they keySet from the map and use the random number as index, this is our question now
        problem = questions.keys().get(random);
        //we use the question to pull the answer
        answer = questions.get(problem);
        //as our last step, we remove the question from the list, so it is not pulled again
        questions.remove(problem);
    }

    public String getProblem(){
        return problem;
    }

    public String getAnswer(){
        return answer;
    }

}

通过这些更改，您可以在每次循环迭代时创建一个新的问题对象。你不知道，也不关心，它是什么类型的算术函数，你只知道它是这 4 种函数中的任何一种，而且总是一个新问题。现在您唯一需要确保的是，当您希望测验中有 10 个问题时，每堂课至少有 10 个问题。否则你最终会遇到异常。