Programación Orientada a Objetos: Principios de Diseño SOLID

Tiempo de lectura: 2 minutos

Los principios SOLID son un conjunto de cinco principios de diseño de software que promueven la creación de código limpio, mantenible y escalable.

Estos principios fueron introducidos por Robert C. Martin en su libro «Agile Software Development, Principles, Patterns, and Practices» y son fundamentales para la ingeniería de software orientada a objetos:

• Single Responsibility Principle (SRP – Principio de Responsabilidad Única): Este principio establece que una clase debe tener una sola razón para cambiar. En otras palabras, una clase debe tener una única responsabilidad dentro del sistema. Esto ayuda a mantener el código modular y facilita su mantenimiento y reutilización.
• Open/Closed Principle (OCP – Principio Abierto/Cerrado): Este principio establece que las entidades de software (clases, módulos, funciones, etc.) deben estar abiertas para su extensión pero cerradas para su modificación. En lugar de modificar el código existente, se debe extender su funcionalidad a través de la herencia, interfaces u otras técnicas de extensión.
• Liskov Substitution Principle (LSP – Principio de Sustitución de Liskov): Este principio establece que los objetos de una clase base deben poder ser sustituidos por objetos de sus subclases sin afectar la integridad del programa. En otras palabras, las subclases deben ser sustituibles por sus clases base sin cambiar el comportamiento esperado del programa.
• Interface Segregation Principle (ISP – Principio de Segregación de Interfaces): Este principio establece que una clase no debe verse obligada a depender de métodos que no utiliza. En lugar de tener una única interfaz grande, es preferible tener varias interfaces más específicas y cohesivas. Esto evita que las clases dependan de funcionalidades que no necesitan.
• Dependency Inversion Principle (DIP – Principio de Inversión de Dependencias): Este principio establece que las clases de alto nivel no deben depender de clases de bajo nivel, sino de abstracciones. Las abstracciones deben depender de otras abstracciones, no de detalles concretos. Esto promueve la flexibilidad y el desacoplamiento en el diseño del software. Ejemplo en Java aplicando el principio SRP:

   // Clase que viola el principio SRP al tener múltiples responsabilidades
   public class GestorEmpleados {
       public void calcularSalario(Empleado empleado) {
           // Cálculo del salario
       }

       public void guardarEmpleado(Empleado empleado) {
           // Guardar empleado en la base de datos
       }

       public void generarReporte(Empleado empleado) {
           // Generar reporte del empleado
       }
   }

   // Aplicación del principio SRP dividiendo las responsabilidades en clases separadas
   public class CalculadoraSalario {
       public void calcularSalario(Empleado empleado) {
           // Cálculo del salario
       }
   }

   public class RepositorioEmpleados {
       public void guardarEmpleado(Empleado empleado) {
           // Guardar empleado en la base de datos
       }
   }

   public class GeneradorReportes {
       public void generarReporte(Empleado empleado) {
           // Generar reporte del empleado
       }
   }

Los principios SOLID proporcionan pautas claras para el diseño de software que favorecen la creación de sistemas más robustos, flexibles y fáciles de mantener a lo largo del tiempo. Es esencial comprender y aplicar estos principios en el desarrollo de software orientado a objetos para mejorar la calidad y la eficiencia del código.