Closed Principle)#

Definición#

El Principio de Abierto/Cerrado (OCP) establece que: “Las clases deben estar abiertas a la extensión pero cerradas a la modificación”.

Esto significa que:

Una clase puede ser extendida para añadir nuevas funcionalidades.
Pero su código existente no debe modificarse al hacerlo.

Motivación#

Evita romper el código probado cuando se añaden nuevas funciones.
Favorece la extensibilidad mediante herencia o interfaces.
Se aplica frecuentemente con patrones como Strategy o Factory.

Ejemplo conceptual#

Clase Pedido que calcula costos de envío:

Antes (violando OCP): cada nuevo método de envío requiere modificar la clase Pedido.
Después (aplicando OCP): se extrae la lógica de envío en una interfaz común Envio, y se crean clases concretas (EnvioExpress, EnvioEstandar, etc.).

Diagrama (Mermaid)#

1
classDiagram
2
    class Pedido {
3
        - Envio envio
4
        + calcularCosto()
5
    }
6

7
    class Envio {
8
        <<interface>>
9
        + calcularCosto()
10
    }
11

12
    class EnvioEstandar {
13
        + calcularCosto()
14
    }
15

16
    class EnvioExpress {
17
        + calcularCosto()
18
    }
19

20
    Pedido --> Envio
21
    Envio <|.. EnvioEstandar
22
    Envio <|.. EnvioExpress

Ejemplo en Spring Boot (Java, IntelliJ IDEA)#

Antes (violando OCP)#

1
public class Pedido {
2
    public double calcularEnvio(String tipo) {
3
        if ("ESTANDAR".equals(tipo)) {
4
            return 50.0;
5
        } else if ("EXPRESS".equals(tipo)) {
6
            return 100.0;
7
        }
8
        return 0.0;
9
    }
10
}

Problema: cada vez que agregamos un nuevo método de envío, hay que modificar Pedido.

Después (aplicando OCP con Strategy)#

1
public interface Envio {
2
    double calcularCosto();
3
}
4

5
public class EnvioEstandar implements Envio {
6
    public double calcularCosto() {
7
        return 50.0;
8
    }
9
}
10

11
public class EnvioExpress implements Envio {
12
    public double calcularCosto() {
13
        return 100.0;
14
    }
15
}
16

17
public class Pedido {
18
    private final Envio envio;
19

20
    public Pedido(Envio envio) {
21
        this.envio = envio;
22
    }
23

24
    public double calcularEnvio() {
25
        return envio.calcularCosto();
26
    }
27
}

Ahora, agregar un nuevo tipo de envío significa crear una nueva clase, sin tocar Pedido.

Ejemplo en Django (Python, PyCharm)#

Antes (violando OCP)#

1
class Pedido:
2
    def calcular_envio(self, tipo):
3
        if tipo == "ESTANDAR":
4
            return 50.0
5
        elif tipo == "EXPRESS":
6
            return 100.0
7
        return 0.0

Cada nuevo tipo de envío requiere modificar Pedido.

Después (aplicando OCP con Strategy)#

1
from abc import ABC, abstractmethod
2

3
class Envio(ABC):
4
    @abstractmethod
5
    def calcular_costo(self):
6
        pass
7

8
class EnvioEstandar(Envio):
9
    def calcular_costo(self):
10
        return 50.0
11

12
class EnvioExpress(Envio):
13
    def calcular_costo(self):
14
        return 100.0
15

16
class Pedido:
17
    def __init__(self, envio: Envio):
18
        self.envio = envio
19

20
    def calcular_envio(self):
21
        return self.envio.calcular_costo()

Ahora basta con crear una nueva clase de envío (EnvioMaritimo, EnvioInternacional, etc.) sin tocar Pedido.

Conclusión#

El Principio de Abierto/Cerrado (OCP) permite:

Extender funcionalidades sin modificar código probado.
Reducir riesgos de errores en el sistema.
Diseñar software más flexible y mantenible.