public void Main(){ //在这里定义代码块，并传入 Test 方法里 Test( delegate(){ //代码逻辑 } ); } public void Test(dele a) { invoke(a);////在这里执行传入的代码块 } 这种写法类似 C#到委托，java 里能做到吗？
java：interface，统一实在，没参数的用 Runnable 省去了一个 interface 定义
static class aaa{
static void exec(Func<Integer, Boolean, String> func1, Runnable action1, Action<String,Object,Integer> action2) {
String val=func1.call(123, true);
action1.run();
action2.call(val, new java.util.Date(), 456);
}
interface Action<T1,T2,T3>{
void call(T1 a1,T2 a2,T3 a3);
}
interface Func<T1, T2, ReturnType>{
ReturnType call(T1 a1,T2 a2);
}
static public void test() {
exec(new Func<Integer, Boolean, String>(){
@Override public String call(Integer a1, Boolean a2) {
return a1+” “+a2;
}
},new Runnable() {
@Override public void run() {
System.out.println(“Runnable”);
}
},new Action<String, Object, Integer>() {
@Override public void call(String a1, Object a2, Integer a3) {
System.out.println(a1+” “+a2+” “+a3);
}
});
}
}
Supplier<T>:供给型接口（后勤）
提供需要用到的数据
sup.get();
Function<T, R>:函数型接口（乾坤大挪移）
接收 T 类型转换为 R 类型
fun.apply();
Predicate<T>:断言型接口（包公断案）
判断对与错，把控 if 关卡
至于需要动态逻辑、动态构造代码并执行的，那需要重新来套 lexer, syntaxer, interpreter/compiler 等，而且手动拼装语句容易错，如果是远程给代码直接调用，不如直接用个 JVM 内的解释器。
或者含泪实践格林斯潘第十定律。
//使用了 @FunctionalInterface 以使用 Lambda
@FunctionalInterface
interface Action {
void invoke();
}
//定义与赋值
Action action;
action = () -> {
//some code 1
};
//非 Lambda 写法
action = new Action() {
@Override
public void invoke() {
//some code 2
}
};
//调用
action1.invoke();
使用 Runnable 的原因很简单，它是系统定义的一个 FunctionalInterface，而且很普通，调用 run 方法也跟多线程没有关系，把 Runnable 替换成上面的 Action，就可以少写一个接口
private void blockingCode(Promise<JsonObject> promise)
{
// do something
}
private void resultHandler(AsyncResult<JsonObject> ar)
{
// get result
}
“`
其中 executeBlocking 是这样定义的
“`
<T> void executeBlocking(Handler<Promise<T>> var1, Handler<AsyncResult<T>> var2);
public interface Handler<E> {
void handle(E var1);
}
“`