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

在Java中，我们可以创建一个表达式解析器来处理简单的混合四则运算，包括加减乘除以及括号。这里我们使用递归下降解析器的方法来实现。首先，我们需要定义一个`Operator`枚举表示四种基本运算，以及一个`Token`类来存储操作数和运算符。

public enum Operator {
    PLUS('+'),
    MINUS('-'),
    TIMES('*'),
    DIVIDE('/');

    private char symbol;

    Operator(char symbol) {
        this.symbol = symbol;
    }

    public char getSymbol() {
        return symbol;
    }
}

class Token {
    public static final int TYPE_NUMBER = 0;
    public static final int TYPE_OPERATOR = 1;
    
    private int type;
    private double value;
    private Operator operator;

    // 构造函数和getter/setter省略...
}

接下来，我们可以定义一个`ExpressionParser`类来解析和计算表达式：

public class ExpressionParser {
    private Stack<Token> tokens;

    public double calculate(String expression) {
        tokens = new Stack<>();
        for (char c : expression.toCharArray()) {
            if (Character.isDigit(c)) {
                double num = 0;
                while (Character.isDigit(c)) {
                    num = num * 10 + (c - '0');
                    c = getchar();
                }
                push(new Token(TokenType.NUMBER, num));
            } else if (c == '(') {
                push(new Token(TokenType.OPEN_PARENTHESIS));
            } else if (c == ')') {
                popAndCalculate();
                consume();
            } else {
                consume();
                push(new Token(TokenType.OPERATOR, c == '+' ? Operator.PLUS : 
                                   c == '-' ? Operator.MINUS :
                                   c == '*' ? Operator.TIMES :
                                   c == '/' ? Operator.DIVIDE));
            }
        }
        popAndCalculate();
        return tokens.peek().getValue(); // 返回最后的结果
    }

    private void consume() {
        if (!tokens.isEmpty()) {
            tokens.pop();
        }
    }

    private void push(Token token) {
        tokens.push(token);
    }

    private void popAndCalculate() {
        Token opToken = tokens.pop();
        if (tokens.peek().getType() != TokenType.OPEN_PARENTHESIS) {
            performOperation(opToken);
        }
    }

    private void performOperation(Token opToken) {
        Token left = tokens.pop();
        Token right = tokens.pop();

        switch (opToken.getOperator()) {
            case PLUS:
                tokens.push(new Token(TokenType.NUMBER, left.getValue() + right.getValue()));
                break;
            case MINUS:
                tokens.push(new Token(TokenType.NUMBER, left.getValue() - right.getValue()));
                break;
            case TIMES:
                tokens.push(new Token(TokenType.NUMBER, left.getValue() * right.getValue()));
                break;
            case DIVIDE:
                tokens.push(new Token(TokenType.NUMBER, left.getValue() / right.getValue()));
                break;
        }
    }

    private char getchar() {
        // 这里假设expression是一个有效的字符串，不含未闭合的括号
        // 实际应用中，需要检查并处理可能的错误情况，比如非法字符等
        throw new UnsupportedOperationException("Implement a method to fetch the next character");
    }
}

你可以通过下面的方式使用这个`ExpressionParser`来计算给定的表达式：

ExpressionParser parser = new ExpressionParser();
double result = parser.calculate("(a+b)*c-d/2"); // 结果将取决于a, b, c的具体数值
System.out.println(result);