Acoplamiento

En la Programación Orientada a Objetos, escribir buen código no solo implica que funcione correctamente, sino también que sea mantenible, reutilizable y escalable. Para lograrlo, es fundamental aplicar principios sólidos de diseño. Dos de los conceptos más importantes en este sentido son el acoplamiento y la cohesión. Ambos influyen directamente en la calidad y estructura del software.

¿Qué es el acoplamiento?

El acoplamiento se refiere al grado de dependencia entre dos módulos o clases dentro de un sistema. En otras palabras, mide cuán conectados están dos componentes del software y cuánto sabe uno sobre el otro.

Tipos de acoplamiento:

• Acoplamiento fuerte (alto): Un módulo depende directamente de los detalles internos de otro. Cualquier cambio en uno puede requerir modificar el otro. Esto hace que el mantenimiento sea complejo y el código menos reutilizable.

• Acoplamiento débil (bajo): Los módulos son independientes entre sí. Solo interactúan a través de interfaces bien definidas, lo que facilita su reutilización, prueba y mantenimiento.

El objetivo en diseño orientado a objetos es lograr acoplamiento bajo, ya que esto nos permite construir sistemas más flexibles, modulares y resistentes a cambios inesperados.

¿Por qué evitar el acoplamiento fuerte?

• Mayor fragilidad: Un pequeño cambio en un módulo puede generar errores en otro que depende de él, aún si no se modificó directamente.
• Menor reutilización: Si una clase depende de otras para funcionar, no se puede reutilizar fácilmente en diferentes contextos.
• Difícil mantenimiento: Cambiar una parte del sistema puede requerir modificaciones en múltiples módulos.

Ejemplo de acoplamiento fuerte en Python:

# Clase fuertemente acoplada
class Clase1:
    x = 10

class Clase2:
    def mi_metodo(self):
        return Clase1.x * 2  # Depende directamente del atributo de otra clase

En este ejemplo, Clase2 depende directamente de la implementación interna de Clase1. Si el atributo x cambia de nombre, tipo o desaparece, Clase2 dejará de funcionar correctamente.

Mejora: diseño con acoplamiento débil

# Diseño con acoplamiento débil
class Clase1:
    def __init__(self, x):
        self.x = x

    def obtener_valor(self):
        return self.x

class Clase2:
    def __init__(self, clase1):
        self.clase1 = clase1

    def mi_metodo(self):
        return self.clase1.obtener_valor() * 2

Aquí, Clase2 depende solo de la interfaz pública de Clase1 (obtener_valor()), lo cual reduce el acoplamiento y permite que ambas clases evolucionen de manera más independiente.