使用java.lang.reflect.Method对象并调用invoke

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

在线演示

从方法参考中了解更多信息。

自Java 8以来，有一个Function<T, R>接口(docs)，它有方法

R apply(T t);

您可以使用它将函数作为参数传递给其他函数。T是函数的输入类型，R是返回类型。

在你的例子中，你需要传递一个函数，它接受Component类型作为输入，并且不返回任何东西——Void。在这种情况下，Function<T, R>不是最好的选择，因为没有Void类型的自动装箱。您正在寻找的接口名为Consumer<T> (docs) with method

void accept(T t);

它看起来是这样的:

public void setAllComponents(Component[] myComponentArray, Consumer<Component> myMethod) {
    for (Component leaf : myComponentArray) {
        if (leaf instanceof Container) { 
            Container node = (Container) leaf;
            setAllComponents(node.getComponents(), myMethod);
        } 
        myMethod.accept(leaf);
    } 
}

你可以使用方法引用来调用它:

setAllComponents(this.getComponents(), this::changeColor);
setAllComponents(this.getComponents(), this::changeSize); 

假设在同一个类中定义了changeColor()和changeSize()方法。

如果你的方法碰巧接受多个参数，你可以使用bifuncfunction <T, U, R> - T和U是输入参数的类型，R是返回类型。还有bicconsumer< T, U>(两个参数，没有返回类型)。不幸的是，对于3个或更多的输入参数，您必须自己创建一个接口。例如:

public interface Function4<A, B, C, D, R> {

    R apply(A a, B b, C c, D d);
}

Java有一种机制来传递名称和调用它。这是反射机制的一部分。 你的函数应该附加类Method的参数。

public void YouMethod(..... Method methodToCall, Object objWithAllMethodsToBeCalled)
{
...
Object retobj = methodToCall.invoke(objWithAllMethodsToBeCalled, arglist);
...
}

上次我检查的时候，Java不能在本地做你想做的事情;你必须使用“变通方法”来绕过这些限制。在我看来，接口是一种选择，但不是一个好的选择。也许告诉你这句话的人的意思是这样的:

public interface ComponentMethod {
  public abstract void PerfromMethod(Container c);
}

public class ChangeColor implements ComponentMethod {
  @Override
  public void PerfromMethod(Container c) {
    // do color change stuff
  }
}

public class ChangeSize implements ComponentMethod {
  @Override
  public void PerfromMethod(Container c) {
    // do color change stuff
  }
}

public void setAllComponents(Component[] myComponentArray, ComponentMethod 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.PerfromMethod(leaf);
    } //end looping through components
}

然后你可以调用:

setAllComponents(this.getComponents(), new ChangeColor());
setAllComponents(this.getComponents(), new ChangeSize());

首先用要作为参数传递的方法定义一个Interface

public interface Callable {
  public void call(int param);
}

使用该方法实现一个类

class Test implements Callable {
  public void call(int param) {
    System.out.println( param );
  }
}

//像这样调用

Callable cmd = new Test();

这允许您将cmd作为参数传递，并调用接口中定义的方法调用

public invoke( Callable callable ) {
  callable.call( 5 );
}