Prinsip SOLID - Diterangkan Menggunakan Contoh Dunia Nyata dalam Python

Prinsip SOLID (Kredit Imej: FreeCodeCamp)

SOLID ialah akronim yang bermaksud lima prinsip reka bentuk yang membantu pembangun mencipta perisian yang lebih mudah diselenggara, difahami dan fleksibel. Mari kita lihat setiap satu dengan contoh yang boleh dikaitkan.

1. S - Prinsip Tanggungjawab Tunggal (SRP)

Definisi: Kelas sepatutnya hanya mempunyai satu sebab untuk berubah, bermakna kelas itu harus mempunyai satu tugas atau tanggungjawab sahaja.

Penjelasan: Bayangkan anda mempunyai alat yang menggabungkan dua tugasan berbeza, seperti menghantar e-mel dan memproses pembayaran. Jika kedua-dua tugas dikendalikan oleh satu kelas, perubahan dalam ciri e-mel mungkin memecahkan ciri pembayaran. Dengan mengasingkan tanggungjawab ini, anda meminimumkan risiko perubahan pada satu bahagian yang menjejaskan bahagian yang lain.

Contoh:

class EmailSender:
    def send_email(self, recipient, subject, body):
        # Code to send an email
        print(f"Sending email to {recipient} with subject '{subject}'")

class PaymentProcessor:
    def process_payment(self, amount):
        # Code to process payment
        print(f"Processing payment of amount {amount}")

# Usage
email_sender = EmailSender()
email_sender.send_email("user@example.com", "Hello!", "Welcome to our service!")

payment_processor = PaymentProcessor()
payment_processor.process_payment(100)

Dalam contoh ini, EmailSender hanya bertanggungjawab untuk menghantar e-mel dan PaymentProcessor hanya bertanggungjawab untuk memproses pembayaran. Mereka masing-masing mempunyai satu tanggungjawab, menjadikan kod lebih mudah untuk dikekalkan dan dilanjutkan.

2. O - Prinsip Terbuka/Tertutup (OCP)

Definisi: Entiti perisian (seperti kelas, modul, fungsi, dll.) harus dibuka untuk sambungan tetapi ditutup untuk pengubahsuaian.

Penjelasan: Ini bermakna anda sepatutnya boleh menambah ciri atau gelagat baharu pada kelas tanpa mengubah kod sedia ada. Bayangkan anda mempunyai sistem pemprosesan pembayaran dan anda ingin menambah kaedah pembayaran baharu. Anda sepatutnya boleh menambah kaedah baharu ini tanpa mengubah suai kod sedia ada.

Contoh:

from abc import ABC, abstractmethod

class PaymentProcessor(ABC):
    @abstractmethod
    def process_payment(self, amount):
        pass

class CreditCardPayment(PaymentProcessor):
    def process_payment(self, amount):
        print(f"Processing credit card payment of {amount}")

class PayPalPayment(PaymentProcessor):
    def process_payment(self, amount):
        print(f"Processing PayPal payment of {amount}")

# Usage
payments = [CreditCardPayment(), PayPalPayment()]
for payment in payments:
    payment.process_payment(100)

Dalam contoh ini, PaymentProcessor ialah kelas abstrak yang mentakrifkan kontrak untuk memproses pembayaran. CreditCardPayment dan PayPalPayment ialah pelaksanaan yang melanjutkan kelas ini. Jika anda ingin menambah kaedah pembayaran baharu, anda boleh membuat kelas baharu yang melanjutkan PaymentProcessor tanpa mengubah suai kelas sedia ada.

3. L - Prinsip Penggantian Liskov (LSP)

Definisi: Subjenis mesti boleh digantikan untuk jenis asasnya tanpa mengubah ketepatan program.

Penjelasan: Ini bermakna objek superclass harus diganti dengan objek subclass tanpa menjejaskan fungsi program. Contohnya, jika anda mempunyai fungsi yang berfungsi dengan kelas Kenderaan, ia juga harus berfungsi dengan mana-mana subkelas seperti Kereta atau Basikal.

Contoh:

class Vehicle:
    def start_engine(self):
        pass

class Car(Vehicle):
    def start_engine(self):
        print("Starting car engine...")

class Bike(Vehicle):
    def start_engine(self):
        print("Starting bike engine...")

# Usage
def start_vehicle_engine(vehicle: Vehicle):
    vehicle.start_engine()

car = Car()
bike = Bike()

start_vehicle_engine(car)  # Should work fine
start_vehicle_engine(bike) # Should work fine

Dalam contoh ini, Kereta dan Basikal ialah subkelas Kenderaan. Fungsi start_vehicle_engine boleh berfungsi dengan mana-mana subkelas Kenderaan tanpa perlu mengetahui spesifikasi subkelas, yang selaras dengan Prinsip Penggantian Liskov.

4. I - Prinsip Pengasingan Antara Muka (ISP)

Definisi: Pelanggan tidak boleh dipaksa untuk melaksanakan antara muka yang tidak digunakannya. Daripada satu antara muka yang gemuk, banyak antara muka yang kecil lebih disukai berdasarkan kumpulan kaedah, setiap satu menyediakan satu submodul.

Penjelasan: Prinsip ini mencadangkan anda harus mencipta antara muka khusus untuk setiap jenis klien dan bukannya satu antara muka tujuan umum. Bayangkan anda mempunyai mesin yang boleh mencetak, mengimbas dan faks. Jika anda mempunyai mesin berasingan yang hanya boleh mencetak atau mengimbas, mesin itu tidak boleh dipaksa untuk melaksanakan fungsi yang tidak digunakan.

Contoh:

from abc import ABC, abstractmethod

class Printer(ABC):
    @abstractmethod
    def print(self, document):
        pass

class Scanner(ABC):
    @abstractmethod
    def scan(self, document):
        pass

class MultiFunctionDevice(Printer, Scanner):
    def print(self, document):
        print(f"Printing: {document}")

    def scan(self, document):
        print(f"Scanning: {document}")

# Usage
mfd = MultiFunctionDevice()
mfd.print("Document 1")
mfd.scan("Document 2")

Di sini, Pencetak dan Pengimbas adalah antara muka yang berasingan. MultiFunctionDevice melaksanakan kedua-duanya, tetapi jika terdapat peranti yang hanya mencetak atau hanya mengimbas, mereka tidak perlu melaksanakan kaedah yang mereka tidak gunakan, mematuhi Prinsip Pengasingan Antara Muka.

5. D - Prinsip Penyongsangan Ketergantungan (DIP)

Definisi: Modul peringkat tinggi tidak boleh bergantung pada modul peringkat rendah. Kedua-duanya harus bergantung pada abstraksi (cth., antara muka). Abstraksi tidak boleh bergantung pada butiran. Butiran harus bergantung pada abstraksi.

Penjelasan: Daripada kelas peringkat tinggi bergantung terus pada kelas peringkat rendah, kedua-duanya harus bergantung pada antara muka atau kelas abstrak. Ini membolehkan lebih fleksibiliti dan penyelenggaraan yang lebih mudah.

Contoh:

from abc import ABC, abstractmethod

class NotificationService(ABC):
    @abstractmethod
    def send(self, message):
        pass

class EmailNotificationService(NotificationService):
    def send(self, message):
        print(f"Sending email: {message}")

class SMSNotificationService(NotificationService):
    def send(self, message):
        print(f"Sending SMS: {message}")

class NotificationSender:
    def __init__(self, service: NotificationService):
        self.service = service

    def notify(self, message):
        self.service.send(message)

# Usage
email_service = EmailNotificationService()
sms_service = SMSNotificationService()

notifier = NotificationSender(email_service)
notifier.notify("Hello via Email")

notifier = NotificationSender(sms_service)
notifier.notify("Hello via SMS")

Dalam contoh ini, NotificationSender bergantung pada abstraksi NotificationService dan bukannya pada kelas konkrit seperti EmailNotificationService atau SMSNotificationService. Dengan cara ini, anda boleh menukar perkhidmatan pemberitahuan tanpa menukar kelas NotificationSender.

Kesimpulan

• Prinsip Tanggungjawab Tunggal (SRP): Sebuah kelas harus melakukan satu perkara dan melakukannya dengan baik.

• Prinsip Terbuka/Tertutup (OCP): Kelas harus dibuka untuk sambungan tetapi ditutup untuk pengubahsuaian.

• Prinsip Penggantian Liskov (LSP): Subkelas hendaklah boleh digantikan untuk kelas asasnya.

• Prinsip Pengasingan Antara Muka (ISP): Tiada pelanggan harus dipaksa untuk bergantung pada kaedah yang tidak digunakan.

• Prinsip Pembalikan Kebergantungan (DIP): Bergantung pada abstraksi, bukan pada pelaksanaan konkrit.

Dengan mengikuti prinsip SOLID ini, anda boleh mencipta perisian yang lebih mudah difahami, diselenggara dan dikembangkan.

Atas ialah kandungan terperinci Prinsip SOLID - Diterangkan Menggunakan Contoh Dunia Nyata dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!