在许多情况下，你有一个接口，并沿着一个实现它的对象。例如，对话框有OnClickListener。
举个随机的例子：

// The callback interface
interface MyCallback {
    void callbackCall();
}

// The class that takes the callback
class Worker {
   MyCallback callback;

   void onEvent() {
      callback.callbackCall();
   }
}

// Option 1:

class Callback implements MyCallback {
   void callbackCall() {
      // callback code goes here
   }
}

worker.callback = new Callback();

// Option 2:

worker.callback = new MyCallback() {

   void callbackCall() {
      // callback code goes here
   }
};

我可能把选项2的语法搞砸了。现在还早。

当视图中发生某件事时，我会触发Activity正在侦听的事件：

//在（自定义）视图中声明

private OnScoreSavedListener onScoreSavedListener;
    public interface OnScoreSavedListener {
        public void onScoreSaved();
    }
    // ALLOWS YOU TO SET LISTENER && INVOKE THE OVERIDING METHOD 
    // FROM WITHIN ACTIVITY
    public void setOnScoreSavedListener(OnScoreSavedListener listener) {
        onScoreSavedListener = listener;
    }

//活动声明

MyCustomView slider = (MyCustomView) view.findViewById(R.id.slider)
    slider.setOnScoreSavedListener(new OnScoreSavedListener() {
        @Override
        public void onScoreSaved() {
            Log.v("","EVENT FIRED");
        }
    });

如果你想知道更多关于片段之间的通信（回调），请看这里：http://developer.android.com/guide/components/fragments.html#CommunicatingWithActivity

如果可以使用现有接口，则无需定义新接口：android.os.Handler.Callback。传递类型为Callback的对象，并调用回调的handleMessage(Message msg)。

使用接口实现回调方法的示例。
定义接口NewInterface.java。
封装java应用程序1;

public interface NewInterface {
    void callback();
}

创建一个新类，NewClass.java。它将调用主类中的回调方法。

package javaapplication1;

public class NewClass {

    private NewInterface mainClass;

    public NewClass(NewInterface mClass){
        mainClass = mClass;
    }

    public void calledFromMain(){
        //Do somthing...

        //call back main
        mainClass.callback();
    }
}

主类JavaApplication1.java实现接口NewInterface - callback（）方法，创建并调用NewClass对象，NewClass对象依次回调其callback（）方法。

package javaapplication1;
public class JavaApplication1 implements NewInterface{

    NewClass newClass;

    public static void main(String[] args) {

        System.out.println("test...");

        JavaApplication1 myApplication = new JavaApplication1();
        myApplication.doSomething();

    }

    private void doSomething(){
        newClass = new NewClass(this);
        newClass.calledFromMain();
    }

    @Override
    public void callback() {
        System.out.println("callback");
    }

}

澄清一下dragon的回答（因为我花了一段时间才弄清楚如何处理Handler.Callback）：
Handler可用于在当前或另一个线程中执行回调，方法是将其传递给Message。Message保存回调中使用的数据。Handler.Callback可传递给Handler的构造函数，以避免直接扩展处理程序。因此，要通过当前线程的回调执行某些代码：

Message message = new Message();
<set data to be passed to callback - eg message.obj, message.arg1 etc - here>

Callback callback = new Callback() {
    public boolean handleMessage(Message msg) {
        <code to be executed during callback>
    }
};

Handler handler = new Handler(callback);
handler.sendMessage(message);

EDIT：刚刚意识到有一种更好的方法可以获得相同的结果（减去控制何时执行回调）：

post(new Runnable() {
    @Override
    public void run() {
        <code to be executed during callback>
    }
});

您也可以使用LocalBroadcast来实现此目的。
创建广播接收器：

LocalBroadcastManager.getInstance(this).registerReceiver(
            mMessageReceiver, new IntentFilter("speedExceeded"));

private BroadcastReceiver mMessageReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        Double currentSpeed = intent.getDoubleExtra("currentSpeed", 20);
        Double currentLatitude = intent.getDoubleExtra("latitude", 0);
        Double currentLongitude = intent.getDoubleExtra("longitude", 0);
        //  ... react to local broadcast message
    }

这就是你如何触发它

Intent intent = new Intent("speedExceeded");
intent.putExtra("currentSpeed", currentSpeed);
intent.putExtra("latitude", latitude);
intent.putExtra("longitude", longitude);
LocalBroadcastManager.getInstance(this).sendBroadcast(intent);

在onPause中取消注册接收器：

protected void onPause() {
  super.onPause();
  LocalBroadcastManager.getInstance(this).unregisterReceiver(mMessageReceiver);
}

假设主要功能是触发事件的活动：

fun main() {

val worker = Worker()

worker.setOnCallListener(
    object: OnCallListener {
        override fun onCall() {
            // here we define what should happen
            // when the event accures
            print("event happend")
        }
    }
)

// most events will be called from Android system itself
// but in our case we have to call it manually
worker.listener.onCall()
}

Worker类具有类型OnCallListener接口的示例和设置其值的方法：

class Worker() {
    lateinit var listener: OnCallListener

    fun setOnCallListener(listener: OnCallListener) {
        this.listener = listener
    }
}

OnCallListener接口如下所示：

interface OnCallListener {
    fun onCall()
}