Java设计模式之桥接模式

桥接模式（Bridge Pattern）是一种常用的软件设计模式，它将抽象部分与实现部分分离，使它们可以独立地变化。桥接模式的核心思想是通过将抽象和实现分离，使它们可以独立地变化，从而降低它们之间的耦合度，提高系统的灵活性。

在桥接模式中，抽象部分和实现部分分别由两个独立的类层次结构组成，通过桥接模式可以使这两个类层次结构独立地变化。抽象部分包含一个指向实现部分的引用，通过调用实现部分的方法来完成具体的业务逻辑。

下面是一个示例，展示了如何使用桥接模式来处理不同类型的消息发送。

首先，我们定义一个消息发送的抽象类 Message，它包含一个 MessageSender 接口类型的成员变量 sender，用于发送消息。

public abstract class Message {
    protected MessageSender sender;

    public Message(MessageSender sender) {
        this.sender = sender;
    }

    public abstract void send();
}
1
2
3
4
5
6
7
8
9

然后，我们定义一个具体的消息类 TextMessage，继承自 Message，并实现其抽象方法。

public class TextMessage extends Message {
    public TextMessage(MessageSender sender) {
        super(sender);
    }

    @Override
    public void send() {
        // 调用实现部分的方法来发送文本消息
        sender.sendMessage("Text message");
    }
}
1
2
3
4
5
6
7
8
9
10
11

接下来，我们定义一个消息发送器的接口 MessageSender，它包含一个发送消息的方法 sendMessage。

public interface MessageSender {
    void sendMessage(String message);
}
1
2
3

然后，我们可以定义不同类型的消息发送器，比如 EmailMessageSender 和 SMSMessageSender。

public class EmailMessageSender implements MessageSender {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending email message: " + message);
    }
}

public class SMSMessageSender implements MessageSender {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending SMS message: " + message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

最后，我们可以使用桥接模式来发送不同类型的消息。

public class Main {
    public static void main(String[] args) {
        // 创建一个文本消息，并使用 EmailMessageSender 发送
        Message textMessage = new TextMessage(new EmailMessageSender());
        textMessage.send();

        // 创建一个文本消息，并使用 SMSMessageSender 发送
        Message smsMessage = new TextMessage(new SMSMessageSender());
        smsMessage.send();
    }
}
1
2
3
4
5
6
7
8
9
10
11

在上面的示例中，Message 类是抽象部分，TextMessage 类是具体的抽象部分，MessageSender 接口是实现部分，EmailMessageSender 和 SMSMessageSender 类是具体的实现部分。通过桥接模式，我们可以将消息发送的抽象部分和实现部分分离，使它们可以独立地变化。这样，当我们需要添加新的消息类型或发送器时，只需要新增相应的类，而不需要修改现有的代码，从而提高了系统的灵活性和可扩展性。