SOLID est l'acronyme d'un groupe de cinq bons principes (règles) en programmation informatique. SOLID permet aux programmeurs d'écrire du code plus facile à comprendre et à modifier ultérieurement. SOLID est souvent utilisé avec des systèmes qui utilisent une conception orientée objet.
Expliquons les principes SOLID à l'aide de l'exemple du véhicule. Imaginez que nous concevons un système pour gérer différents types de véhicules, comme les voitures et les voitures électriques, pour un service de transport.

S - Principe de responsabilité unique (SRP)

Exemple de véhicule : Imaginez que vous avez une voiture. Il est responsable de la conduite, mais il ne devrait pas être responsable de son propre entretien (comme les vidanges d'huile ou la permutation des pneus). Au lieu de cela, un mécanicien distinct en est responsable.
Explication : Dans notre code, la classe Vehicle ne doit gérer que les éléments liés au véhicule lui-même, comme stocker sa marque et son modèle. Si nous devons gérer la maintenance, nous créons une classe Maintenance distincte pour cela. De cette façon, chaque classe a une tâche ou une responsabilité, ce qui rend le code plus facile à gérer.

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 - Principe ouvert/fermé (OCP)

Exemple de véhicule : Supposons que vous ayez une voiture de base et que vous souhaitiez maintenant ajouter une voiture électrique à votre système. Vous ne devriez pas avoir à modifier la classe de voiture existante pour ajouter des fonctionnalités pour les voitures électriques. Au lieu de cela, vous pouvez étendre les fonctionnalités existantes en créant une nouvelle classe pour les voitures électriques.
Explication : La classe Vehicle est ouverte à l'extension (vous pouvez créer de nouveaux types de véhicules comme ElectricVehicle), mais elle est fermée à la modification (vous n'avez pas besoin de modifier la classe Vehicle elle-même pour ajouter de nouveaux types).

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

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

class ElectricVehicle 





  
  
  Principe de substitution L - Liskov (LSP)


Exemple de véhicule : Imaginez que vous disposez d'une flotte de véhicules et que vous pouvez remplacer n'importe quelle voiture ordinaire par une voiture électrique sans aucun problème. Les deux devraient être capables de remplir leur fonction de base - conduire - sans casser le système.
Explication : Toute sous-classe (comme ElectricVehicle) devrait pouvoir remplacer sa classe parent (Vehicle) sans altérer le comportement du programme. Cela garantit que notre code peut gérer différents types de véhicules de la même manière.


Véhicule de classe 
class Vehicle
  def initialize(make, model)
    @make = make
    @model = model
  end

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

class ElectricVehicle 





  
  
  I - Principe de ségrégation d'interface (ISP)


Exemple de véhicule : Imaginez que vous ayez différents types de véhicules : certains peuvent être rechargés (comme les voitures électriques) et d'autres ne peuvent être conduits (comme les voitures à essence). Vous ne voulez pas qu'une voiture à essence soit confrontée à des méthodes liées à la recharge.
Explication : les classes ne doivent implémenter que les interfaces (ou comportements) dont elles ont besoin. Par exemple, un véhicule électrique peut implémenter à la fois des interfaces pilotables et facturables, tandis qu'un véhicule ordinaire n'implémente que pilotable.


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 - Principe d'inversion de dépendance (DIP)


Exemple de véhicule : imaginez qu'une voiture puisse avoir différents types de moteurs : un moteur à essence ou un moteur électrique. Au lieu de dépendre directement d'un type de moteur spécifique, la voiture devrait dépendre d'une interface moteur plus générale afin de pouvoir utiliser n'importe quel type de moteur.
Explication : les modules de haut niveau (comme le véhicule) ne doivent pas dépendre de modules de bas niveau (comme GasEngine ou ElectricEngine). Les deux devraient dépendre d’abstractions (comme une interface Engine). Cela rend le système plus flexible et plus facile à modifier.


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

class GasEngine 



En suivant les principes SOLID dans cet exemple de véhicule, nous pouvons créer un système facile à entretenir, à étendre et à adapter aux nouvelles exigences.

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