SOLID es un acrónimo de un grupo de cinco buenos principios (reglas) en programación de computadoras. SOLID permite a los programadores escribir código que sea más fácil de entender y cambiar más adelante. SOLID se utiliza a menudo con sistemas que utilizan un diseño orientado a objetos.
Expliquemos los principios SOLID usando el ejemplo del vehículo. Imaginemos que estamos diseñando un sistema para gestionar diferentes tipos de vehículos, como autos y autos eléctricos, para un servicio de transporte.

S - Principio de Responsabilidad Única (SRP)

Ejemplo de vehículo: Imagina que tienes un coche. Es responsable de conducir, pero no debería ser responsable de manejar su propio mantenimiento (como cambios de aceite o rotación de neumáticos). En cambio, un mecánico independiente es responsable de eso.
Explicación: En nuestro código, la clase Vehículo solo debe manejar cosas relacionadas con el vehículo en sí, como almacenar su marca y modelo. Si necesitamos gestionar el mantenimiento, creamos una clase de Mantenimiento separada para eso. De esta manera, cada clase tiene un trabajo o responsabilidad, lo que hace que el código sea más fácil de administrar.

class Vehicle
  def initialize(make, model)
    @make = make
    @model = model
  end
end

class Maintenance
  def initialize(vehicle)
    @vehicle = vehicle
  end

  def perform_maintenance
    puts "Performing maintenance on #{@vehicle.make} #{@vehicle.model}"
  end
end

O - Principio abierto/cerrado (OCP)

Ejemplo de vehículo: Supongamos que tiene un automóvil básico y ahora desea agregar un automóvil eléctrico a su sistema. No debería tener que modificar la clase de automóvil existente para agregar funciones para automóviles eléctricos. En su lugar, puedes ampliar la funcionalidad existente creando una nueva clase para coches eléctricos.
Explicación: La clase de Vehículo está abierta a extensión (puedes crear nuevos tipos de vehículos como ElectricVehicle), pero está cerrada a modificaciones (no necesitas cambiar la clase de Vehículo para agregar nuevos tipos).

class Vehicle
  def initialize(make, model)
    @make = make
    @model = model
  end

  def description
    "#{@make} #{@model}"
  end
end

class ElectricVehicle 





  
  
  L - Principio de sustitución de Liskov (LSP)


Ejemplo de vehículo: Imagina que tienes una flota de vehículos y puedes reemplazar cualquier automóvil normal por un automóvil eléctrico sin ningún problema. Ambos deberían poder realizar su función básica - conducir - sin dañar el sistema.
Explicación: Cualquier subclase (como ElectricVehicle) debería poder reemplazar su clase principal (Vehicle) sin alterar el comportamiento del programa. Esto garantiza que nuestro código pueda manejar diferentes tipos de vehículos de la misma manera.


class Vehicle
  def initialize(make, model)
    @make = make
    @model = model
  end

  def drive
    puts "Driving the #{@make} #{@model}"
  end
end

class ElectricVehicle 





  
  
  I - Principio de segregación de interfaz (ISP)


Ejemplo de vehículo: Imagina que tienes diferentes tipos de vehículos: algunos se pueden cargar (como los coches eléctricos) y otros solo se pueden conducir (como los coches de gasolina). No querrás que un coche de gasolina tenga que lidiar con métodos relacionados con la carga.
Explicación: Las clases solo deben implementar las interfaces (o comportamientos) que necesitan. Por ejemplo, un vehículo eléctrico podría implementar interfaces conducibles y cargables, mientras que un vehículo normal solo implementa conducibles.


module Drivable
  def drive
    raise NotImplementedError, "This #{self.class} cannot drive"
  end
end

module Chargeable
  def charge
    raise NotImplementedError, "This #{self.class} cannot be charged"
  end
end

class Vehicle
  include Drivable

  def initialize(make, model)
    @make = make
    @model = model
  end

  def drive
    puts "Driving the #{@make} #{@model}"
  end
end

class ElectricVehicle 





  
  
  D - Principio de inversión de dependencia (DIP)


Ejemplo de vehículo: Imagine que un automóvil puede tener diferentes tipos de motores: un motor de gasolina o un motor eléctrico. En lugar de depender directamente de un tipo de motor específico, el automóvil debería depender de una interfaz de motor más general para poder usar cualquier tipo de motor.
Explicación: Los módulos de alto nivel (como el Vehículo) no deben depender de módulos de bajo nivel (como GasEngine o ElectricEngine). Ambos deberían depender de abstracciones (como una interfaz de motor). Esto hace que el sistema sea más flexible y más fácil de cambiar.


class Engine
  def start
    raise NotImplementedError, "This #{self.class} cannot start"
  end
end

class GasEngine 



Si seguimos los principios SOLID de este ejemplo de vehículo, podemos construir un sistema que sea fácil de mantener, ampliar y adaptar a nuevos requisitos.

LinkedIn: https://www.linkedin.com/in/anandsoni11/