Question

如果这是一个重复的问题，我很抱歉，我希望能够从另一个方法调用一个在constructors参数列表中定义的方法。

以下是不会编译的代码，但它确实是我能想到描述我的问题的唯一方法。我也希望我的解释有意义。

Main.java

....
Class0 instance = new Class0(arg0, arg1, arg2, new Class1(){
        //do something
        //do something else
        //do more stuff
    }
)
library.go(instance);
....

我想在这里得到的一点是，使用匿名函数初始化了Class0的新实例。然后将实例传递给Library的实例。

Class0.java

....
public Class1 action = null;
public Class0(int arg0, int arg1, int arg2, Class1 class) {
     setArg0(arg0);
     setArg1(arg1);
     setArg2(arg2);
     setAction(class);
}
public setAction(Class1 class) {
     action = class;
}
public action() {
     class;
}
....

Class0是从构造函数方法构造的，并将函数设置为action字段，它仍然是未调用的，但是以后存储。 action（）调用传递给构造函数的函数。

Library.java

....
public void go(Class0 class0) {
    class0.action();
}
....

大多数情况下，Library.java不受我的控制，它是第三方库的管道。 go通过其action方法调用main中声明的实例对象的存储函数。

这样的东西甚至远程存在于java中吗？还有其他方法可以达到同样的目的吗？

Answer 1

编辑：这假设是java 7.0或更早版本。它适用于java 8，但lambda表达式最有可能是首选。

您似乎想要实现回调接口。

使用方法创建一个接口。
使用接口作为方法的参数（在您的情况下为构造函数）。
接口只是对某个对象的引用，因此请调用该方法。

以下是一些代码：

Kapow.java

public interface Kapow
{
    void callbackMethod();
}

KapowImpl.java

public class KapowImpl implements Kapow
{
    @Override
    public void callbackMethod()
    {
        System.out.println("Kapow!");
    }
}

Main.java

public final class Main
{
    private static void callIt(final Kapow theCallback)
    {
        theCallback.callbackMethod();
    }

    public static void main(String[] args)
    {
        Kapow kapowObject = new KapowImpl();

        callIt(kapowObject);
    }
}

Answer 2

“方法类型声明”的一个很好的例子是java.awt.event.ActionListener（见下文）。在Java 8或更高版本中，您可以使用lambda expressions来简化用法，但原则仍然相同 - 带有一个方法声明的接口代表逻辑方法。

/*
 * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package java.awt.event;

import java.util.EventListener;

/**
 * The listener interface for receiving action events.
 * The class that is interested in processing an action event
 * implements this interface, and the object created with that
 * class is registered with a component, using the component's
 * <code>addActionListener</code> method. When the action event
 * occurs, that object's <code>actionPerformed</code> method is
 * invoked.
 *
 * @see ActionEvent
 * @see <a href="http://java.sun.com/docs/books/tutorial/post1.0/ui/eventmodel.html">Tutorial: Java 1.1 Event Model</a>
 *
 * @author Carl Quinn
 * @since 1.1
 */
public interface ActionListener extends EventListener {

    /**
     * Invoked when an action occurs.
     */
    public void actionPerformed(ActionEvent e);

}

以下是如何使用该模式的简单示例：

public static void main(String[] args) {
    ActionListener squeezeAction = new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("Ouch!");
        }
    };
    performAction(squeezeAction);
}

public static void performAction(ActionListener method) {
    method.actionPerformed(null); //invoke method
}

使用lambda表达式（需要JRE 1.8或更高版本），可以简化为：

public static void main(String[] args) {
    ActionListener squeezeAction = e -> System.out.println("Ouch!");
    performAction(squeezeAction);
}

public static void performAction(ActionListener method) {
    method.actionPerformed(null); //invoke method
}

或作为现有方法的参考：

public class Test {
    public static void main(String[] args) {
        ActionListener squeezeAction = Test::squeeze;
        performAction(squeezeAction);
    }

    public static void sqeeze(ActionEvent e) {
        System.out.println("Ouch!");
    }

    public static void performAction(ActionListener method) {
        method.actionPerformed(null); //invoke method
    }
}

从参数调用方法

2 个答案: