用简单java实现调度场算法的计算器，并且详细解释每个步骤。

调度场算法是一种用于计算数学表达式的算法，它通过将表达式转换成逆波兰表达式来进行计算。Java语言可以通过栈的数据结构来实现这种算法。

以下是简单Java语言实现调度场算法的计算器的步骤：

1. 定义一个栈来存储运算符和操作数。

2. 将表达式转换成字符数组，依次遍历每个字符。

3. 如果遇到操作数，将其压入栈中。

4. 如果遇到运算符，将其与栈顶的运算符进行比较。如果栈顶的运算符优先级高于当前运算符，则将栈顶的运算符弹出并进行计算。重复此步骤，直到当前运算符的优先级高于栈顶的运算符或者栈为空。将当前运算符压入栈中。

5. 如果遇到左括号，将其压入栈中。

6. 如果遇到右括号，则弹出栈中的运算符并进行计算，直到遇到左括号为止。左括号和右括号不需要压入栈中。

7. 遍历完整个表达式后，将栈中的运算符依次弹出并进行计算，直到栈为空。

8. 计算结果即为最终结果。

以下是一个简单的Java代码实现：

import java.util.Stack;

public class Calculator {
    public static int calculate(String expression) {
        Stack<Integer> stack = new Stack<>();
        char[] chars = expression.toCharArray();

        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            if (Character.isDigit(c)) { // 如果是数字
                int num = c - '0';
                while (i + 1 < chars.length && Character.isDigit(chars[i + 1])) { // 处理多位数字
                    num = num * 10 + (chars[i + 1] - '0');
                    i++;
                }
                stack.push(num);
            } else if (c == '(') { // 如果是左括号
                stack.push(-1);
            } else if (c == ')') { // 如果是右括号
                int num = stack.pop();
                int result = 0;
                while (num != -1) { // 计算括号内的表达式
                    result += num;
                    num = stack.pop();
                }
                stack.push(result);
            } else if (c == '+' || c == '-' || c == '*' || c == '/') { // 如果是运算符
                while (!stack.isEmpty() && stack.peek() != -1 && getPriority(stack.peek()) >= getPriority(c)) { // 比较优先级
                    int operand2 = stack.pop();
                    int operand1 = stack.pop();
                    int result = calculateByOperator(operand1, operand2, stack.pop());
                    stack.push(result);
                }
                stack.push((int)c);
            }
        }

        int result = 0;
        while (!stack.isEmpty()) { // 计算最终结果
            result += stack.pop();
        }
        return result;
    }

    private static int calculateByOperator(int operand1, int operand2, int operator) {
        switch (operator) {
            case '+':
                return operand1 + operand2;
            case '-':
                return operand1 - operand2;
            case '*':
                return operand1 * operand2;
            case '/':
                return operand1 / operand2;
            default:
                throw new IllegalArgumentException("Invalid operator");
        }
    }

    private static int getPriority(int operator) {
        switch (operator) {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
            default:
                return 0;
        }
    }
}

该代码实现了一个简单的调度场算法的计算器，可以处理包含括号、加减乘除的表达式。其中，calculate方法接收一个表达式字符串，返回计算结果。具体实现中，使用栈来存储运算符和操作数，遍历表达式字符串的每个字符，根据字符的类型进行不同的处理。如果是数字，将其转换成整数并压入栈中；如果是左括号，将其压入栈中；如果是右括号，弹出栈中的元素并计算括号内的表达式；如果是运算符，则比较其与栈顶运算符的优先级，如果栈顶运算符的优先级高于等于当前运算符，则弹出并计算栈顶运算符；否则，将当前运算符压入栈中。最后，遍历完整个表达式后，将栈中的运算符依次弹出并计算，最终得到计算结果。