我正在寻找一种通过引用传递方法的方法。我知道Java不传递方法作为参数，但是，我想要一个替代方案。
我被告知接口是作为参数传递方法的替代方案，但我不理解接口如何通过引用充当方法。如果我理解正确的话，接口只是一组没有定义的抽象方法。我不想发送一个每次都需要定义的接口，因为几个不同的方法可以用相同的参数调用相同的方法。
我想要完成的是类似这样的事情:
public void setAllComponents(Component[] myComponentArray, Method myMethod) {
for (Component leaf : myComponentArray) {
if (leaf instanceof Container) { //recursive call if Container
Container node = (Container) leaf;
setAllComponents(node.getComponents(), myMethod);
} //end if node
myMethod(leaf);
} //end looping through components
}
调用方法如下:
setAllComponents(this.getComponents(), changeColor());
setAllComponents(this.getComponents(), changeSize());
我没有找到任何解决方案，在这里，显示如何传递方法与参数绑定到它作为一个方法的参数。下面的例子演示了如何传递一个已经绑定了参数值的方法。
步骤1:创建两个接口，一个有返回类型，另一个没有。Java也有类似的接口，但它们没有什么实际用途，因为它们不支持异常抛出。
public interface Do {
void run() throws Exception;
}
public interface Return {
R run() throws Exception;
}
我们如何使用两个接口在事务中封装方法调用的示例。注意，我们传递方法时带有实际参数。
//example - when passed method does not return any value
public void tx(final Do func) throws Exception {
connectionScope.beginTransaction();
try {
func.run();
connectionScope.commit();
} catch (Exception e) {
connectionScope.rollback();
throw e;
} finally {
connectionScope.close();
}
}
//Invoke code above by
tx(() -> api.delete(6));
另一个例子展示了如何传递一个实际返回值的方法
public R tx(final Return func) throws Exception {
R r=null;
connectionScope.beginTransaction();
try {
r=func.run();
connectionScope.commit();
} catch (Exception e) {
connectionScope.rollback();
throw e;
} finally {
connectionScope.close();
}
return r;
}
//Invoke code above by
Object x= tx(() -> api.get(id));
java 8起
Java 8以后，您可以使用lambda表达式提供函数接口(只有一个抽象方法的接口)的抽象方法的实现，并将其作为参数传递给方法。
@FunctionalInterface
interface ArithmeticFunction {
public int calcualate(int a, int b);
}
public class Main {
public static void main(String args[]) {
ArithmeticFunction addition = (a, b) -> a + b;
ArithmeticFunction subtraction = (a, b) -> a - b;
int a = 20, b = 5;
System.out.println(perform(addition, a, b));
// or
System.out.println(perform((x, y) -> x + y, a, b));
System.out.println(perform(subtraction, a, b));
// or
System.out.println(perform((x, y) -> x - y, a, b));
}
static int perform(ArithmeticFunction function, int a, int b) {
return function.calcualate(a, b);
}
}
输出:
25
25
15
15
在线演示
从方法参考中了解更多信息。
我很欣赏上面的答案，但我可以使用下面的方法实现相同的行为;这个想法借鉴自Javascript的回调。我对修正持开放态度，尽管到目前为止(在生产中)还不错。
其思想是在签名中使用函数的返回类型，这意味着yield必须是静态的。
下面是一个运行带有超时的进程的函数。
public static void timeoutFunction(String fnReturnVal) {
Object p = null; // whatever object you need here
String threadSleeptime = null;
Config config;
try {
config = ConfigReader.getConfigProperties();
threadSleeptime = config.getThreadSleepTime();
} catch (Exception e) {
log.error(e);
log.error("");
log.error("Defaulting thread sleep time to 105000 miliseconds.");
log.error("");
threadSleeptime = "100000";
}
ExecutorService executor = Executors.newCachedThreadPool();
Callable<Object> task = new Callable<Object>() {
public Object call() {
// Do job here using --- fnReturnVal --- and return appropriate value
return null;
}
};
Future<Object> future = executor.submit(task);
try {
p = future.get(Integer.parseInt(threadSleeptime), TimeUnit.MILLISECONDS);
} catch (Exception e) {
log.error(e + ". The function timed out after [" + threadSleeptime
+ "] miliseconds before a response was received.");
} finally {
// if task has started then don't stop it
future.cancel(false);
}
}
private static String returnString() {
return "hello";
}
public static void main(String[] args) {
timeoutFunction(returnString());
}
