Ctrl+K

Dependency Inversion Principle

Open In Colab

2.5. Dependency Inversion Principle#

El Principio de Inversión de Dependencias (Dependency Inversion Principle - DIP) es uno de los cinco principios SOLID del diseño de software. Fue propuesto por Robert C. Martin como una forma de reducir el acoplamiento entre módulos de software y promover el diseño de sistemas más flexibles y extensibles. El DIP establece que las clases de alto nivel no deben depender de las clases de bajo nivel, sino de abstracciones. Las abstracciones no deben depender de detalles concretos; los detalles concretos deben depender de abstracciones.

2.5.1. Definición del DIP:#

El principio DIP establece dos reglas fundamentales:

  1. Los módulos de alto nivel no deben depender de los módulos de bajo nivel. Ambos deben depender de abstracciones.

  2. Las abstracciones no deben depender de detalles concretos. Los detalles concretos deben depender de abstracciones.

En resumen, este principio promueve el desacoplamiento entre los componentes de un sistema, lo que facilita la modificación y extensión del software.

2.5.2. Ejemplo del DIP:#

Supongamos que tenemos un sistema de gestión de empleados que proporciona una funcionalidad para calcular los salarios de los empleados. Utilizaremos el principio DIP para desacoplar el cálculo del salario de la clase Employee utilizando una interfaz SalaryCalculator.

from abc import ABC, abstractmethod

# Interfaz para el cálculo del salario
class SalaryCalculator(ABC):
    @abstractmethod
    def calculate_salary(self, employee):
        pass

# Implementación concreta del cálculo del salario
class BasicSalaryCalculator(SalaryCalculator):
    def calculate_salary(self, employee):
        # Cálculo básico del salario
        return employee.salary

# Clase de alto nivel que depende de la abstracción
class PayrollSystem:
    def __init__(self, salary_calculator):
        self.salary_calculator = salary_calculator

    def calculate_payroll(self, employee):
        return self.salary_calculator.calculate_salary(employee)

# Clase de bajo nivel
class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

# Uso del principio DIP

basic_salary_calculator = BasicSalaryCalculator()
payroll_system = PayrollSystem(basic_salary_calculator)

employee = Employee("John", 5000)
print("Salary for", employee.name, "is", payroll_system.calculate_payroll(employee))

Salary for John is 5000

En este ejemplo, PayrollSystem es una clase de alto nivel que calcula el salario de los empleados utilizando un objeto que implementa la interfaz SalaryCalculator. Esto sigue el principio DIP, ya que PayrollSystem no depende de la implementación concreta del cálculo del salario, sino de una abstracción (SalaryCalculator). Esto facilita la extensión del sistema, ya que es fácil agregar nuevas implementaciones de SalaryCalculator sin modificar PayrollSystem.

Contents