Android 回调-在从处理程序实例化时，更喜欢组合而不是继承

我想知道Handler.Callback的用法。我在网上找不到任何详细信息。在以下资源中： 据说：

我们可以通过传递一个 在处理程序构造期间回调

资源的示例如下所示：

public static class SpeakHandler extends Handler {
    public static final int SAY_HELLO = 0;
    public static final int SAY_BYE = 1;
    public SpeakHandler(Callback callback) {
        super(callback);
    }
    @Override
    public void handleMessage(Message msg) {
        switch(msg.what) {
            case SAY_HELLO:
                sayWord("hello"); break;
            case SAY_BYE:
                sayWord("goodbye"); break;
            default:
                super.handleMessage(msg);
        }
    }
    private void sayWord(String word) { … }
}
public static class Speaker implements Handler.Callback {
    public static final int SAY_WORD = 2;
    @Override
    public boolean handleMessage(Message msg) {
        if (msg.what == SAY_WORD) {
            sayWord((String)msg.obj);
            return true;
        }
        return false;
    }
    private void sayWord(String word) { … }
}
Handler h = new SpeakHandler(new Speaker());
h.sendMessage(Message.obtain(handler, Speaker.SAY_WORD, "!?"));

    public static class SpeakHandler extends Handler {
    public static final int SAY_HELLO = 0;
    public static final int SAY_BYE = 1;
    public static final int SAY_WORD = 2;
    @Override
    public void handleMessage(Message msg) {
        switch(msg.what) {
            case SAY_HELLO:
                sayWord("hello"); break;
            case SAY_BYE:
                sayWord("goodbye"); break;
            case SAY_WORD:
                sayWord((String)msg.obj); break;
            default:
                super.handleMessage(msg);
        }
    }
    private void sayWord(String word) { … }
}

为什么我需要上面代码中的Handler.Callback？我可以做以下相同的事情：

public static class SpeakHandler extends Handler {
    public static final int SAY_HELLO = 0;
    public static final int SAY_BYE = 1;
    public SpeakHandler(Callback callback) {
        super(callback);
    }
    @Override
    public void handleMessage(Message msg) {
        switch(msg.what) {
            case SAY_HELLO:
                sayWord("hello"); break;
            case SAY_BYE:
                sayWord("goodbye"); break;
            default:
                super.handleMessage(msg);
        }
    }
    private void sayWord(String word) { … }
}
public static class Speaker implements Handler.Callback {
    public static final int SAY_WORD = 2;
    @Override
    public boolean handleMessage(Message msg) {
        if (msg.what == SAY_WORD) {
            sayWord((String)msg.obj);
            return true;
        }
        return false;
    }
    private void sayWord(String word) { … }
}
Handler h = new SpeakHandler(new Speaker());
h.sendMessage(Message.obtain(handler, Speaker.SAY_WORD, "!?"));

    public static class SpeakHandler extends Handler {
    public static final int SAY_HELLO = 0;
    public static final int SAY_BYE = 1;
    public static final int SAY_WORD = 2;
    @Override
    public void handleMessage(Message msg) {
        switch(msg.what) {
            case SAY_HELLO:
                sayWord("hello"); break;
            case SAY_BYE:
                sayWord("goodbye"); break;
            case SAY_WORD:
                sayWord((String)msg.obj); break;
            default:
                super.handleMessage(msg);
        }
    }
    private void sayWord(String word) { … }
}

什么是Handler.Callback？官方文件中说

实例化处理程序时可以使用的回调接口，以避免 必须实现自己的Handler子类。 我不明白这是什么意思

---

关于这一点的详细讨论可以在软件工程Stackexchange上找到：一般来说，组合是首选的，因为随着程序规模的增长，它的可扩展性更强。然而，它经常被说成是编程教条，而不是实际的硬规则。我想说的是，

处理程序

不是

说话人

，而

说话人

也不是

处理程序

，因此将两者合并为一个实体在逻辑上是没有意义的。@DeeV，什么是处理程序。回调？