实现含有三个同事类的中介者模式的示例代码，其中每个同事可以向其他一个或两个同事发送消息。

以下是一个简单的示例代码，实现了一个包含三个同事类的中介者模式，每个同事可以向其他两个同事发送消息：

// 抽象同事类
abstract class Colleague {
    protected Mediator mediator;

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void send(String message);

    public abstract void receive(String message);
}

// 具体同事类1
class ConcreteColleague1 extends Colleague {
    public void send(String message) {
        mediator.send(message, this);
    }

    public void receive(String message) {
        System.out.println("ConcreteColleague1 received message: " + message);
    }
}

// 具体同事类2
class ConcreteColleague2 extends Colleague {
    public void send(String message) {
        mediator.send(message, this);
    }

    public void receive(String message) {
        System.out.println("ConcreteColleague2 received message: " + message);
    }
}

// 具体同事类3
class ConcreteColleague3 extends Colleague {
    public void send(String message) {
        mediator.send(message, this);
    }

    public void receive(String message) {
        System.out.println("ConcreteColleague3 received message: " + message);
    }
}

// 抽象中介者类
abstract class Mediator {
    public abstract void send(String message, Colleague colleague);
}

// 具体中介者类
class ConcreteMediator extends Mediator {
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;
    private ConcreteColleague3 colleague3;

    public void setColleague1(ConcreteColleague1 colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(ConcreteColleague2 colleague2) {
        this.colleague2 = colleague2;
    }

    public void setColleague3(ConcreteColleague3 colleague3) {
        this.colleague3 = colleague3;
    }

    public void send(String message, Colleague colleague) {
        if (colleague == colleague1) {
            colleague2.receive(message);
            colleague3.receive(message);
        } else if (colleague == colleague2) {
            colleague1.receive(message);
            colleague3.receive(message);
        } else if (colleague == colleague3) {
            colleague1.receive(message);
            colleague2.receive(message);
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ConcreteColleague1 colleague1 = new ConcreteColleague1();
        ConcreteColleague2 colleague2 = new ConcreteColleague2();
        ConcreteColleague3 colleague3 = new ConcreteColleague3();

        ConcreteMediator mediator = new ConcreteMediator();
        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);
        mediator.setColleague3(colleague3);

        colleague1.setMediator(mediator);
        colleague2.setMediator(mediator);
        colleague3.setMediator(mediator);

        colleague1.send("Hello from colleague1");
        colleague2.send("Hi from colleague2");
        colleague3.send("Greetings from colleague3");
    }
}

在上面的示例代码中，`Colleague` 是抽象同事类，定义了每个具体同事类必须实现的方法，并持有一个中介者对象。`ConcreteColleague1`、`ConcreteColleague2` 和 `ConcreteColleague3` 是具体同事类，每个类实现了 `send` 和 `receive` 方法，分别用于向其他同事发送消息和接收消息。

`Mediator` 是抽象中介者类，定义了中介者必须实现的方法。`ConcreteMediator` 是具体中介者类，实现了 `send` 方法，根据接收到的消息和发送消息的同事对象，将消息转发给其他同事对象。

客户端代码中，创建了三个具体同事对象和一个具体中介者对象，并将同事对象和中介者对象关联起来。然后，每个同事对象都向其他同事发送消息。当一个同事对象发送消息时，中介者对象会根据消息和发送消息的同事对象，将消息转发给其他同事对象。每个同事对象收到消息后，会打印出接收到的消息。