SOLID ialah koleksi prinsip asas yang direka untuk meningkatkan kebolehurusan dan kebolehskalaan kod dalam Pengaturcaraan Berorientasikan Objek (OOP). Ia terdiri daripada lima prinsip utama:

1. S Prinsip Tanggungjawab tunggal?—?SRP
2. O Prinsip Tertutup pen?—?OCP
3. L Prinsip Penggantian iskov?—?LSP
4. Saya Prinsip Pengasingan antara muka?—?ISP
5. D Prinsip Penyongsangan ependency?—?DIP

Prinsip-prinsip ini telah diperkenalkan oleh Robert C. Martin (juga dikenali sebagai Uncle Bob) pada awal 2000-an dan sejak itu telah diterima pakai secara meluas dalam komuniti pembangunan perisian. Dengan mengikut prinsip SOLID, pembangun boleh mencipta kod yang lebih mudah difahami, diubah suai dan dilanjutkan, yang membawa kepada sistem perisian yang lebih mantap dan boleh diselenggara.

Prinsip Tanggungjawab Tunggal (SRP)

Prinsip Tanggungjawab Tunggal ialah prinsip pertama dan paling asas dalam OOP dan SOLID. Seperti namanya, prinsip ini bermaksud "Satu kelas harus mempunyai hanya satu tanggungjawab khusus untuk dijaga".

Andaikan kita mempunyai kelas yang dipanggil Invois , yang mengandungi 2 kaedah generateInvoice() dan saveToFiles() .

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }

  public void saveToFiles() {
    // code to save invoice as a file.
  }
}

Ini bukan amalan yang baik kerana kelas Invois mempunyai dua tanggungjawab. Pendekatan yang lebih baik ialah mengasingkan fungsi ini kepada kelas khusus.

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }
}

public class FileManager {
  public void saveToFiles(Invoice invoice) {
    // code to save invoice as a file.
  }
}

Di sini, kita dapat lihat kita mempunyai 2 kelas untuk kes penggunaan:

• Menjana invois
• Simpan ke fail

Faedah mengikuti SRP

• Organisasi Kod yang Diperbaiki : Dengan mengasingkan kebimbangan kepada kelas yang berbeza, pangkalan kod menjadi lebih teratur dan lebih mudah untuk dinavigasi.
• Kebolehselenggaraan Lebih Baik : Apabila kelas mempunyai satu tanggungjawab, lebih mudah untuk memahami tujuannya dan membuat perubahan tanpa kesan sampingan yang tidak diingini.
• Peningkatan Kebolehgunaan Semula : Kelas dengan satu tanggungjawab lebih berkemungkinan boleh diguna semula di bahagian aplikasi yang berbeza atau malah dalam projek lain.
• Pengujian Lebih Mudah : Kelas dengan tanggungjawab tunggal biasanya lebih kecil dan lebih fokus, menjadikannya lebih mudah untuk diuji secara berasingan.

Prinsip Terbuka-Tertutup (OCP)

Prinsip Terbuka-Tertutup ialah satu lagi prinsip teras dalam SOLID. Prinsip ini telah diperkenalkan oleh Bertrand Meyer pada tahun 1997. Idea di sebalik prinsip ini ialah "Artifak perisian (kelas, modul dan fungsi) harus dibuka untuk sambungan, tetapi ditutup untuk pengubahsuaian."

Contohnya;

Katakanlah, kita mempunyai kelas yang dipanggil Shape , kita boleh menggunakan kelas ini untuk mengira luas bentuk.

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }

  public void saveToFiles() {
    // code to save invoice as a file.
  }
}

Dalam kod di atas, menambah bentuk baharu memerlukan pengubahsuaian kelas Bentuk sedia ada, yang tidak dianggap sebagai amalan yang baik.

Di bawah ialah contoh kod yang menunjukkan cara menggunakan Prinsip Terbuka-Tutup pada senario ini.

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }
}

public class FileManager {
  public void saveToFiles(Invoice invoice) {
    // code to save invoice as a file.
  }
}

Dengan aplikasi OCP, kami boleh menambah banyak bentuk yang kami mahu tanpa mengubah suai pelaksanaan semasa.

NOTA: Menggunakan antara muka bukan satu-satunya cara untuk mencapai OCP.

Faedah mengikuti OCP

• Risiko Pepijat Mengurangkan : Dengan tidak mengubah suai kod sedia ada, risiko memperkenalkan pepijat baharu atau memecahkan fungsi sedia ada diminimumkan.
• Kebolehselenggaraan yang Dipertingkat : Kod yang mengikuti OCP adalah lebih mudah untuk diselenggara dan dilanjutkan, kerana ciri baharu boleh ditambah tanpa mengubah pangkalan kod sedia ada.
• Fleksibiliti Dipertingkat : Penggunaan abstraksi dan polimorfisme membolehkan reka bentuk yang lebih fleksibel dan boleh disesuaikan, menjadikannya lebih mudah untuk menampung keperluan yang berubah-ubah.

Prinsip Penggantian Liskov (LSP)

Prinsip Penggantian Liskov ialah satu lagi prinsip penting dalam OOP. Ia telah diperkenalkan oleh Barbara Liskov pada tahun 1987 semasa ceramah persidangan mengenai pengabstrakan data.

Prinsipnya menyatakan, "Objek kelas super harus diganti dengan objek subkelasnya tanpa mengubah ketepatan program".

Sebagai contoh, jika Circle dan Rectangle ialah sub jenis Shape, maka kita sepatutnya dapat menggantikan objek Shape dengan objek Bulatan atau Rectangle tanpa sebarang masalah.

public class Shape {
    private String shapeType;
    private double radius;
    private double length;
    private double width;

    public Shape(String shapeType, double radius, double length, double width) {
        this.shapeType = shapeType;
        this.radius = radius;
        this.length = length;
        this.width = width;
    }

    public double area() {
        if (shapeType.equals("circle")) {
            return Math.PI * (radius * radius);
        } else if (shapeType.equals("rectangle")) {
            return length * width;
        } else {
            throw new IllegalArgumentException("Unknown shape type");
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Shape circle = new Shape("circle", 5, 0, 0);
        Shape rectangle = new Shape("rectangle", 0, 4, 6);

        System.out.println(circle.area());
        System.out.println(rectangle.area());
    }
}

Seperti yang ditunjukkan dalam contoh ini, mematuhi Prinsip Penggantian Liskov bermakna kita seharusnya dapat menggantikan tika superclass dengan tika subkelas dengan lancar.

Faedah mengikuti LSP

• Kebolehgunaan Semula Kod yang Dipertingkat : Dengan memastikan subjenis boleh digantikan untuk jenis asasnya, kod yang menggunakan jenis asas juga boleh berfungsi dengan mana-mana subjenisnya, menggalakkan penggunaan semula kod.
• Kebolehselenggaraan Dipertingkat : Kod yang mengikuti LSP lebih mudah diselenggara kerana ia mengurangkan risiko memperkenalkan pepijat apabila mengubah suai atau melanjutkan pangkalan kod.
• Kebolehujian yang Lebih Baik : LSP menjadikannya lebih mudah untuk menulis ujian unit untuk kelas dan subjenisnya, kerana ujian boleh ditulis terhadap jenis asas dan harus berfungsi untuk semua subjenis.

Prinsip Pengasingan Antara Muka (ISP)

Prinsip Pengasingan Antara Muka ialah salah satu daripada lima prinsip SOLID yang diperkenalkan oleh Robert C. Martin. Ia menyatakan: "Pelanggan tidak boleh dipaksa untuk bergantung pada antara muka yang mereka tidak gunakan".

Dalam erti kata lain, Menggunakan banyak antara muka khusus tugas adalah lebih baik daripada menggunakan satu antara muka tujuan umum.

Contoh di bawah menunjukkan penggunaan antara muka tujuan umum.

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }

  public void saveToFiles() {
    // code to save invoice as a file.
  }
}

Menggunakan antara muka tujuan umum seperti MultifunctionPrinter memaksa kami untuk melaksanakan kaedah yang tidak perlu, yang dianggap sebagai amalan buruk. Mari terokai cara kita boleh menggunakan Prinsip Pengasingan Antara Muka pada senario ini.

Antara muka

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }
}

public class FileManager {
  public void saveToFiles(Invoice invoice) {
    // code to save invoice as a file.
  }
}

Perlaksanaan

public class Shape {
    private String shapeType;
    private double radius;
    private double length;
    private double width;

    public Shape(String shapeType, double radius, double length, double width) {
        this.shapeType = shapeType;
        this.radius = radius;
        this.length = length;
        this.width = width;
    }

    public double area() {
        if (shapeType.equals("circle")) {
            return Math.PI * (radius * radius);
        } else if (shapeType.equals("rectangle")) {
            return length * width;
        } else {
            throw new IllegalArgumentException("Unknown shape type");
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Shape circle = new Shape("circle", 5, 0, 0);
        Shape rectangle = new Shape("rectangle", 0, 4, 6);

        System.out.println(circle.area());
        System.out.println(rectangle.area());
    }
}

Dengan menggunakan ISP , kami membahagikannya kepada antara muka yang lebih kecil dan khusus peranan?—?seperti Pencetak, Pengimbas dan Faks. Ini membenarkan setiap kelas (cth. BasicPrinter, AdvancedPrinter atau FaxMachine) untuk melaksanakan hanya fungsi yang berkaitan, mempromosikan modulariti dan mengurangkan kebergantungan yang tidak perlu.

Faedah mengikuti ISP

• Kod Modular dan Boleh Digunakan Semula : Dengan memecahkan antara muka yang besar kepada yang lebih kecil, lebih khusus, kod tersebut menjadi lebih modular dan boleh digunakan semula. Kelas atau modul boleh melaksanakan hanya antara muka yang mereka perlukan, mengurangkan kebergantungan yang tidak perlu dan memudahkan penggunaan semula kod merentas bahagian sistem yang berlainan.
• Kerumitan Kod Dikurangkan : Apabila kelas atau modul hanya bergantung pada antara muka yang mereka perlukan, kod menjadi kurang kompleks dan lebih mudah difahami. Ini kerana pembangun tidak perlu berurusan dengan kaedah atau kebergantungan yang tidak perlu. Ini tidak berkaitan dengan kes penggunaan khusus mereka.
• Kebolehselenggaraan yang Lebih Baik : Dengan antara muka yang lebih kecil dan lebih fokus, ia menjadi lebih mudah untuk mengekalkan kod. Perubahan pada satu antara muka kurang berkemungkinan menjejaskan bahagian lain sistem, mengurangkan risiko memperkenalkan pepijat atau memecahkan fungsi sedia ada.
• Kebolehujian yang Lebih Baik : Antara muka yang lebih kecil dan lebih fokus menjadikannya lebih mudah untuk menulis ujian unit untuk komponen individu. Ini kerana ujian boleh memfokuskan pada tingkah laku tertentu tanpa dipengaruhi oleh kaedah atau kebergantungan yang tidak berkaitan.
• Peningkatan Fleksibiliti : Dengan mematuhi ISP, sistem menjadi lebih fleksibel dan lebih mudah untuk dilanjutkan atau diubah suai. Ciri atau keperluan baharu boleh ditambah dengan mencipta antara muka baharu atau mengubah suai yang sedia ada tanpa menjejaskan keseluruhan sistem.

Prinsip Penyongsangan Ketergantungan (DIP)

Prinsip Penyongsangan Kebergantungan ialah prinsip terakhir SOLID. Yang turut diperkenalkan oleh Robert C. Martin. Ini menggalakkan kod yang digandingkan secara longgar.

DIP menyatakan beberapa perkara:

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

Dalam istilah mudah, bukannya kelas bergantung secara langsung pada kelas khusus lain (pelaksanaan konkrit), ia harus bergantung pada antara muka atau kelas abstrak. Ini menjadikan kod lebih fleksibel dan lebih mudah untuk diselenggara, kerana anda boleh menukar pelaksanaan tanpa menukar kelas bergantung.

Kod berganding rapat (tanpa DIP)

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }

  public void saveToFiles() {
    // code to save invoice as a file.
  }
}

Seperti yang ditunjukkan dalam contoh di atas, kelas Komputer secara langsung bergantung pada kelas Papan Kekunci.

Kod ganding longgar (dengan DIP)

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }
}

public class FileManager {
  public void saveToFiles(Invoice invoice) {
    // code to save invoice as a file.
  }
}

Kini, Komputer bergantung pada antara muka InputDevice, bukan Papan Kekunci tertentu. Ini memudahkan anda menukar kepada peranti input lain, seperti WirelessKeyboard, tanpa mengubah suai kelas Komputer.

Faedah mengikuti DIP

• Gandingan Longgar : Dengan bergantung pada abstraksi berbanding pelaksanaan konkrit, kod menjadi kurang gandingan yang ketat, menjadikannya lebih mudah untuk menukar satu bahagian sistem tanpa menjejaskan bahagian lain.
• Kebolehselenggaraan yang Lebih Baik : Perubahan dalam modul peringkat rendah tidak memberi kesan kepada modul peringkat tinggi, menjadikan sistem lebih mudah untuk diselenggara dan dilanjutkan.
• Kebolehujian Dipertingkat : Modul peringkat tinggi boleh diuji menggunakan pelaksanaan olok-olok modul peringkat rendah, menjadikan ujian lebih pantas dan lebih dipercayai.
• Peningkatan Kebolehgunaan Semula : Modul peringkat tinggi boleh digunakan semula dalam konteks yang berbeza tanpa perlu menukar modul peringkat rendah yang bergantung kepada modul tersebut.

Kesimpulan

Kesimpulannya, prinsip SOLID: Tanggungjawab Tunggal, Tertutup Terbuka, Penggantian Liskov, Pengasingan Antara Muka dan Penyongsangan Ketergantungan menyediakan garis panduan penting untuk menulis kod yang bersih, boleh diselenggara dan berskala dalam pengaturcaraan berorientasikan objek.

Dengan mematuhi prinsip ini, pembangun boleh mencipta sistem yang lebih mudah difahami, diubah suai dan diperluas, akhirnya membawa kepada perisian berkualiti tinggi dan proses pembangunan yang lebih cekap.

Ringkasan

Terima kasih kerana membaca artikel ini! Saya harap anda kini mempunyai pemahaman yang kukuh tentang prinsip SOLID dan cara anda boleh menggunakannya untuk meningkatkan projek anda.

Ikuti saya di:

LinkedIn?—?@nsadisha
GitHub?—?@nsadisha
Sederhana?—?@nsadisha
Dev.to?—?@nsadisha

— Sadisha Nimsara

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