依赖倒置原则（DIP）

《紧跟上一篇，大家先看前面的内容》

• 应用场景：高层模块不应该依赖低层模块，二者都应该依赖抽象；抽象不应该依赖细节，细节应该依赖抽象。例如，在一个电商系统中，订单服务（高层模块）不应该直接依赖具体的数据库操作类（低层模块），而是应该依赖一个抽象的数据库接口，这样当数据库类型发生变化时，订单服务不需要修改。
• 示例代码
• Java

// 抽象数据库接口
interface Database {
    void saveData(String data);
}

// 具体数据库实现类：MySQL
class MySQLDatabase implements Database {
    @Override
    public void saveData(String data) {
        System.out.println("Saving data to MySQL: " + data);
    }
}

// 具体数据库实现类：Oracle
class OracleDatabase implements Database {
    @Override
    public void saveData(String data) {
        System.out.println("Saving data to Oracle: " + data);
    }
}

// 高层模块：订单服务
class OrderService {
    private Database database;

    public OrderService(Database database) {
        this.database = database;
    }

    public void saveOrder(String orderData) {
        database.saveData(orderData);
    }
}

public class Main {
    public static void main(String[] args) {
        Database mysqlDB = new MySQLDatabase();
        OrderService orderServiceWithMySQL = new OrderService(mysqlDB);
        orderServiceWithMySQL.saveOrder("Order 1 data");

        Database oracleDB = new OracleDatabase();
        OrderService orderServiceWithOracle = new OrderService(oracleDB);
        orderServiceWithOracle.saveOrder("Order 2 data");
    }
}

- **Python**

from abc import ABC, abstractmethod

# 抽象数据库接口
class Database(ABC):
    @abstractmethod
    def save_data(self, data):
        pass

# 具体数据库实现类：MySQL
class MySQLDatabase(Database):
    def save_data(self, data):
        print(f"Saving data to MySQL: {data}")

# 具体数据库实现类：Oracle
class OracleDatabase(Database):
    def save_data(self, data):
        print(f"Saving data to Oracle: {data}")

# 高层模块：订单服务
class OrderService:
    def __init__(self, database):
        self.database = database

    def save_order(self, order_data):
        self.database.save_data(order_data)


if __name__ == "__main__":
    mysql_db = MySQLDatabase()
    order_service_with_mysql = OrderService(mysql_db)
    order_service_with_mysql.save_order("Order 1 data")

    oracle_db = OracleDatabase()
    order_service_with_oracle = OrderService(oracle_db)
    order_service_with_oracle.save_order("Order 2 data")

- **PHP**

database = $database;
    }

    public function saveOrder($orderData) {
        $this->database->saveData($orderData);
    }
}

$mysqlDB = new MySQLDatabase();
$orderServiceWithMySQL = new OrderService($mysqlDB);
$orderServiceWithMySQL->saveOrder("Order 1 data");

$oracleDB = new OracleDatabase();
$orderServiceWithOracle = new OrderService($oracleDB);
$orderServiceWithOracle->saveOrder("Order 2 data");
?>

- **C#**

using System;

// 抽象数据库接口
interface IDatabase
{
    void SaveData(string data);
}

// 具体数据库实现类：MySQL
class MySQLDatabase : IDatabase
{
    public void SaveData(string data)
    {
        Console.WriteLine("Saving data to MySQL: " + data);
    }
}

// 具体数据库实现类：Oracle
class OracleDatabase : IDatabase
{
    public void SaveData(string data)
    {
        Console.WriteLine("Saving data to Oracle: " + data);
    }
}

// 高层模块：订单服务
class OrderService
{
    private IDatabase database;

    public OrderService(IDatabase database)
    {
        this.database = database;
    }

    public void SaveOrder(string orderData)
    {
        database.SaveData(orderData);
    }
}

class Program
{
    static void Main()
    {
        IDatabase mysqlDB = new MySQLDatabase();
        OrderService orderServiceWithMySQL = new OrderService(mysqlDB);
        orderServiceWithMySQL.SaveOrder("Order 1 data");

        IDatabase oracleDB = new OracleDatabase();
        OrderService orderServiceWithOracle = new OrderService(oracleDB);
        orderServiceWithOracle.SaveOrder("Order 2 data");
    }
}

- **Go**

package main

import "fmt"

// 抽象数据库接口
type Database interface {
    SaveData(data string)
}

// 具体数据库实现类：MySQL
type MySQLDatabase struct{}

func (m MySQLDatabase) SaveData(data string) {
    fmt.Printf("Saving data to MySQL: %s\n", data)
}

// 具体数据库实现类：Oracle
type OracleDatabase struct{}

func (o OracleDatabase) SaveData(data string) {
    fmt.Printf("Saving data to Oracle: %s\n", data)
}

// 高层模块：订单服务
type OrderService struct {
    database Database
}

func NewOrderService(database Database) *OrderService {
    return &OrderService{database: database}
}

func (os *OrderService) SaveOrder(orderData string) {
    os.database.SaveData(orderData)
}

func main() {
    mysqlDB := MySQLDatabase{}
    orderServiceWithMySQL := NewOrderService(mysqlDB)
    orderServiceWithMySQL.SaveOrder("Order 1 data")

    oracleDB := OracleDatabase{}
    orderServiceWithOracle := NewOrderService(oracleDB)
    orderServiceWithOracle.SaveOrder("Order 2 data")
}

- **JavaScript**

// 抽象数据库接口
class Database {
    saveData(data) {
        throw new Error('This method must be implemented!');
    }
}

// 具体数据库实现类：MySQL
class MySQLDatabase extends Database {
    saveData(data) {
        console.log(`Saving data to MySQL: ${data}`);
    }
}

// 具体数据库实现类：Oracle
class OracleDatabase extends Database {
    saveData(data) {
        console.log(`Saving data to Oracle: ${data}`);
    }
}

// 高层模块：订单服务
class OrderService {
    constructor(database) {
        this.database = database;
    }
    saveOrder(orderData) {
        this.database.saveData(orderData);
    }
}

const mysqlDB = new MySQLDatabase();
const orderServiceWithMySQL = new OrderService(mysqlDB);
orderServiceWithMySQL.saveOrder('Order 1 data');

const oracleDB = new OracleDatabase();
const orderServiceWithOracle = new OrderService(oracleDB);
orderServiceWithOracle.saveOrder('Order 2 data');

这些设计模式和设计原则是软件开发中非常重要的基础知识，合理运用它们可以提高代码的可维护性、可扩展性和可复用性。