中介者模式（Mediator Pattern）

// 抽象中介者：定义注册用户和转发消息的接口
public interface IMediator {
    // 注册用户（同事）到中介者
    void register(User user);
    // 转发消息：参数1=发送者，参数2=消息内容
    void relayMessage(User sender, String message);
}

// 抽象同事：用户，持有中介者引用
public abstract class User {
    protected IMediator mediator; // 持有中介者引用（核心）
    protected String name;

    public User(IMediator mediator, String name) {
        this.mediator = mediator;
        this.name = name;
    }

    // 发送消息（委托给中介者）
    public abstract void sendMessage(String message);

    // 接收消息（处理消息）
    public abstract void receiveMessage(String senderName, String message);
}

// 具体中介者：聊天室，维护所有用户，负责转发消息
import java.util.ArrayList;
import java.util.List;

public class ChatRoom implements IMediator {
    // 维护所有注册的用户（同事）
    private final List<User> userList = new ArrayList<>();

    @Override
    public void register(User user) {
        if (!userList.contains(user)) {
            userList.add(user);
            System.out.println("[聊天室] 用户 " + user.name + " 加入聊天室");
        }
    }

    @Override
    public void relayMessage(User sender, String message) {
        // 逻辑：将消息转发给所有非发送者的用户
        for (User user : userList) {
            if (user != sender) { // 不发给自己
                user.receiveMessage(sender.name, message);
            }
        }
    }
}

// 具体同事：普通用户
public class ConcreteUser extends User {
    public ConcreteUser(IMediator mediator, String name) {
        super(mediator, name);
    }

    @Override
    public void sendMessage(String message) {
        System.out.println("[用户 " + name + "] 发送消息：" + message);
        // 委托中介者转发消息
        mediator.relayMessage(this, message);
    }

    @Override
    public void receiveMessage(String senderName, String message) {
        System.out.println("[用户 " + name + "] 收到 " + senderName + " 的消息：" + message);
    }
}

// 客户端：模拟用户在聊天室交互
public class MediatorClient {
    public static void main(String[] args) {
        // 1. 创建中介者（聊天室）
        IMediator chatRoom = new ChatRoom();

        // 2. 创建同事（用户）并注册到中介者
        User alice = new ConcreteUser(chatRoom, "Alice");
        User bob = new ConcreteUser(chatRoom, "Bob");
        User charlie = new ConcreteUser(chatRoom, "Charlie");
        chatRoom.register(alice);
        chatRoom.register(bob);
        chatRoom.register(charlie);

        // 3. 模拟用户发送消息
        System.out.println("\n===== 消息交互开始 =====");
        alice.sendMessage("大家好！我是Alice～");
        System.out.println("------------------------");
        bob.sendMessage("Hi Alice！我是Bob～");
        System.out.println("------------------------");
        charlie.sendMessage("欢迎加入聊天室！");
    }
}

public abstract class Colleague {

    public abstract void onEvent(Mediator mediator);

}

public class Alarm extends Colleague {



    @Override

    public void onEvent(Mediator mediator) {

        mediator.doEvent("alarm");

    }



    public void doAlarm() {

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

    }

}

public class CoffeePot extends Colleague {

    @Override

    public void onEvent(Mediator mediator) {

        mediator.doEvent("coffeePot");

    }



    public void doCoffeePot() {

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

    }

}

public class Calender extends Colleague {

    @Override

    public void onEvent(Mediator mediator) {

        mediator.doEvent("calender");

    }



    public void doCalender() {

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

    }

}

public class Sprinkler extends Colleague {

    @Override

    public void onEvent(Mediator mediator) {

        mediator.doEvent("sprinkler");

    }



    public void doSprinkler() {

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

    }

}

public abstract class Mediator {

    public abstract void doEvent(String eventType);

}

public class ConcreteMediator extends Mediator {

    private Alarm alarm;

    private CoffeePot coffeePot;

    private Calender calender;

    private Sprinkler sprinkler;



    public ConcreteMediator(Alarm alarm, CoffeePot coffeePot, Calender calender, Sprinkler sprinkler) {

        this.alarm = alarm;

        this.coffeePot = coffeePot;

        this.calender = calender;

        this.sprinkler = sprinkler;

    }



    @Override

    public void doEvent(String eventType) {

        switch (eventType) {

            case "alarm":

                doAlarmEvent();

                break;

            case "coffeePot":

                doCoffeePotEvent();

                break;

            case "calender":

                doCalenderEvent();

                break;

            default:

                doSprinklerEvent();

        }

    }



    public void doAlarmEvent() {

        alarm.doAlarm();

        coffeePot.doCoffeePot();

        calender.doCalender();

        sprinkler.doSprinkler();

    }



    public void doCoffeePotEvent() {

        // ...

    }



    public void doCalenderEvent() {

        // ...

    }



    public void doSprinklerEvent() {

        // ...

    }

}

public class Client {

    public static void main(String[] args) {

        Alarm alarm = new Alarm();

        CoffeePot coffeePot = new CoffeePot();

        Calender calender = new Calender();

        Sprinkler sprinkler = new Sprinkler();

        Mediator mediator = new ConcreteMediator(alarm, coffeePot, calender, sprinkler);

        // 闹钟事件到达，调用中介者就可以操作相关对象

        alarm.onEvent(mediator);

    }

}

doAlarm()

doCoffeePot()

doCalender()

doSprinkler()

// 1. 定义交互接口（中介者接口）
public interface OnFragmentInteractionListener {
    void onFragmentADataSent(String data);
}

// 2. Activity作为具体中介者
public class MainActivity extends AppCompatActivity implements OnFragmentInteractionListener {
    private FragmentB fragmentB;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        fragmentB = (FragmentB) getSupportFragmentManager().findFragmentById(R.id.fragment_b);
    }

    // 实现接口，转发FragmentA的数据给FragmentB
    @Override
    public void onFragmentADataSent(String data) {
        if (fragmentB != null) {
            fragmentB.updateData(data);
        }
    }
}

// 3. FragmentA（具体同事）
public class FragmentA extends Fragment {
    private OnFragmentInteractionListener listener;

    // 绑定Activity时获取中介者引用
    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        if (context instanceof OnFragmentInteractionListener) {
            listener = (OnFragmentInteractionListener) context;
        } else {
            throw new RuntimeException("Activity需实现OnFragmentInteractionListener");
        }
    }

    // 发送数据给FragmentB（通过中介者）
    private void sendDataToFragmentB() {
        if (listener != null) {
            listener.onFragmentADataSent("来自FragmentA的数据");
        }
    }
}