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

Question

Right now I'm going to have to write a method that looks like this:

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...";
        }
}

It would be nice if I could write the code more like this:

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

So Operator would replace the Arithmetic Operators (+, -, *, /...)

Does anyone know if something like this is possible in java?

Answer 1

No, you can't do that in Java. The compiler needs to know what your operator is doing. What you could do instead is an enum:

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;
    }
}

You can then write a method like this:

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

And call it like this:

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

Answer 2

Method arguments in Java must be expressions. An operator by itself is not an expression. This is not possible in Java.

You can, of course, pass objects (maybe enum constants) that represents those operators, and act accordingly, but you can't pass the operators themselves as parameters.

---

Additional tips

Since you're just starting Java, it's best to ingrain these informations early on to ease your future development.

• Method names starts with lowercase: calculate instead of Calculate
• Variable names starts with lowercase: operator instead of Operator
• Double is a reference type, the box for primitive type double .
  • Effective Java 2nd Edition, Item 49: Prefer primitive types to boxed primitives
• Don't return "error..." . Instead, throw new IllegalArgumentException("Invalid operator");

See also

• Java Language Guide/Autoboxing
• Java Lessons/Exceptions
• Coding Conventions/Naming
  • Unfortunate typo in this document: How is this statement making sense? (Sun's naming convention for Java variables)

Answer 3

There's only the cumbersome way of doing it with a callback interface. Something like

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

Then you implement the operators you need:

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

And your generic method takes an Operator and the two arguments:

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

You could also use an enum instead of an interface if you only need a smaller, fixed number of operators.

Answer 4

You can't pass operators directly. You could use functors .

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

Answer 5

You can either

1. Use a functional language for JVM to implement this part of your code (clojure, scala et el), wrap lambda functions around math operators and pass those functions as parameters

2. Get an expression evaluator for Java like http://www.singularsys.com/jep/ (and there must be many free alternatives as well)

Answer 6

No this is not possible in this way.

You will need a parser to do what you want, and this can be cumbersome.

You're probably asking the wrong question, since you are getting the wrong answer.

If you are looking for a mathematical parser you might want to take a look at this project on SF: http://sourceforge.net/projects/jep/

There might be some answers in this.

Answer 7

It would be nice, wouldn't it? But, you just can't do that. You can probably accomplish, something similar by writing your own "operators".

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);
  }
}

You get the picture how to extend this to many other operators ... and not only Doubles obviously. The advantage of my method is that you can actualy keep your method signature of accepting a String operator.

Answer 8

Since the introduction of lambda expressions and functional interfaces in Java 8, you can do it more idiomatically.

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

Whether you want to have these BinaryOperator s predefined (or declared somewhere as constants) is more of a stylistic choice.

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

Answer 9

Operators, AFAIK, cannot be passed as a parameter in any language (at least that I've come across).

Reason is that only values (either by copy or by references) can be passed as "values to parameters".

And operators represent no values.