Is it possible to pass arithmetic operators to a method in java?
Solution 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));
Solution 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 ofCalculate
- Variable names starts with lowercase:
operator
instead ofOperator
-
Double
is a reference type, the box for primitive typedouble
.- 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)
Solution 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.
Solution 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);
}
Solution 5
You can either
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
Get an expression evaluator for Java like http://www.singularsys.com/jep/ (and there must be many free alternatives as well)
James T
Updated on March 10, 2021Comments
-
James T about 3 years
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?
-
Ashish Jindal almost 14 yearsEnums cannot have abstract methods.
-
aioobe almost 14 years+1, but typo in subtraction implementation and identifier of second argument.
-
Daniel Pryden almost 14 yearsOperators can be passed as parameters in every functional language I know. Scala can do it on the JVM.
-
Michael Mrozek almost 14 yearsYeah, I died a little inside when I read that part. The ability to pass operators is one of those things Java-oriented people never consider, and then they find a language that supports it and hopefully it blows their minds
-
Jon Skeet almost 14 years@aioobe: Yup, I'd just got to the identifier but had missed the implementation. @Ashsish: Yes they can, if all the values override it.
-
Daniel Pryden almost 14 yearsCumbersome perhaps, but this is considerably more flexible and extensible than using an enum.
-
Ashish Jindal almost 14 years@Daniel: That tells me to look into Scala :) In anycase, the operator stuff doesn't apply to Java ;)
-
Thomas Kappler almost 14 yearsThat it is. Especially since you can use anonymous classes for one-off operators.
-
Jon Skeet almost 14 years@Daniel: Yes, it depends on whether you have a fixed set of operators to start with. If you do, an enum is neater IMO (and allows for serialization etc). If you need the extra flexibility, the anonymous inner class bit works fine. Of course, you could always make an enum which implements the interface, to get the best of both worlds :)
-
Daniel Pryden almost 14 years@Jon: True enough. That's why I didn't say that this approach is necessarily better, just that it "is considerably more flexible and extensible." In many cases, "flexible and extensible" equals better, but obviously not always. (Serialization is an excellent counterexample, BTW.) It just goes to show you should never pick your design until you know the constraints of the problem!
-
Kenny Meyer over 13 yearsThis solves my problem! Thanks for sharing your solution. In a dynamic programming language like Python, there would be an eval() method to rescue, but there is none in Java.
-
BlackJack almost 7 years@KennyMeyer In Python one wouldn't use evil
eval()
but passing the functions in theoperator
module as arguments.def calculate(op, a, b): return op(a, b)
and the called ascalculate(operator.add, 3.5, 2)
.