Principio abierto/cerrado

El principio abierto/cerrado es un principio de diseño orientado a objetos que fue propuesto por Bertrand Meyer en 1988. Este principio establece que una entidad de software, como una clase o un módulo, debe estar abierta para la extensión, pero cerrada para la modificación. En otras palabras, el comportamiento de una entidad de software puede ser ampliado, pero no modificado.

La idea detrás del principio abierto/cerrado es que si una clase es modificada, esto puede afectar a otras partes del sistema que dependen de ella. En cambio, si se extiende la clase mediante la creación de nuevas clases, se pueden añadir nuevas funcionalidades sin afectar al código existente.

Ventajas del principio abierto/cerrado

Las ventajas del principio abierto/cerrado son varias. En primer lugar, permite una mayor flexibilidad en el diseño del código, ya que se pueden añadir nuevas funcionalidades sin modificar el código existente. En segundo lugar, el principio abierto/cerrado promueve la reutilización del código, ya que se pueden crear nuevas clases que aprovechen el comportamiento de las clases existentes. En tercer lugar, el principio abierto/cerrado ayuda a reducir el acoplamiento en el código, ya que las clases no están fuertemente acopladas entre sí.

Desventajas del principio abierto/cerrado

A pesar de sus ventajas, el principio abierto/cerrado también tiene algunas desventajas. En primer lugar, puede ser más complicado de implementar que simplemente modificar las clases existentes. En segundo lugar, puede llevar a una mayor complejidad en el código si se crean demasiadas clases nuevas. En tercer lugar, si se utilizan mal las técnicas de extensión, puede llevar a problemas de mantenimiento y rendimiento del código.

Ejemplo en código C#

Supongamos que tenemos una clase llamada Figura que representa una figura geométrica. Esta clase tiene un método llamado Area() que devuelve el área de la figura.

public class Figura
{
    public virtual double Area()
    {
        // Cálculo del área de la figura
    }
}

Ahora, supongamos que queremos añadir una nueva funcionalidad para calcular el perímetro de la figura. Una forma de hacerlo sería modificando la clase Figura, añadiendo un nuevo método llamado Perimetro().

public class Figura
{
    public virtual double Area()
    {
        // Cálculo del área de la figura
    }

    public virtual double Perimetro()
    {
        // Cálculo del perímetro de la figura
    }
}

Si bien esto nos permite calcular el perímetro de la figura, también estamos modificando la clase Figura, lo que puede afectar otras partes del código que dependen de ella.

Para aplicar el principio abierto/cerrado, podemos crear una interfaz llamada `IFigura` que define los métodos Area() y Perimetro(). Luego, hacemos que la clase Figura implemente esta interfaz.

public interface IFigura
{
    double Area();
    double Perimetro();
}

public class Figura : IFigura
{
    public virtual double Area()
    {
        // Cálculo del área de la figura
    }

    public virtual double Perimetro()
    {
        // Cálculo del perímetro de la figura
    }
}

Ahora, si queremos añadir una nueva funcionalidad para calcular el volumen de una figura tridimensional, podemos crear una nueva clase llamada Figura3D que implemente la interfaz IFigura.

public class Figura3D : IFigura
{
    public virtual double Area()
    {
        // Cálculo del área de la figura tridimensional
    }

    public virtual double Perimetro()
    {
        // Cálculo del perímetro de la figura tridimensional
    }

    public virtual double Volumen()
    {
        // Cálculo del volumen de la figura tridimensional
    }
}

De esta forma, estamos extendiendo el comportamiento de las figuras sin necesidad de modificar la clase original Figura.

Volver a: Principios SOLID