我明白你的问题——当在同一个Activity里多次调用这个AlertDialog时，所有确认按钮的点击都会触发同一个onYesClicked()方法，根本没法区分是哪个弹窗触发的，很容易导致逻辑混乱。其实解决这个问题的核心是让每个Dialog实例能绑定自己独有的回调逻辑，而不是依赖Activity实现单一的接口方法。

给你两种实用的解决方案，从灵活度最高的开始讲：

方案一：使用自定义回调接口（推荐，灵活度拉满） #

这种方法让你在创建每个Dialog时直接传入对应的点击处理逻辑，完全避免了多个Dialog共享同一个回调方法的问题。

步骤1：修改ExampleDialog类 #

把原来依赖Activity实现的接口替换成可以传入的回调实例，同时利用Java 8+的Lambda特性简化代码：

import android.app.AlertDialog;
import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.os.Bundle;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatDialogFragment;

public class ExampleDialog extends AppCompatDialogFragment {
    private static final String ARGUMENT_TITLE = "title";
    private static final String ARGUMENT_MESSAGE = "message";
    private static final String ARGUMENT_POSITIVE_TEXT = "positive_text";
    private static final String ARGUMENT_POSITIVE_TOAST = "positive_toast";
    private static final String ARGUMENT_NEGATIVE_TEXT = "negative_text";
    private static final String ARGUMENT_NEGATIVE_TOAST = "negative_toast";

    // 定义函数式接口，支持Lambda表达式
    @FunctionalInterface
    public interface OnPositiveClickListener {
        void onPositiveClicked();
    }

    @FunctionalInterface
    public interface OnNegativeClickListener {
        void onNegativeClicked();
    }

    private OnPositiveClickListener positiveClickListener;
    private OnNegativeClickListener negativeClickListener;
    private String title;
    private String message;
    private String positiveText;
    private String positiveToast;
    private String negativeText;
    private String negativeToast;

    // 修改newInstance方法，添加回调参数
    public static ExampleDialog newInstance(String title, String message,
                                            String positiveText, String positiveToast,
                                            String negativeText, String negativeToast,
                                            OnPositiveClickListener positiveListener,
                                            OnNegativeClickListener negativeListener) {
        Bundle args = new Bundle();
        args.putString(ARGUMENT_TITLE, title);
        args.putString(ARGUMENT_MESSAGE, message);
        args.putString(ARGUMENT_POSITIVE_TEXT, positiveText);
        args.putString(ARGUMENT_POSITIVE_TOAST, positiveToast);
        args.putString(ARGUMENT_NEGATIVE_TEXT, negativeText);
        args.putString(ARGUMENT_NEGATIVE_TOAST, negativeToast);

        ExampleDialog fragment = new ExampleDialog();
        fragment.setArguments(args);
        // 绑定各自的回调逻辑
        fragment.positiveClickListener = positiveListener;
        fragment.negativeClickListener = negativeListener;
        return fragment;
    }

    @Override
    public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
        title = getArguments().getString(ARGUMENT_TITLE);
        message = getArguments().getString(ARGUMENT_MESSAGE);
        positiveText = getArguments().getString(ARGUMENT_POSITIVE_TEXT);
        positiveToast = getArguments().getString(ARGUMENT_POSITIVE_TOAST);
        negativeText = getArguments().getString(ARGUMENT_NEGATIVE_TEXT);
        negativeToast = getArguments().getString(ARGUMENT_NEGATIVE_TOAST);

        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setTitle(title)
                .setMessage(message)
                .setNegativeButton(negativeText, (dialog, which) -> {
                    Toast.makeText(getContext(), negativeToast, Toast.LENGTH_SHORT).show();
                    // 触发取消按钮的回调（如果有传入的话）
                    if (negativeClickListener != null) {
                        negativeClickListener.onNegativeClicked();
                    }
                })
                .setPositiveButton(positiveText, (dialog, which) -> {
                    Toast.makeText(getContext(), positiveToast, Toast.LENGTH_SHORT).show();
                    // 触发确认按钮的回调
                    if (positiveClickListener != null) {
                        positiveClickListener.onPositiveClicked();
                    }
                });
        return builder.create();
    }

    // 移除原来的onAttach和ExampleDialogListener接口，不再需要Activity强制实现接口
}

步骤2：在Activity中调用不同的Dialog #

现在你可以为每个Dialog单独指定点击逻辑，完全不会冲突：

// 示例1：删除弹窗
public void openDeleteDialog() {
    ExampleDialog dialog = ExampleDialog.newInstance(
            "删除确认",
            "确定要删除这条记录吗？",
            "删除",
            "正在删除...",
            "取消",
            "已取消删除",
            // 确认按钮的专属逻辑
            () -> deleteSelectedRecord(),
            // 取消按钮的专属逻辑（不需要的话可以传null）
            () -> Toast.makeText(this, "你点击了取消", Toast.LENGTH_SHORT).show()
    );
    dialog.show(getSupportFragmentManager(), "delete_dialog");
}

// 示例2：登出弹窗
public void openLogoutDialog() {
    ExampleDialog dialog = ExampleDialog.newInstance(
            "登出确认",
            "确定要退出当前账号吗？",
            "登出",
            "正在登出...",
            "取消",
            "已取消登出",
            // 确认按钮的专属逻辑
            () -> performLogout(),
            null // 取消按钮不需要逻辑，传null即可
    );
    dialog.show(getSupportFragmentManager(), "logout_dialog");
}

// 对应的业务处理方法
private void deleteSelectedRecord() {
    // 这里写删除记录的具体逻辑
}

private void performLogout() {
    // 这里写登出账号的具体逻辑
}

方案二：给回调方法加标识参数（兼容旧版Java） #

如果你还在使用Java 7或更低版本，没法用Lambda，可以给原来的回调方法加一个标识参数，区分不同的Dialog：

步骤1：修改ExampleDialog的接口和回调逻辑 #

// 修改原有的ExampleDialogListener接口，添加tag参数
public interface ExampleDialogListener {
    void onYesClicked(String dialogTag);
}

@Override
public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
    // ... 其他代码保持不变 ...
    .setPositiveButton(positive, new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
            Toast toast = Toast.makeText(getContext(), positivetext, Toast.LENGTH_SHORT);
            toast.show();
            // 传入当前Dialog的tag（就是show时传入的第二个参数）
            listener.onYesClicked(getTag());
        }
    });
    return builder.create();
}

步骤2：在Activity中区分处理 #

@Override
public void onYesClicked(String dialogTag) {
    // 根据Dialog的tag判断是哪个弹窗触发的
    switch (dialogTag) {
        case "delete_dialog":
            deleteSelectedRecord();
            break;
        case "logout_dialog":
            performLogout();
            break;
        // 其他弹窗的tag可以继续添加case
    }
}

// 调用时指定不同的tag
public void openDeleteDialog() {
    ExampleDialog dialog = ExampleDialog.newInstance("删除确认", "确定要删除吗？", "删除", "正在删除", "取消", "已取消");
    dialog.show(getSupportFragmentManager(), "delete_dialog");
}

public void openLogoutDialog() {
    ExampleDialog dialog = ExampleDialog.newInstance("登出确认", "确定要登出吗？", "登出", "正在登出", "取消", "已取消");
    dialog.show(getSupportFragmentManager(), "logout_dialog");
}

两种方案里，方案一更推荐，因为它让每个Dialog的逻辑更独立，代码更清晰，不需要在Activity里写一大段switch判断。而且用Lambda表达式的话，代码会非常简洁。

内容的提问来源于stack exchange，提问作者confusedcoder