java 编写代码实现混合四则运算，需包含+、-、*、\及（）的应用；例如输入实现（a+b）*c-d/2。

在Java中，你可以创建一个简单的表达式解析器来处理这种混合四则运算。这里我们可以使用递归下降解析法，也就是通过编写函数来模拟数学运算规则。以下是一个基本的例子：

import java.util.Stack;

public class ExpressionEvaluator {
    public static double evaluate(String expression) {
        Stack<Double> values = new Stack<>();
        Stack<Character> ops = new Stack<>();

        for (int i = 0; i < expression.length(); i++) {
            char token = expression.charAt(i);

            if (Character.isDigit(token)) {
                double num = 0;
                while (i < expression.length() && Character.isDigit(expression.charAt(i))) {
                    num = num * 10 + (expression.charAt(i) - '0');
                    i++;
                }
                i--;
                values.push(num);
            } else if (token == '(') {
                ops.push(token);
            } else if (token == ')') {
                while (!ops.isEmpty() && ops.peek() != '(') {
                    double val2 = values.pop();
                    double val1 = values.pop();
                    char op = ops.pop();

                    double result = applyOp(val1, val2, op);
                    values.push(result);
                }
                if (!ops.isEmpty()) {
                    ops.pop(); // pop '('
                }
            } else if (token == '+' || token == '-' || token == '*' || token == '/') {
                while (!ops.isEmpty() && precedence(token) <= precedence(ops.peek())) {
                    double val2 = values.pop();
                    double val1 = values.pop();
                    char op = ops.pop();

                    double result = applyOp(val1, val2, op);
                    values.push(result);
                }
                ops.push(token);
            }
        }

        // Evaluate any remaining operations
        while (!ops.isEmpty()) {
            double val2 = values.pop();
            double val1 = values.pop();
            char op = ops.pop();

            double result = applyOp(val1, val2, op);
            values.push(result);
        }

        return values.pop(); // Return the final result
    }

    private static double applyOp(double val1, double val2, char op) {
        switch (op) {
            case '+':
                return val1 + val2;
            case '- val2;
            case '*':
                return val1 * val2;
            case '/':
                return val1 / val2;
            default:
                throw new IllegalArgumentException("Invalid operator");
        }
    }

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

    public static void main(String[] args) {
        System.out.println(evaluate("(5+3)*2-4/2")); // 输出：16.0
    }
}

这个程序定义了一个`evaluate`方法，它接收一个字符串表达式作为输入，并返回计算结果。注意这个例子只处理了整数除法，如果需要处理浮点数，可以在适当的地方修改。