Prinsip PADAT menggunakan beberapa analogi yang menyeronokkan dengan Contoh Kenderaan

SOLID ialah akronim untuk sekumpulan lima prinsip (peraturan) yang baik dalam pengaturcaraan komputer. SOLID membolehkan pengaturcara menulis kod yang lebih mudah difahami dan diubah kemudian hari. SOLID selalunya digunakan dengan sistem yang menggunakan reka bentuk berorientasikan objek.
Mari kita terangkan prinsip SOLID menggunakan contoh kenderaan. Bayangkan kami sedang mereka bentuk sistem untuk mengurus pelbagai jenis kenderaan, seperti kereta dan kereta elektrik, untuk perkhidmatan pengangkutan.

S - Prinsip Tanggungjawab Tunggal (SRP)

Contoh Kenderaan: Bayangkan anda mempunyai kereta. Ia bertanggungjawab untuk memandu, tetapi ia tidak sepatutnya bertanggungjawab untuk mengendalikan penyelenggaraannya sendiri (seperti penukaran minyak atau putaran tayar). Sebaliknya, mekanik berasingan bertanggungjawab untuk itu.
Penjelasan: Dalam kod kami, kelas Kenderaan hanya perlu mengendalikan perkara yang berkaitan dengan kenderaan itu sendiri, seperti menyimpan buatan dan modelnya. Jika kami perlu menguruskan penyelenggaraan, kami membuat kelas Penyelenggaraan yang berasingan untuk itu. Dengan cara ini, setiap kelas mempunyai satu tugas atau tanggungjawab, menjadikan kod lebih mudah untuk diurus.

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 - Prinsip Terbuka/Tertutup (OCP)

Contoh Kenderaan: Katakan anda mempunyai kereta asas, dan kini anda ingin menambah kereta elektrik pada sistem anda. Anda tidak perlu mengubah suai kelas kereta sedia ada untuk menambah ciri bagi kereta elektrik. Sebaliknya, anda boleh melanjutkan fungsi sedia ada dengan mencipta kelas baharu untuk kereta elektrik.
Penjelasan: Kelas Kenderaan dibuka untuk sambungan (anda boleh mencipta jenis kenderaan baharu seperti ElectricVehicle), tetapi ditutup untuk pengubahsuaian (anda tidak perlu menukar kelas Kenderaan itu sendiri untuk menambah jenis baharu).

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

---

L - Prinsip Penggantian Liskov (LSP)

Contoh Kenderaan: Bayangkan anda mempunyai kumpulan kenderaan, dan anda boleh menggantikan mana-mana kereta biasa dengan kereta elektrik tanpa sebarang masalah. Kedua-duanya sepatutnya dapat melaksanakan fungsi asas mereka - memandu - tanpa melanggar sistem.
Penjelasan: Mana-mana subkelas (seperti ElectricVehicle) sepatutnya boleh menggantikan kelas induknya (Kenderaan) tanpa mengubah tingkah laku program. Ini memastikan kod kami boleh mengendalikan pelbagai jenis kenderaan dengan cara yang sama.

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 - Prinsip Pengasingan Antara Muka (ISP)

Contoh Kenderaan: Bayangkan anda mempunyai pelbagai jenis kenderaan: ada yang boleh dicas (seperti kereta elektrik), dan ada yang hanya boleh dipandu (seperti kereta gas). Anda tidak mahu kereta gas perlu berurusan dengan kaedah yang berkaitan dengan pengecasan.
Penjelasan: Kelas hendaklah hanya melaksanakan antara muka (atau gelagat) yang mereka perlukan. Sebagai contoh, Kenderaan Elektrik mungkin melaksanakan kedua-dua antara muka Boleh Dipandu dan Boleh Dicaj, manakala Kenderaan biasa hanya melaksanakan Boleh Dipandu.

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 - Prinsip Penyongsangan Kebergantungan (DIP)

Contoh Kenderaan: Bayangkan sebuah kereta boleh mempunyai pelbagai jenis enjin: enjin gas atau enjin elektrik. Daripada bergantung secara langsung pada jenis enjin tertentu, kereta harus bergantung pada antara muka Enjin yang lebih umum supaya ia boleh menggunakan sebarang jenis enjin.
Penjelasan: Modul peringkat tinggi (seperti Kenderaan) tidak boleh bergantung pada modul peringkat rendah (seperti GasEngine atau ElectricEngine). Kedua-duanya harus bergantung pada abstraksi (seperti antara muka Enjin). Ini menjadikan sistem lebih fleksibel dan lebih mudah diubah.

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

Dengan mengikut prinsip SOLID dalam contoh kenderaan ini, kami boleh membina sistem yang mudah diselenggara, dilanjutkan dan disesuaikan dengan keperluan baharu.

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

Atas ialah kandungan terperinci Prinsip PADAT menggunakan beberapa analogi yang menyeronokkan dengan Contoh Kenderaan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!