在函数接口中添加静态方法

package example;

interface Action<T, U> {
       U execute(T t);
       static  Action<Void,Void> invoke(Runnable runnable){
           return (v) -> {
               runnable.run();
                return null;
            };         
       }
    }

public class Lambda {


    public static void main(String[] args) {

        Action<Void, Void> a = Action.invoke(() -> System.out.println("Do nothing!"));
        Void t = null;
        a.execute(t);
    }

}

输出

Do nothing!

如果它不需要任何东西，但返回一些东西，则使用Supplier。

如果它获取一些东西，但不返回任何东西，则使用Consumer。

如果Callable返回一个结果并且可能抛出，则使用Callable(最类似于一般CS术语中的Thunk)。

如果Runnable既不做也不能抛出，则使用Runnable。

你所追求的语法是可以用一个小的帮助函数将一个Runnable转换为Action<Void, Void>(你可以把它放在Action中):

public static Action<Void, Void> action(Runnable runnable) {
    return (v) -> {
        runnable.run();
        return null;
    };
}

// Somewhere else in your code
 Action<Void, Void> action = action(() -> System.out.println("foo"));

这是不可能的。具有非Void返回类型的函数(即使它是Void)必须返回一个值。然而，你可以添加静态方法的动作，让你“创建”一个动作:

interface Action<T, U> {
   U execute(T t);

   public static Action<Void, Void> create(Runnable r) {
       return (t) -> {r.run(); return null;};
   }

   public static <T, U> Action<T, U> create(Action<T, U> action) {
       return action;
   } 
}

这将允许您编写以下内容:

// create action from Runnable
Action.create(()-> System.out.println("Hello World")).execute(null);
// create normal action
System.out.println(Action.create((Integer i) -> "number: " + i).execute(100));

λ:

() -> { System.out.println("Do nothing!"); };

实际上表示接口的实现，如下所示:

public interface Something {
    void action();
}

这和你定义的完全不同。这就是为什么你会得到一个错误。

既然你不能扩展你的@FunctionalInterface，也不能引入一个全新的接口，那么我认为你没有太多的选择。不过，您可以使用Optional<T>接口来表示缺少某些值(返回类型或方法参数)。然而，这并不会使体更简单。

你可以为这种特殊情况创建子接口:

interface Command extends Action<Void, Void> {
  default Void execute(Void v) {
    execute();
    return null;
  }
  void execute();
}

它使用默认方法覆盖继承的参数化方法Void execute(Void)，将调用委托给更简单的方法Void execute()。

结果是，它使用起来更简单:

Command c = () -> System.out.println("Do nothing!");