Java设计一个找到四个数字合成等于目标数的程序

要使用Java设计一个找到四个数字合成等于目标数的程序，我们可以使用回溯算法来实现。下面是使用Java编写的示例代码：

```java

import java.util.ArrayList;

import java.util.List;

public class NumberCombination {

    public static void findCombination(int target, int depth, int curSum, List<Integer> chosenNums) {

        if (depth == 4) {

            if (curSum == target) {

                System.out.println(chosenNums);

            }

            return;

        }

        for (int num = 0; num <= 9; num++) {

            chosenNums.add(num);

            curSum += num;

            findCombination(target, depth + 1, curSum, chosenNums);

            chosenNums.remove(chosenNums.size() - 1);

            curSum -= num;

        }

    }

    public static void main(String[] args) {

        findCombination(10, 0, 0, new ArrayList<>());

    }

}

```

在上述代码中，我们使用了一个`findCombination`方法来递归查找四个数字的合成结果。该方法有四个参数：`target`表示目标数，`depth`表示当前递归深度，`curSum`表示当前合成结果，`chosenNums`表示当前已选择的数字列表。

我们通过判断`depth`是否为4来确定是否已选择了四个数字。如果已选择了四个数字，则判断`curSum`是否等于`target`，如果等于则打印出已选择的数字列表。否则，我们循环从0到9的数字，在循环中选择一个数字并更新`chosenNums`和`curSum`，然后递归调用`findCombination`方法。在递归返回后，我们将刚刚选择的数字从`chosenNums`中移除，并将`curSum`恢复到原来的值，以便进行下一轮选择。

在示例的`main`方法中，我们调用`findCombination`方法，并传入目标数为10，初始递归深度为0，初始合成结果为0，以及一个空的`chosenNums`列表。该示例将打印出所有四个数字合成结果为10的可能组合。

你可以根据需要修改目标数和其他参数来运行程序。

代码：

import java.util.*;

public class Game24 {

    public static void main(String[] args) {

        // 生成随机的四个数字

        List<Integer> numbers = generateNumbers();

        // 输出随机生成的数字

        System.out.println("随机生成的四个数字为：" + numbers);

        // 获取用户输入的算式

        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入四个数字的算式，使用+、-、*、/运算符：");

        String expression = scanner.nextLine();

        // 检验用户输入的算式结果是否为24

        if (calculate(expression, numbers) == 24) {

            System.out.println("恭喜你，答案正确！");

        } else {

            System.out.println("很抱歉，答案错误。");

        }

    }

    // 生成随机的四个数字

    private static List<Integer> generateNumbers() {

        List<Integer> numbers = new ArrayList<>();

        Random random = new Random();

        for (int i = 0; i < 4; i++) {

            int number = random.nextInt(9) + 1;

            numbers.add(number);

        }

        return numbers;

    }

    // 计算算式的结果

    private static double calculate(String expression, List<Integer> numbers) {

        // 替换J、Q、K为1

        expression = expression.replaceAll("J", "1")

                .replaceAll("Q", "1")

                .replaceAll("K", "1");

        expression = expression.replaceAll(" ", "");

        for (int i = 0; i < numbers.size(); i++) {

            expression = expression.replaceAll(String.valueOf(i + 1), String.valueOf(numbers.get(i)));

        }

        return eval(expression);

    }

    // 解析并计算表达式的结果

    private static double eval(final String str) {

        // 代码略，与之前提供的代码一致

        return new Object() {

            int pos = -1;

            int ch;

            void nextChar() {

                ch = (++pos < str.length()) ? str.charAt(pos) : -1;

            }

            boolean eat(int charToEat) {

                while (ch == ' ') nextChar();

                if (ch == charToEat) {

                    nextChar();

                    return true;

                }

                return false;

            }

double parse() {

                nextChar();

                double x = parseExpression();

                if (pos < str.length()) throw new RuntimeException("Unexpected: " + (char) ch);

                return x;

            }

            double parseExpression() {

                double x = parseTerm();

                for (;;) {

                    if      (eat('+')) x += parseTerm(); // addition

                    else if (eat('-')) x -= parseTerm(); // subtraction

                    else return x;

                }

            }

            double parseTerm() {

                double x = parseFactor();

                for (;;) {

                    if      (eat('*')) x *= parseFactor(); // multiplication

                    else if (eat('/')) x /= parseFactor(); // division

                    else return x;

                }

            }

            double parseFactor() {

                if (eat('+')) return parseFactor(); // unary plus

                if (eat('-')) return -parseFactor(); // unary minus

                double x;

                int startPos = this.pos;

                if (eat('(')) { // parentheses

                    x = parseExpression();

                    eat(')');

                } else if ((ch >= '0' && ch <= '9') || ch == '.') { // numbers

                    while ((ch >= '0' && ch <= '9') || ch == '.') nextChar();

                    x = Double.parseDouble(str.substring(startPos, this.pos));

                } else {

                    throw new RuntimeException("Unexpected: " + (char)ch);

                }

                return x;

            }

        }.parse();

    }

}

运行截图：