Principio Abierto-Cerrado en Desarrollo de Software

Clase 5 de 27 • Curso de Patrones de Diseño y SOLID en Python

Resumen

El principio abierto-cerrado (Open-Closed Principle) es clave para mantener la flexibilidad y estabilidad en el desarrollo de software, permitiendo que el código sea ampliado sin ser modificado. Este principio garantiza que el software pueda evolucionar de manera eficiente sin afectar las funcionalidades ya probadas, lo que es fundamental en un entorno de cambio constante como el de las empresas tecnológicas.

¿Qué es el principio abierto-cerrado?

El principio abierto-cerrado establece que el software debe estar abierto para su extensión pero cerrado para su modificación. Esto significa que es posible añadir nuevas funcionalidades sin alterar el código existente, lo que ayuda a evitar errores y mantiene la estabilidad del sistema.

¿Cómo se aplica en el desarrollo de software?

Extensión sin modificación: se agregan nuevas características utilizando mecanismos como interfaces, abstracciones o polimorfismos. En lenguajes como Python, estas herramientas son parte del propio lenguaje y permiten ampliar comportamientos sin alterar la base de código original.
Cerrado para modificación: protege el código validado, encapsulando las funcionalidades y asegurando que las nuevas extensiones no rompan lo que ya está en uso.

¿Cuáles son los beneficios de aplicarlo?

Menos errores: al no tocar el código existente, se minimizan los errores derivados de cambios imprevistos.
Actualizaciones más rápidas: la extensión del software se vuelve más ágil, lo que es crucial cuando hay cambios constantes de requisitos en las empresas.
Estabilidad del sistema: el código probado y validado permanece inalterado, lo que facilita el desarrollo de nuevas funcionalidades sin riesgos.

¿Cuándo deberías aplicar el principio abierto-cerrado?

Este principio es útil cuando necesitas añadir nuevas funcionalidades sin afectar el código existente. Un ejemplo común es la integración de una nueva pasarela de pagos en un sistema ya funcional o agregar un método de notificación sin cambiar las implementaciones actuales. También es recomendable en contextos donde los requisitos del sistema cambian frecuentemente, como en la construcción de plataformas de pago o servicios con muchas interacciones externas.

¿Cómo puedes aplicarlo en tu día a día?

Reflexiona sobre cómo usarías este principio al agregar nuevas pasarelas de pago al sistema que estás desarrollando. Piensa también en qué momentos, durante tu experiencia, has extendido funcionalidades sin modificar la base de código. Este enfoque te permitirá adaptarte rápidamente a las necesidades cambiantes de la empresa mientras mantienes la estabilidad.

Jovanny Delgado

student•

El Principio Abierto/Cerrado (Open-Closed Principle, OCP) es un pilar fundamental en la programación orientada a objetos. Establece que las entidades de software (clases, módulos, funciones) deben estar abiertas a la extensión, pero cerradas a la modificación. Es decir, debemos poder agregar nuevas funcionalidades sin alterar el código existente.

¿Por qué es importante el OCP en Python?

Mayor mantenibilidad: Al evitar modificar código existente, reducimos el riesgo de introducir nuevos errores.
Mayor flexibilidad: Permite agregar nuevas funcionalidades sin afectar el comportamiento de las partes existentes del sistema.
Fomenta la reutilización: Las clases diseñadas siguiendo el OCP son más fáciles de reutilizar en diferentes contextos.

Cómo aplicar el OCP en Python

1. Abstracción:

Identificar las áreas de cambio: Determina qué partes de tu código son más propensas a cambiar en el futuro.
Crear abstracciones: Utiliza clases abstractas, interfaces o clases base para definir un contrato que las clases concretas deben cumplir.

2. Extensión:

Heredar de las abstracciones: Crea nuevas clases que hereden de las abstracciones y proporcionen implementaciones concretas.
Utilizar polimorfismo: Permite que diferentes objetos respondan de manera diferente al mismo mensaje.

Ejemplo: Sistema de pagos

Python

from abc import ABC, abstractmethod class Pagador(ABC): @abstractmethod def pagar(self, monto): pass class PayPal(Pagador): def pagar(self, monto): print(f"Pagando {monto} dólares a través de PayPal") class TarjetaCredito(Pagador): def pagar(self, monto): print(f"Pagando {monto} dólares con tarjeta de crédito") # Cliente def procesar_pago(pagador, monto): pagador.pagar(monto) # Uso paypal = PayPal() tarjeta = TarjetaCredito() procesar_pago(paypal, 100) procesar_pago(tarjeta, 50)

En este ejemplo:

Pagador es una clase abstracta que define el contrato para todos los pagadores.
PayPal y TarjetaCredito heredan de Pagador y proporcionan implementaciones específicas.
La función procesar_pago es polimórfica, ya que puede trabajar con cualquier objeto que implemente la interfaz Pagador.

3. Herramientas de Python para el OCP:

Clases abstractas: Definidas con ABC y abstractmethod.
Interfaces: Aunque Python no tiene interfaces explícitas, se pueden simular usando clases abstractas con solo métodos abstractos.
Herencia: Permite crear nuevas clases a partir de clases existentes.
Polimorfismo: Permite que objetos de diferentes clases respondan de manera diferente al mismo mensaje.

Otros principios SOLID relacionados con el OCP:

Principio de Sustitución de Liskov (LSP): Los objetos de una superclase deben poder ser reemplazados por objetos de sus subclases sin alterar la corrección del programa.
Principio de Segregación de Interfaces (ISP): Muchas interfaces específicas son mejores que una única interfaz de propósito general.

Conclusiones

El principio OCP es una herramienta poderosa para crear software más flexible, mantenible y extensible. Al aplicarlo en Python, podemos construir sistemas que sean más fáciles de adaptar a los cambios futuros y que sean más robustos ante la evolución de los requisitos.

Juan Andres Bravo Freitez

student•

muy buen aporte

Mario Alexander Vargas Celis

student•

El **Principio Abierto/Cerrado** (Open/Closed Principle, OCP) establece que **una clase debe estar abierta para su extensión, pero cerrada para su modificación**. Esto significa que deberíamos poder agregar nuevas funcionalidades a una clase sin cambiar su código existente, lo cual es esencial para preservar la estabilidad del software y minimizar los errores.

Una forma común de aplicar el OCP en Python es utilizando la **herencia** o la **composición** para extender el comportamiento de las clases sin modificar su código base.

### Ejemplo de una Clase que Viola el OCP

Imaginemos una clase que calcula el descuento para una tienda en línea. La clase DiscountCalculator contiene lógica para aplicar distintos tipos de descuentos. Sin embargo, si necesitamos agregar un nuevo tipo de descuento, tendríamos que modificar la clase, violando así el principio OCP.


class DiscountCalculator:

&#x20;   def calculate(self, price, discount\_type):

&#x20;       if discount\_type == "percentage":

&#x20;           return price \* 0.90  # 10% de descuento

&#x20;       elif discount\_type == "fixed":

&#x20;           return price - 20  # Descuento fijo de $20

&#x20;       else:

&#x20;           return price

Si se agrega un nuevo tipo de descuento, como un descuento para clientes frecuentes, sería necesario modificar el método calculate, lo que va en contra del principio OCP.

### Solución: Aplicando OCP

Para aplicar el OCP, separamos cada tipo de descuento en clases independientes, que pueden extenderse sin necesidad de modificar la lógica existente. Utilizaremos **polimorfismo** mediante una clase base abstracta DiscountStrategy.


from abc import ABC, abstractmethod



class DiscountStrategy(ABC):

&#x20;   @abstractmethod

&#x20;   def apply\_discount(self, price):

&#x20;       pass



class PercentageDiscount(DiscountStrategy):

&#x20;   def apply\_discount(self, price):

&#x20;       return price \* 0.90  # 10% de descuento



class FixedDiscount(DiscountStrategy):

&#x20;   def apply\_discount(self, price):

&#x20;       return price - 20  # Descuento fijo de $20



class NoDiscount(DiscountStrategy):

&#x20;   def apply\_discount(self, price):

&#x20;       return price  # Sin descuento



class DiscountCalculator:

&#x20;   def \_\_init\_\_(self, strategy: DiscountStrategy):

&#x20;       self.strategy = strategy



&#x20;   def calculate(self, price):

&#x20;       return self.strategy.apply\_discount(price)

### Explicación

- **Clase DiscountStrategy**: Es una clase abstracta que define el método apply\_discount, el cual debe ser implementado por cada tipo de descuento.

- **Clases PercentageDiscount, FixedDiscount y NoDiscount**: Cada una implementa una estrategia de descuento específica. Puedes agregar nuevas estrategias sin modificar las clases existentes.

- **Clase DiscountCalculator**: Su método calculate utiliza una instancia de DiscountStrategy para aplicar el descuento. Esta clase no necesita ser modificada al agregar un nuevo tipo de descuento.

### Uso del Código

Podemos usar DiscountCalculator con distintas estrategias de descuento de forma flexible:


\# Crear instancias de estrategias de descuento

percentage\_discount = PercentageDiscount()

fixed\_discount = FixedDiscount()

no\_discount = NoDiscount()



\# Aplicar descuentos

calculator = DiscountCalculator(percentage\_discount)

print(f"Precio con descuento del 10%: ${calculator.calculate(100)}")



calculator.strategy = fixed\_discount

print(f"Precio con descuento fijo de $20: ${calculator.calculate(100)}")



calculator.strategy = no\_discount

print(f"Precio sin descuento: ${calculator.calculate(100)}")

### Ventajas de Aplicar el Principio OCP

1. **Extensibilidad**: Puedes agregar nuevos tipos de descuento sin modificar las clases existentes.

2. **Mantenibilidad**: Al no modificar el código base, reduces el riesgo de introducir errores en el código existente.

3. **Flexibilidad**: Puedes intercambiar estrategias de descuento dinámicamente, haciendo el sistema más adaptable.

### Conclusión

Aplicar el Principio Abierto/Cerrado permite que el sistema sea extensible y flexible. Este enfoque de diseño reduce la posibilidad de errores al minimizar los cambios en el código existente y fomenta la reutilización de componentes a través del polimorfismo.

JHONATAN DAVID RESTREPO HENAO

student•

🧠 Preguntas clave para saber si necesitas OCP

¿Necesito modificar una clase o función cada vez que agrego una nueva funcionalidad? (Si es así, aplica OCP).
¿Puedo extender la funcionalidad agregando una nueva clase en lugar de modificar una existente?
¿Hay muchos if/else o switch/case que podrían convertirse en clases separadas?
¿Cada vez que hay un cambio en las reglas de negocio, tengo que modificar el código existente?

Pablo Torres Pérez

student•

Alguna vez usé este principio para crear un filtro con el patrón de filtrado por encadenamiento. Así permitía agregar nuevos filtros sin modificar los que ya existen. Yo lo utilicé para filtrar contratos, pero también puede ser aplicado a un listado de productos. Se puede crear una clase Filter que sirva como interfaz. Luego crear clases para cada tipo de filtro. Ejemplo: class PrecioFilter(Filter): class ColorFilter(Filter): class TipoFilter(Filter): . y otra clase para encadenar los filtros existentes.

Joel Gabriel Germán Valdez

student•

Un ejemplo en aplicar este principio en el ejercicio propuesto, seria agregar otra pasarela de pago como PayPal, Authorize etc, es decir haciendo otra clase mas con sus respectivos metodos y configuraciones y simplemente agregandola como otra opcion al PaymentServices

César Ernesto Rivas Martínez

student•

en el Notificator, para tener 1 por cada tipo de notificacion que querramos enviar, para no tener que modificar la que ya tenemos
en el Logger, por si ocupamos diferentes formas de logear errores