C++ / El principio open-closed

Bienvenidos sean a este post, hoy veremos uno de los principios de SOLID.

Este principio enuncia que una clase deberia ser abierta para extensiones pero cerrada para modificaciones. Es decir, cuando se necesita una nueva funcionalidad es mejor extender la funcionalidad base en lugar de modificarla. Para entender el concepto, vamos a analizar la clase Producto:

class Producto
{
  // codigo omitido por brevedad
  void set_nombre(std::string);
  std::string get_nombre();
  // resto de los metodos getter y setter
private:
  std::string nombre_;
  double precio_;
  double peso_;
};

En la parte privada tendremos las tres propiedades donde almacenaremos los datos basicos del producto en si y en la parte publica tenemos todos los metodos getter y setter para manipular a las propiedades. Supongamos que despues de diseñada y completada la plataforma, los usuarios nos pasan una sugerencia: la venta de productos digitales. Estos puede ser e-books, peliculas, musica, etc. No habria ningun inconveniente pero que sucede con el peso del producto? Con esto debemos repensar como va a ser el uso de la logica de esta clase, una solucion puede ser la siguiente:

class Producto
{
  // codigo omitido por brevedad
  bool es_digital() const {
    return peso_ == 0.0;
  }
private:
  std::string nombre_;
  double precio_;
  double peso_;
};

En este caso, agregamos una nueva funcion donde verificamos si es digital, donde en caso de ser verdadero procede a asignarle el valor de cero. Sin embargo, con esto hemos contradicho al principio pero como podemos complacerlo? Rediseñamos a la clase Producto, la hacemos abstracta y la usamos de base para todos los tipos de producto. Lo siguiente es crear dos clases que sera para los productos fisicos y digitales, las denominaremos como ProductoFisico y ProductoDigital respectivamente. Y ambas seran heredadas de la clase base denominada Producto. Por lo tanto, ahora en nuestra clase Producto tendremmos estos elementos:

class Producto
{
  // codigo omitido por brevedad
  void set_nombre(std::string);
  std::string get_nombre();
  // resto de los metodos getter y setter
private:
  std::string nombre_;
  double precio_;
};

Tendremos solamente el nombre y el precio para cada producto, porque seran los datos en comun, y los metodos getter y setter para manipularlos. Veamos como puede ser la clase de ProductoFisico:

class ProductoFisico : public Producto
{
  void set_peso(double);
  double get_peso();
private:
  double peso_;
};

Solamente tendremos la propiedad del peso del producto y sus respectivos metodos para manipularlos, con esto comentado veamos como puede ser la otra clase:

class ProductoDigital : public Producto
{
  void set_path(std::string);
  std::string get_path();
private:
  std::string path_;
};

En este caso, en lugar del peso debemos informar la ubicacion o path donde se encuentra el elemento, ya sea para ser descargado o reproducido. El resto es similar porque tambien tiene los metodos para manipular a la propiedad. Este es el enfoque debemos usar para nuestras clases donde en lugar de modificarlas completamente, simplemente la modificamos para que contenga los elementos base y esta pueda ser heredada por otros y a su vez las hijas extiendan la funcionalidad porque ahora si surgen nuevos requerimientos simplemente creamos una nueva clase que extienda la clase base. Esto es a lo que se refiere el principio cuando menciona abierto a extension.

En resumen, hoy hemos visto el principio abierto-cerrado, Open-Closed Principle, que es, para que sirve, y como podemos aplicarlo de la manera correcta. Espero les haya resultado de utilidad sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.