是否可以将算术运算符传递给java中的方法？

Question

现在我将不得不编写一个如下所示的方法：

public String Calculate(String operator, double operand1, double operand2)
{

        if (operator.equals("+"))
        {
            return String.valueOf(operand1 + operand2);
        }
        else if (operator.equals("-"))
        {
            return String.valueOf(operand1 - operand2);
        }
        else if (operator.equals("*"))
        {
            return String.valueOf(operand1 * operand2);
        }
        else
        {
            return "error...";
        }
}

如果我能把代码写成这样就好了：

public String Calculate(String Operator, Double Operand1, Double Operand2)
{
       return String.valueOf(Operand1 Operator Operand2);
}

因此运算符将替换算术运算符（+、-、*、/...）

有谁知道在java中这样的事情是否可行？

Answer 1

不，你不能在 Java 中做到这一点。编译器需要知道您的操作员在做什么。你可以做的是一个枚举：

public enum Operator
{
    ADDITION("+") {
        @Override public double apply(double x1, double x2) {
            return x1 + x2;
        }
    },
    SUBTRACTION("-") {
        @Override public double apply(double x1, double x2) {
            return x1 - x2;
        }
    };
    // You'd include other operators too...

    private final String text;

    private Operator(String text) {
        this.text = text;
    }

    // Yes, enums *can* have abstract methods. This code compiles...
    public abstract double apply(double x1, double x2);

    @Override public String toString() {
        return text;
    }
}

然后你可以写一个这样的方法：

public String calculate(Operator op, double x1, double x2)
{
    return String.valueOf(op.apply(x1, x2));
}

然后这样称呼它：

String foo = calculate(Operator.ADDITION, 3.5, 2);
// Or just
String bar = String.valueOf(Operator.ADDITION.apply(3.5, 2));

Answer 2

Java 中的方法参数必须是表达式。运算符本身不是表达式。这在 Java 中是不可能的。

当然，您可以传递代表这些运算符的对象（可能是enum 常量）并采取相应的行动，但您不能将运算符本身作为参数传递。

---

其他提示

由于您刚刚开始使用 Java，因此最好尽早掌握这些信息以简化您未来的开发。

• 方法名称以小写开头：calculate 而不是Calculate
• 变量名以小写开头：operator 而不是Operator
• Double 是一个引用类型，原始类型 double 的框。
  • Effective Java 2nd Edition，Item 49：Prefer primitive types to boxed primitive
• 不要return "error..."。相反，throw new IllegalArgumentException("Invalid operator");

另见

• Java Language Guide/Autoboxing
• Java Lessons/Exceptions
• Coding Conventions/Naming
  • 不幸的是，本文档中有错字：How is this statement making sense? (Sun’s naming convention for Java variables)

Answer 3

只有使用回调接口的繁琐方法。类似的东西

interface Operator {
    public Double do(Double x, Double y);
}

然后你实现你需要的操作符：

Operator plus = new Operator() {
    public Double do(Double x, Double y) {
        return x + y;
    }
};

你的通用方法需要一个运算符和两个参数：

public String Calculate(Operator operator, Double x, Double y) {
    return String.valueOf( operator.do(x, y) );
}

如果您只需要较小的固定数量的运算符，您也可以使用枚举而不是接口。

Answer 4

您不能直接传递运算符。你可以使用functors。

public double Calculate(BinaryFunction<Double, Double, Double> op, double Operand1, double Operand2)
{
  return (double)op.evaluate(Operand1, Operand2);
}

Answer 5

你可以

1. 使用 JVM 的函数式语言来实现这部分代码（clojure、scala 等），将 lambda 函数包装在数学运算符周围并将这些函数作为参数传递

2. 获取 Java 表达式评估器，例如 http://www.singularsys.com/jep/（而且必须有许多免费替代品）

Answer 6

不，这是不可能的。

你需要一个解析器来做你想做的事，这可能很麻烦。

你可能问错了问题，因为你得到了错误的答案。

如果您正在寻找数学解析器，您可能想看看 SF 上的这个项目：http://sourceforge.net/projects/jep/

这里面可能有一些答案。

Answer 7

这会很好，不是吗？但是，你就是不能那样做。您可能可以通过编写自己的“运算符”来完成类似的事情。

public interface Operator {
  Double calculate(Double op1, Double op2);
}

public Addition implements Operator {
  @Override
  Double calculate(Double op1, Double op2) { return op1 + op2; }
}

public class Calculator {
  private static Operator ADDITION = new Addition();
  private static Map<String,Operator> OPERATORS = new HashMap<String,Operator>();
  static {
    OPERATORS.put("+",ADDITION);
  }

  public String Calculate(String operator, Double operand1, Double operand2) {
    return String.valueOf(OPERATORS.get(operator).calculate(operand1,operand2);
  }
}

您了解如何将其扩展到许多其他运算符......显然不仅仅是双精度数。我的方法的优点是您实际上可以保留接受 String 运算符的方法签名。

Answer 8

自从在 Java 8 中引入了lambda expressions 和functional interfaces，你可以更地道地做到这一点。

public static <T> T calculate(BinaryOperator<T> operator, T operand1, T operand2) {
  return operator.apply(operand1, operand2);
}

是否要预定义这些BinaryOperators（或在某处声明为常量）更多的是一种风格选择。

Integer r1 = calculate((a, b) -> a + b, 2, 2); // 4
Integer r2 = calculate(Integer::sum, 2, 2); // 4

Answer 9

运算符，AFAIK，不能作为任何语言的参数传递（至少我遇到过）。

原因是只有值（通过复制或通过引用）可以作为“参数的值”传递。

并且运算符不代表任何值。