Prinsip PADAT dalam Pembangunan Perisian

Dalam bidang pembangunan perisian, prinsip SOLID ialah satu set lima prinsip reka bentuk yang bertujuan untuk mencipta sistem perisian yang teguh, boleh diselenggara dan berskala. Prinsip ini, yang dicipta oleh Robert C. Martin (juga dikenali sebagai Uncle Bob), menyediakan garis panduan untuk dipatuhi oleh pembangun bagi memastikan pangkalan kod mereka bersih dan boleh diperluaskan. Di sini, kami akan meneroka setiap prinsip SOLID dan menunjukkan cara melaksanakannya dengan contoh dalam Python.

1. Prinsip Tanggungjawab Tunggal (SRP)

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

Contoh:

class Order:
    def __init__(self, items):
        self.items = items

    def calculate_total(self):
        return sum(item.price for item in self.items)

class InvoicePrinter:
    @staticmethod
    def print_invoice(order):
        print("Invoice:")
        for item in order.items:
            print(f"{item.name}: ${item.price}")
        print(f"Total: ${order.calculate_total()}")

# Usage
class Item:
    def __init__(self, name, price):
        self.name = name
        self.price = price

items = [Item("Apple", 1), Item("Banana", 2)]
order = Order(items)
InvoicePrinter.print_invoice(order)

Dalam contoh ini, kelas Pesanan hanya bertanggungjawab untuk menguruskan pesanan, manakala kelas InvoicePrinter bertanggungjawab untuk mencetak invois. Ini mematuhi SRP dengan memastikan setiap kelas mempunyai tanggungjawab tunggal.

2. Prinsip Terbuka/Tertutup (OCP)

Definisi: Entiti perisian harus dibuka untuk sambungan tetapi ditutup untuk pengubahsuaian.

Contoh:

class Discount:
    def apply(self, total):
        return total

class PercentageDiscount(Discount):
    def __init__(self, percentage):
        self.percentage = percentage

    def apply(self, total):
        return total - (total * self.percentage / 100)

class FixedDiscount(Discount):
    def __init__(self, amount):
        self.amount = amount

    def apply(self, total):
        return total - self.amount

def calculate_total(order, discount):
    total = order.calculate_total()
    return discount.apply(total)

# Usage
discount = PercentageDiscount(10)
print(calculate_total(order, discount))

Dalam contoh ini, kelas Diskaun dilanjutkan oleh PercentageDiscount dan FixedDiscount tanpa mengubah suai kelas asas, mematuhi OCP.

3. Prinsip Penggantian Liskov (LSP)

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

Contoh:

class Bird:
    def fly(self):
        pass

class Sparrow(Bird):
    def fly(self):
        print("Sparrow is flying")

class Ostrich(Bird):
    def fly(self):
        raise Exception("Ostrich can't fly")

def make_bird_fly(bird):
    bird.fly()

# Usage
sparrow = Sparrow()
make_bird_fly(sparrow)

ostrich = Ostrich()
try:
    make_bird_fly(ostrich)
except Exception as e:
    print(e)

Di sini, Burung Unta melanggar LSP kerana ia tidak boleh terbang, oleh itu ia tidak boleh digantikan untuk kelas asas Burung.

4. Prinsip Pengasingan Antara Muka (ISP)

Definisi: Pelanggan tidak boleh dipaksa untuk bergantung pada antara muka yang mereka tidak gunakan.

Contoh:

from abc import ABC, abstractmethod

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

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

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

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

class SimplePrinter(Printer):
    def print_document(self, document):
        print(f"Printing: {document}")

# Usage
mfp = MultiFunctionPrinter()
mfp.print_document("Report")
mfp.scan_document("Report")

printer = SimplePrinter()
printer.print_document("Report")

Dalam contoh ini, MultiFunctionPrinter melaksanakan kedua-dua antara muka Pencetak dan Pengimbas, manakala SimplePrinter hanya melaksanakan Pencetak, mematuhi ISP.

5. Prinsip Penyongsangan Ketergantungan (DIP)

Definisi: Modul peringkat tinggi tidak boleh bergantung pada modul peringkat rendah. Kedua-duanya harus bergantung pada abstraksi. Abstraksi tidak boleh bergantung pada butiran. Butiran harus bergantung pada abstraksi.

Contoh:

from abc import ABC, abstractmethod

class Database(ABC):
    @abstractmethod
    def save(self, data):
        pass

class MySQLDatabase(Database):
    def save(self, data):
        print("Saving data to MySQL database")

class MongoDBDatabase(Database):
    def save(self, data):
        print("Saving data to MongoDB database")

class UserService:
    def __init__(self, database: Database):
        self.database = database

    def save_user(self, user_data):
        self.database.save(user_data)

# Usage
mysql_db = MySQLDatabase()
mongo_db = MongoDBDatabase()

user_service = UserService(mysql_db)
user_service.save_user({"name": "John Doe"})

user_service = UserService(mongo_db)
user_service.save_user({"name": "Jane Doe"})

Dalam contoh ini, UserService bergantung pada abstraksi Pangkalan Data, membenarkan fleksibiliti dan mematuhi DIP.

Kesimpulan

Dengan mematuhi prinsip SOLID, pembangun boleh mencipta perisian yang lebih modular, lebih mudah diselenggara dan berskala. Prinsip ini membantu dalam mengurus kerumitan pembangunan perisian, memastikan kod kekal bersih dan boleh dikembangkan. Melalui contoh praktikal dalam Python, kita dapat melihat cara prinsip ini boleh digunakan untuk mencipta sistem yang teguh dan boleh diselenggara.

Atas ialah kandungan terperinci Prinsip PADAT dalam Pembangunan Perisian. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!