编写一个简单的Java应用程序，实现四则混合运算功能，例如实现：（a+b)*c+d/2;

在Java中编写一个简单的四则混合运算计算器，我们可以创建一个`Calculator`类，其中包含一个`calculate`方法来处理输入的表达式。这里使用了`eval()`函数来进行字符串到数值的转换和数学运算，注意这个`eval()`函数在实际生产环境中可能会有安全风险，因为它允许执行任意字符串表达式。

import java.lang.reflect.Method;
import java.util.Stack;

public class Calculator {
    private static final String ADD = "+";
    private static final String SUBTRACT = "-";
    private static final String MULTIPLY = "*";
    private static final String DIVIDE = "/";

    public double calculate(String expression) throws Exception {
        Stack<Double> values = new Stack<>();
        Stack<Character> operators = new Stack<>();

        // 分割表达式并处理每一个部分
        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);
            if (Character.isDigit(c)) {
                StringBuilder sb = new StringBuilder();
                while (i < expression.length() && Character.isDigit(expression.charAt(i))) {
                    sb.append(expression.charAt(i++));
                }
                values.push(Double.parseDouble(sb.toString()));
            } else if (c == '(') {
                operators.push(c);
            } else if (c == ')') {
                while (!operators.isEmpty() && operators.peek() != '(') {
                    applyOperator(operators.pop(), values);
                }
                operators.pop();
            } else if (c == '+' || c == '-' || c == '*' || c == '/') {
                while (!operators.isEmpty() && hasPrecedence(c, operators.peek())) {
                    applyOperator(operators.pop(), values);
                }
                operators.push(c);
            }
        }

        // 检查剩余的操作符是否匹配所有左括号
        while (!operators.isEmpty()) {
            applyOperator(operators.pop(), values);
        }

        // 最后一个操作数是结果
        return values.pop();
    }

    private boolean hasPrecedence(char op1, char op2) {
        switch (op1) {
            case '*':
            case '/':
                return true;
            default:
                return false;
        }

        switch (op2) {
            case '+':
            case '-':
                return true;
            default:
                return false;
        }
    }

    private void applyOperator(char operator, Stack<Double> values) {
        double right = values.pop();
        double left = values.pop();

        switch (operator) {
            case '+':
                values.push(left + right);
                break;
            case '-':
                values.push(left - right);
                break;
            case '*':
                values.push(left * right);
                break;
            case '/':
                if (right != 0) {
                    values.push(left / right);
                } else {
                    throw new ArithmeticException("Cannot divide by zero");
                }
                break;
        }
    }

    public static void main(String[] args) {
        try {
            Calculator calculator = new Calculator();
            System.out.println(calculator.calculate("(2+3)*4+5/2")); // 输出：28.0
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们首先将输入的表达式按照数字、运算符和括号分割，并分别存储到值栈和运算符栈中。然后依次处理每个运算符和括号，最后剩下的栈顶元素就是计算的结果。