Java 8 及更高版本

使用 Java 8+ lambda 表达式，如果您有一个只有一个抽象方法（有时称为 SAM 类型）的类或接口，例如：

public interface MyInterface {
    String doSomething(int param1, String param2);
}

那么在任何地方使用 MyInterface，你都可以替换一个 lambda 表达式：

class MyClass {
    public MyInterface myInterface = (p1, p2) -> { return p2 + p1; };
}

例如，您可以非常快速地创建新线程：

new Thread(() -> someMethod()).start();

并使用方法引用语法使其更加干净：

new Thread(this::someMethod).start();

如果没有 lambda 表达式，最后两个示例将如下所示：

new Thread(new Runnable() { someMethod(); }).start();

在 Java 8 之前

一种常见的模式是将其“包装”在接口中，例如，然后传入一个可调用的：Callable

public T myMethod(Callable<T> func) {
    return func.call();
}

此模式称为命令模式。

请记住，您最好为您的特定用途创建一个界面。如果您选择使用可调用，则可以将上面的 T 替换为您期望的任何类型的返回值，例如 String。

针对您在下面的评论，您可以说：

public int methodToPass() { 
        // do something
}

public void dansMethod(int i, Callable<Integer> myFunc) {
       // do something
}

然后调用它，也许使用一个匿名的内部类：

dansMethod(100, new Callable<Integer>() {
   public Integer call() {
        return methodToPass();
   }
});

请记住，这不是一个“技巧”。它只是java的基本概念等同于函数指针。

您可以使用Java反射来执行此操作。该方法将表示为java.lang.reflect.Method的实例。

import java.lang.reflect.Method;

public class Demo {

    public static void main(String[] args) throws Exception{
        Class[] parameterTypes = new Class[1];
        parameterTypes[0] = String.class;
        Method method1 = Demo.class.getMethod("method1", parameterTypes);

        Demo demo = new Demo();
        demo.method2(demo, method1, "Hello World");
    }

    public void method1(String message) {
        System.out.println(message);
    }

    public void method2(Object object, Method method, String message) throws Exception {
        Object[] parameters = new Object[1];
        parameters[0] = message;
        method.invoke(object, parameters);
    }

}