Principes SOLID utilisant des analogies amusantes avec l'exemple de véhicule

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 un travail 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 changer 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 < Vehicle
  def initialize(make, model, battery_range)
    super(make, model)
    @battery_range = battery_range
  end

  def description
    "#{super} with #{@battery_range} miles battery range"
  end
end

---

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.

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

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

class ElectricVehicle < Vehicle
  def drive
    puts "Driving the electric #{@make} #{@model} quietly"
  end
end

def test_drive(vehicle)
  vehicle.drive
end

car = Vehicle.new("Toyota", "Corolla")
ev = ElectricVehicle.new("Tesla", "Model 3")

test_drive(car)  # Driving the Toyota Corolla
test_drive(ev)   # Driving the electric Tesla Model 3 quietly

---

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 chargé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 < Vehicle
  include Chargeable

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

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

  def charge
    puts "Charging the #{@make} #{@model}"
  end
end

---

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.

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

class GasEngine < Engine
  def start
    puts "Starting gas engine"
  end
end

class ElectricEngine < Engine
  def start
    puts "Starting electric engine"
  end
end

class Vehicle
  def initialize(engine)
    @engine = engine
  end

  def start
    @engine.start
  end
end

gas_engine = GasEngine.new
electric_engine = ElectricEngine.new

gas_car = Vehicle.new(gas_engine)
electric_car = Vehicle.new(electric_engine)

gas_car.start        # Starting gas engine
electric_car.start   # Starting electric engine

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

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!