java - Java中的回调方法是什么？（术语似乎使用松散）

Question

我不明白什么是回调方法，而且我听说人们非常松散地使用该术语。在 Java 世界中，什么是回调方法？如果有人可以提供一些 Java 回调方法的示例代码并进行解释，那将对我的 Java 学习之旅有很大帮助。

Answer 1

回调是一段代码，您将其作为参数传递给其他代码，以便它执行它。由于 Java 还不支持函数指针，因此它们被实现为 Command 对象。就像是

public class Test {
    public static void main(String[] args) throws  Exception {
        new Test().doWork(new Callback() { // implementing class            
            @Override
            public void call() {
                System.out.println("callback called");
            }
        });
    }

    public void doWork(Callback callback) {
        System.out.println("doing work");
        callback.call();
    }

    public interface Callback {
        void call();
    }
}

回调通常会持有对某些状态的引用以使其真正有用。

通过使回调实现对您的代码具有所有依赖关系，您可以在代码和执行回调的代码之间获得间接性。

Answer 2

java中的回调方法是在事件（调用它E）发生时被调用的方法。通常，您可以通过将某个接口的实现传递给负责触发事件的系统来实现它E（参见示例 1）。

同样在更大和更复杂的系统中，您可以简单地注释一个方法，系统将识别所有注释的方法，并在事件发生时调用它们（参见示例 2）。当然，系统定义了方法应该接收哪些参数和其他约束。

示例 1：

public interface Callback {
    //parameters can be of any types, depending on the event defined
    void callbackMethod(String aParameter);
}


public class CallbackImpl implements Callback {
    void callbackMethod(String aParameter) {
     //here you do your logic with the received paratemers
     //System.out.println("Parameter received: " + aParameter);

    }
}

//.... and then somewhere you have to tell the system to add the callback method
//e.g. systemInstance.addCallback(new CallbackImpl());

示例 2：

//by annotating a method with this annotation, the system will know which method it should call. 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CallbackAnnotation {}


public class AClass {

    @CallbackAnnotation
    void callbackMethod(String aParameter) {
     //here you do your logic with the received paratemers
     //System.out.println("Parameter received: " + aParameter);

    }
}

//.... and then somewhere you have to tell the system to add the callback class
//and the system will create an instance of the callback class
//e.g. systemInstance.addCallbackClass(AClass.class);

Answer 3

简单来说，回调机制是指以另一个函数作为参数调用一个函数。在 C、C++ 等语言中，这是通过将函数指针作为参数传递来完成的，但 java 没有指针的概念。解决方法是接口。我们传递对接口的引用而不是指针。看完下面的代码，你的理解就会一清二楚。为了展示真实世界的应用程序，想象一下购买鼠标和鼠标垫。鼠标垫价格是固定的，但鼠标价格因品牌而异。

interface mouse
{
    double mousePrice();
}
class BrandA implements mouse
{
    public double mousePrice()          //note that public access modifier is needed as all methods of interface are public are by default and when you override them
    //you cannot use any access modifier more restrictive
    {
        return 100;
    }

}

class BrandB implements mouse
{
    public double mousePrice()
    {
        return 200;
    }

}

class Simple
{
    static void total(mouse t)
    {
        double mousepad = 20;
        double mousep = t.mousePrice();
        System.out.println(mousepad + mousep);
    }
    public static void main(String args[])
    {
        mouse ob = new BrandA();        //upcasting. 
        total(ob);
    }
}

Answer 4

通过使用回调机制，我们将获得我们自己的方法实现只回调。或单击事件时的特定实现。它将主要用于 java 的 EventHandlers 中。

package com.callbackExample;

public abstract interface SomeEventHandler {
    public abstract void hadleClick();//by default abstract

}

package com.callbackExample;

public class SomeEventImplementation implements SomeEventHandler {

    @Override
    public void hadleClick() {
        System.out.println("Click Handler : clicked");
    }

}

package com.callbackExample;

public class Button {
    public void onClick(SomeEventHandler clickEventHandler) {
        clickEventHandler.hadleClick();
    }

}
package com.callbackExample;

public class Test {
    public static void main(String[] args) {
        Button button=new Button();
        SomeEventImplementation someEventImplementation=new SomeEventImplementation();
        button.onClick(someEventImplementation);
        
        Button button2=new Button();
        button2.onClick(new SomeEventHandler() {
            
            @Override
            public void hadleClick() {
                System.out.println("button2 : my own implementation..");
            }
        });
    }

}

-------------------------------------------
OUTPUT  : Click Handler : clicked
          button2 : my own implementation..
-------------------------------------------

Answer 5

@Sotirios Delimanolis 的回答很好，但我想给出一个清晰的例子，以一种听众如何工作的方式解释回调 - android 库大量采用了以下方法。

class RemoteClass {

    private OnChangeListener mOnChangeListener;

    void makeSomeChanges() {
        /*
        .. do something here and call callback
        */
        mOnChangeListener.onChanged(this, 1);
    }

    public void setOnChangeListener(OnChangeListener listener) {
        mOnChangeListener = listener;
    }

    public interface OnChangeListener {
        public void onChanged(RemoteClass remoteClass, int test);
    }
}

有一个类建立了我的人，它通过名称告诉你的类通过将 接口RemoteClass的实现传递给方法来引用回调。OnChangeListenersetOnChangeListener

class Test {

    public static void main(String[] args) {    
        RemoteClass obj = new RemoteClass();
        obj.setOnChangeListener(demoChanged);
        obj.makeSomeChanges();
    }

    private static RemoteClass.OnChangeListener demoChanged = new RemoteClass.OnChangeListener() {
        @Override
        public void onChanged(RemoteClass remoteClass, int incoming) {
            switch (incoming) {
                case 1:
                    System.out.println("I will take appropriate action!");
                    break;
                default:
                    break;
            }
        }
    };
}

现在你的类已经完成了它的任务并完成了它的工作，并且在必要RemoteClass时调用会导致使用引用执行方法。makeSomeChangesonChangedmOnChangeListener