回调函数是一段代码，你可以把它作为参数传递给其他代码，让它执行。由于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();
    }
}

回调通常会引用一些实际有用的状态。

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

java中的callback方法是一个当事件（称为E）发生时被调用的方法，通常你可以通过传递一个特定接口的实现到负责触发事件E的系统来实现（见示例1）。
同样在更大更复杂的系统中，你可以简单地注解一个方法，系统将识别所有注解的方法，并在事件发生时调用它们（见例2）。当然，系统定义了方法应该接收的参数和其他约束。
例一：

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());

例二：

//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);

通过使用回调机制，我们将得到我们自己的方法实现，或者当事件被点击时得到一个特定的实现。它将主要用于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..
-------------------------------------------

简单地说，回调机制是指调用一个函数时使用另一个函数作为参数。在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);
    }
}

@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，并告诉您的类通过将OnChangeListener接口的实现传递给setOnChangeListener方法来引用回调。

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也完成了它的工作，并且在必要时调用makeSomeChanges会导致使用mOnChangeListener引用执行onChanged方法。

根据工作状态调用onSuccess或onFailure回调方法。

package mains.geeks;

public class Test {
    public static void main(String[] args) throws  Exception {

        Test testObj = new Test();

        testObj.doWork(new Callback() {
            @Override
            public void onSucess() {
                System.out.println("success callback called");
            }
            @Override
            public void onFailure() {
                System.out.println("onFailure callback called");
            }
        });
    }

    public void doWork(Callback callback) {
        System.out.println("doing work");
        if (false){
            callback.onSucess();
        } else {
            callback.onFailure();
        }
    }

    public interface Callback {
        void onSucess();
        void onFailure();
    }
}