我正在寻找一种通过引用传递方法的方法。我知道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());
编辑:在Java 8中，lambda表达式是一个很好的解决方案，正如其他答案所指出的那样。下面的答案是为Java 7和更早的版本编写的…
看一下命令模式。
// NOTE: code not tested, but I believe this is valid java...
public class CommandExample
{
public interface Command
{
public void execute(Object data);
}
public class PrintCommand implements Command
{
public void execute(Object data)
{
System.out.println(data.toString());
}
}
public static void callCommand(Command command, Object data)
{
command.execute(data);
}
public static void main(String... args)
{
callCommand(new PrintCommand(), "hello world");
}
}
编辑:正如Pete Kirkham所指出的，还有另一种使用访问者的方法。访问者方法稍微复杂一些——您的节点都需要使用acceptVisitor()方法来感知访问者——但如果您需要遍历一个更复杂的对象图，那么它就值得研究。
我很欣赏上面的答案，但我可以使用下面的方法实现相同的行为;这个想法借鉴自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());
}
编辑:在Java 8中，lambda表达式是一个很好的解决方案，正如其他答案所指出的那样。下面的答案是为Java 7和更早的版本编写的…
看一下命令模式。
// NOTE: code not tested, but I believe this is valid java...
public class CommandExample
{
public interface Command
{
public void execute(Object data);
}
public class PrintCommand implements Command
{
public void execute(Object data)
{
System.out.println(data.toString());
}
}
public static void callCommand(Command command, Object data)
{
command.execute(data);
}
public static void main(String... args)
{
callCommand(new PrintCommand(), "hello world");
}
}
编辑:正如Pete Kirkham所指出的，还有另一种使用访问者的方法。访问者方法稍微复杂一些——您的节点都需要使用acceptVisitor()方法来感知访问者——但如果您需要遍历一个更复杂的对象图，那么它就值得研究。
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
在线演示
从方法参考中了解更多信息。
