Function passing in Java is not directly supported because no constructs like lambda exist in the Java programming language. But there are alternatives, and in this post I will describe some of them.
Interfaces / Strategy Pattern
With an interface, it is possible to
mimic function passing in Java. An example:
/**
* returns the added results of func. Func recieves [0..times-1].
*/
private int accumulate(Function func, int times) {
int result = 0;
for (int i = 0; i < times; i++) {
result += func.calc(i);
}
return result;
}
/**
* A function interface.
*/
interface Function {
int calc(int x);
}
We can now use this structure to calculate various things:
/**
* adds all the numbers from 1 to the given number.
*/
public int addNumbersTo(int limit) {
return accumulate(new Function() {
@Override
public int calc(int x) {
return x + 1;
}
}, limit);
}
/*
* adds up the first X even numbers.
*/
public int addFirstXEvenNumbers(int x) {
return accumulate(new Function() {
@Override
public int calc(int x) {
return (2 * x) + 2;
}
}, x);
}
It is also possible that the calc function accepts an unknown number of arguments by using a list.
Basically, this is the
Strategy Pattern without context and with anonymous implementations of the interfaces.
Advantages:
I hope the advantage of doing this becomes clear: We can
extract code that is used by a whole lot of functions to make the code cleaner and easier to maintain.
Disadvantages:
The code is quite verbose in Java.
Speed: it is slower than writing all functions individually. There are two reasons for this: the general overhead from function calling (which can generally be neglected) and the fact that the Java compiler is not able to perform a lot of optimizations. Most of the time, the speed difference will not matter though.
Template Method Pattern
In some situations it makes more sense to use the
template method pattern.
public abstract class Accumulator {
/**
* returns the added results of this accumulator.
*/
public int accumulate(int times) {
int result = 0;
for (int i = 0; i < times; i++) {
result += getNextNumber(i);
}
return result;
}
/**
* returns the i'th number.
*/
abstract int getNextNumber(int i);
}
public class AllNumberAcc extends Accumulator {
@Override
int getNextNumber(int i) {
return i + 1;
}
}
public class EvenNumberAcc extends Accumulator {
@Override
int getNextNumber(int i) {
return (2 * i) + 2;
}
}
And use it like this:
EvenNumberAcc ena = new EvenNumberAcc();
ena.accumulate(10);
Advantages:
It is more flexible than the approach described above
Disadvantages:
It is more work to add a new function and if too many are needed, the many classes may get confusing.
Think about alternatives
If the code is only used by some functions which do nearly the same think about how the function can be changed (sometimes it is enough to add an extra boolean parameter to the signature and an if clause to the method body).
If for example you can be sure that anything you will ever accumulate are numbers up to ten or the first ten even numbers, the above example could look like this:
/**
* returns the added results of func. Func receives [0..times-1].
*/
private int accumulate(boolean allNumbers, int times) {
int result = 0;
for (int i = 0; i < times; i++) {
if (allNumbers) {
result += (i + 1);
} else {
result += ((2 * i) + 2);
}
}
return result;
}
/**
* adds all the numbers from 1 to 10 (result will always be 55).
*/
public int addNumbersToTen() {
return accumulate(true, 10);
}
/*
* adds up the first ten even numbers.
*/
public int addFirstTenEvenNumbers() {
return accumulate(false, 10);
}
If you have for example three different cases you could use an Enum and a switch statement. But if the cases become too many, this can get ugly quite quickly.
Also, there is a performance loss as the if statement has to be executed each time. But again, in most cases this can be neglected.
The above solution is fine for smaller programs, but Java is an object oriented programming language, so that is what should generally be used (most of the time it is a bad idea to fight against the way a language was designed).
The three ways to mimic function passing in Java are quite similar, but they are not the same. It depends on the situation which one to use (or if it would be better to use something entirely different).
