Merida Design Blog

Publicado el | Artículos / , ,

S.O.L.I.D. Principios de la programación orientada a objetos: Responsabilidad única

El término S.O.L.I.D. fué creado por Robert C. Martin en su libro que lleva el mismo nombre y es usado para referirse a los 5 primeros principios de la programación orientada a objetos (POO).

S.O.L.I.D. proviene de las siguientes siglas en inglés:

  • S – Single Responsibility Principle: Principio de la Responsabilidad Única
  • O – Open/Closed Principle: Principio de Abierto/Cerrado
  • L – Liskov Substitution Principle: Principio de la Sustitución Liskov
  • I – Interface Segregation Principle: Princpio de la Segregación de Interfaz
  • D – Dependency Inversion Principle: Principio de la Inversión de Dependencia

Estos términos parecen complicados pero en realidad son fáciles de entender, como veremos a lo largo de esta serie de artículos.

Usando estos principios en conjunto, es posible crear aplicaciones que son fáciles de mantener, extender, testear e incluso re-factorizar (algo que suelo hacer mucho).


Principio de la responsabilidad única (SRP)

Establece que cada clase debe tener solamente una razón de cambio, es decir, un único trabajo a realizar.

Para aclarar esta idea un poco más, veamos como se traduce esto en código real, para lo cual elaborarémos un ejemplo sencillo con algunos objetos de tipo formas de los cuales queremos obtener la sumatoria de sus áreas.

Primero creamos las clases de las formas definiendo sus constructores con los parámetros correspondientes y a continuación.

    class Circle {
		    public $radius;
		
		    public function __construct($radius) {
			    $this->radius = $radius;
		    }
	  }
	
	  class Square {
		    public $length;
		
		    public function __construct($length) {
			    $this->length = $length;
		    }
	   }

Ahora creamos la clase AreaCalculator que nos servirá para realizar el cálculo de la sumatoria de las áreas.

    class AreaCalculator {
      protected $shapes;

      public function __construct($shapes = array()) {
        $this->shapes = $shapes;
      }

      public function sum() {
        // lógica para sumar las áreas
      }

      public function output() {
        return implode('', array(
            "<h1>",
                "Suma de las areas de todas las figuras ingresadas:",
                $this->sum(),
            "</h1>"
        ));
      }
    }

Para usar la clase, solamente necesitamos instanciarla y pasarle un arreglo con objetos de tipo Square o Circle, después de eso, llamamos al método output para imprimir el resultado de la sumatoria.

    $shapes = array(
        new Circle(2),
        new Square(5),
        new Square(6)
    );

    $areas = new AreaCalculator($shapes);

    echo $areas->output();

Si nos fijamos en la clase AreaCalculator podremos ver que no cumple con el principio SRP, ya que actualmente la clase se está haciendo cargo de 2 tareas, el cálculo de la sumatoria y la impresión del resultado.

Para resolver éste problema, podemos crear una clase que se encargue de realizar la impresión del
resultado, de esta forma ambas clases ahora tendrán una única responsabilidad.

La clase a la cual llamaremos SumCalculatorOutputter funcionaría de la siguiente forma:

    $sapes = array(
        new Circle(2),
        new Square(5),
        new Square(6)
    );

    $areas = new AreaCalculator($shapes);
    $output = new SumCalculatorOutputter($areas);

    echo $output->JSON();
    echo $output->HAML();
    echo $output->HTML();
    echo $output->JADE();

 

Conclusión

Como podemos ver, ahora cada clase tiene su propio propósito o tarea, cumpliendo así el principio de la única responsabilidad y dándonos una mayor flexibilidad extender los módulos.

En el siguiente artículo hablaremos sobre el Principio de Abierto/Cerrado.



Publicaciones que pueden interesarte

    Deja un comentario

      tope
    Derechos Reservados, Merida Design 2017
    %d bloggers like this: