java24点游戏 有时间 关卡 刷新 重新开始功能

以下是一个简单的Java 24点游戏，包括时间限制，关卡，刷新和重新开始功能：

import java.util.*;
import java.util.concurrent.TimeUnit;

public class TwentyFourGame {

    private static final int MAX_LEVEL = 5;
    private static final int TIME_LIMIT = 60; // seconds

    private List<Integer> cards;
    private int level;
    private int score;
    private int timeLeft;
    private Scanner scanner;
    private Random random;

    public TwentyFourGame() {
        cards = new ArrayList<>();
        scanner = new Scanner(System.in);
        random = new Random();
    }

    public void start() {
        System.out.println("Welcome to 24-Game!");
        level = 1;
        score = 0;
        while (level <= MAX_LEVEL) {
            System.out.println("Level " + level);
            generateCards();
            timeLeft = TIME_LIMIT;
            while (timeLeft > 0) {
                showCards();
                System.out.print("Enter your answer (q to quit): ");
                String answer = scanner.nextLine();
                if (answer.equals("q")) {
                    System.out.println("Game over! Your final score is " + score);
                    return;
                }
                if (checkAnswer(answer)) {
                    score++;
                    System.out.println("Correct! Your current score is " + score);
                    break;
                } else {
                    System.out.println("Incorrect! Please try again.");
                }
            }
            level++;
        }
        System.out.println("Congratulations! You have finished all levels. Your final score is " + score);
    }

    private void generateCards() {
        cards.clear();
        for (int i = 0; i < 4; i++) {
            cards.add(random.nextInt(10) + 1);
        }
    }

    private void showCards() {
        System.out.println("Cards: " + cards);
        System.out.println("Time left: " + timeLeft + " seconds");
    }

    private boolean checkAnswer(String answer) {
        List<Integer> nums = new ArrayList<>();
        for (char c : answer.toCharArray()) {
            if (Character.isDigit(c)) {
                nums.add(c - '0');
            }
        }
        if (nums.size() != 4) {
            return false;
        }
        Collections.sort(nums);
        List<String> expressions = generateExpressions(nums);
        for (String expr : expressions) {
            if (evaluateExpression(expr) == 24) {
                return true;
            }
        }
        return false;
    }

    private List<String> generateExpressions(List<Integer> nums) {
        List<String> expressions = new ArrayList<>();
        if (nums.size() == 1) {
            expressions.add(Integer.toString(nums.get(0)));
            return expressions;
        }
        for (int i = 0; i < nums.size(); i++) {
            int num1 = nums.get(i);
            List<Integer> subNums = new ArrayList<>(nums);
            subNums.remove(i);
            for (int j = 0; j < subNums.size(); j++) {
                int num2 = subNums.get(j);
                List<Integer> newNums = new ArrayList<>(subNums);
                newNums.remove(j);
                List<String> subExprs = generateExpressions(newNums);
                for (String expr : subExprs) {
                    expressions.add(num1 + "+" + num2 + "+" + expr);
                    expressions.add(num1 + "-" + num2 + "-" + expr);
                    expressions.add(num1 + "*" + num2 + "*" + expr);
                    if (num2 != 0) {
                        expressions.add(num1 + "/" + num2 + "/" + expr);
                    }
                }
            }
        }
        return expressions;
    }

    private int evaluateExpression(String expr) {
        Stack<Integer> stack = new Stack<>();
        String[] tokens = expr.split("[+\\-*/]");
        String[] operators = expr.split("\\d+");
        int i = 0;
        while (i < tokens.length) {
            String token = tokens[i];
            stack.push(Integer.parseInt(token));
            if (i < operators.length) {
                String operator = operators[i + 1];
                switch (operator) {
                    case "+":
                        break;
                    case "-":
                        stack.push(-stack.pop());
                        break;
                    case "*":
                        stack.push(stack.pop() * stack.pop());
                        break;
                    case "/":
                        int divisor = stack.pop();
                        int dividend = stack.pop();
                        stack.push(dividend / divisor);
                        break;
                }
            }
            i++;
        }
        int result = 0;
        while (!stack.empty()) {
            result += stack.pop();
        }
        return result;
    }

    public static void main(String[] args) {
        TwentyFourGame game = new TwentyFourGame();
        game.start();
    }

}

该程序使用了以下几个类：

- `List<Integer>`：用于存储4张牌的数字。
- `Scanner`：用于从标准输入读取用户输入。
- `Random`：用于生成随机的数字。
- `Stack<Integer>`：用于计算表达式的值。

程序包括以下方法：

- `generateCards()`：生成4张随机的牌。
- `showCards()`：显示当前的牌和剩余的时间。
- `checkAnswer(String answer)`：检查用户输入的答案是否正确。该方法首先将用户输入中的数字提取出来，然后生成所有可能的表达式，最后计算表达式的值，如果有一个等于24，则返回true，否则返回false。
- `generateExpressions(List<Integer> nums)`：生成所有可能的表达式。该方法使用递归算法，首先从4个数字中选取2个，然后生成所有可能的表达式，再将剩下的数字和表达式组合起来，最后返回所有可能的表达式。
- `evaluateExpression(String expr)`：计算表达式的值。该方法使用栈来实现，首先将表达式中的数字入栈，然后遇到运算符时进行相应的操作，最后将栈中的数字相加得到结果。

程序使用`start()`方法作为入口，该方法包括一个循环，每次循环生成4张牌并计时，直到用户输入了正确的答案或时间到了为止。如果用户完成了所有的关卡，则输出恭喜信息。程序还包括一个`main()`方法，用于启动游戏。

在程序中，我们使用了`java.util.concurrent.TimeUnit`类来实现时间限制。具体来说，我们使用了以下代码来计时：

timeLeft = TIME_LIMIT;
long start = System.currentTimeMillis();
while (timeLeft > 0) {
    long elapsed = System.currentTimeMillis() - start;
    timeLeft = TIME_LIMIT - (int) TimeUnit.MILLISECONDS.toSeconds(elapsed);
    // ...
}

其中，`TIME_LIMIT`为时间限制的秒数，`start`为计时的起始时间，`elapsed`为已经过去的毫秒数，`timeLeft`为剩余的秒数。在每次循环开始时，我们计算已经过去的时间，并根据时间限制计算剩余的时间。如果剩余时间小于等于0，则表示时间到了，退出循环。