依赖倒置原则

依赖倒置原则：高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。

高层模块不应该直接依赖于底层模块的具体实现，而应该依赖于底层的抽象。 模块间的依赖是通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的。

接口和抽象类不应该依赖于实现类，而实现类依赖接口或抽象类。这一点其实不用多说，很好理解，面向接口编程思想正是这点的最好体现。

依赖倒置原则强调高层模块不应该依赖于低层模块，二者都应该依赖于抽象。

抽象不应该依赖于具体实现细节，而具体实现细节应该依赖于抽象。 这样可以降低模块之间的耦合性，提高代码的可测试性和可维护性。

举例说明

这里通过一个例子对依赖倒置原则进行说明。例如：

定义一个 IMessageSender 接口，它声明了一个 sendMessage 方法，表示发送消息的操作。 EmailSender 类和 SMSMessageSender 类分别实现了 IMessageSender 接口，提供了不同的消息发送实现。 NotificationService 类表示通知服务，它依赖于 IMessageSender 接口而不是具体的消息发送类。

在构造函数中，通过依赖注入的方式将具体的消息发送类传递给 NotificationService 对象。 NotificationService 类的 sendNotification 方法通过调用 messageSender 对象的 sendMessage 方法来发送通知。

创建了一个 EmailSender 对象和一个 SMSMessageSender 对象，作为具体的消息发送类。然后，分别创建了两个 NotificationService 对象：

• emailNotification
• smsNotification

通过将不同的消息发送类传递给这两个对象的构造函数，实现了依赖倒置，高层模块 NotificationService 不直接依赖于具体的消息发送类，而是依赖于抽象的 IMessageSender 接口。

/**
 * 依赖倒置原则Demo
 */

interface IMessageSender {
  sendMessage: (message: string) => void
}

export class EmailSender implements IMessageSender {
  sendMessage(message: string): void {
    console.log(`Sending email: ${message}`)
  }
}

class SMSMessageSender implements IMessageSender {
  sendMessage(message: string): void {
    console.log(`Sending SMS: ${message}`)
  }
}

class NotificationService {
  private messageSender: IMessageSender

  constructor(messageSender: IMessageSender) {
    this.messageSender = messageSender
  }

  sendNotification(message: string): void {
    this.messageSender.sendMessage(message)
  }
}

// 使用示例
const emailSender = new EmailSender()
const smsSender = new SMSMessageSender()

const emailNotification = new NotificationService(emailSender)
const smsNotification = new NotificationService(smsSender)

emailNotification.sendNotification('Hello,  email notification.')
smsNotification.sendNotification('Hello, SMS notification.')

依赖倒置原则的核心思想是通过抽象来解耦模块之间的依赖关系。高层模块不应该直接依赖于低层模块的实现细节，而是依赖于抽象。 这样可以提高系统的灵活性和可维护性，使得模块之间更加松耦合。

依赖倒置原则鼓励使用接口或抽象类来定义模块之间的通信协议，而不是依赖于具体实现类。这样可以轻松替换底层的具体实现，而不影响高层模块的代码。