Menulis Clean Code: Prinsip Open-Closed Principle (OCP) pada SOLID

Prinsip Open-Closed Principle (OCP) pada SOLID

Open-Closed Principle (OCP): Dalam istilah bahasa indonesia sederhanya adalah Kode harus "terbuka untuk ekstensi, tetapi tertutup untuk modifikasi." Artinya, Kita dapat menambahkan fungsionalitas baru tanpa mengubah kode yang sudah ada.

Ilustrasi Open-Closed Principle (OCP)

Dengan menggunakan konsep inheritance dan polymorphism di Java, Kita dapat membuat kode yang mudah diperluas tanpa memodifikasi kode yang ada. Contohnya, Kita misal bisa membuat interface PaymentProcessor dan mengimplementasikan metode processPayment() dalam beberapa kelas seperti CreditCardPayment dan PaypalPayment tanpa harus mengubah kode yang sudah ada.

Prinsip ini menjaga agar kode yang sudah ada tidak perlu diubah setiap kali ada fitur baru, melainkan dapat diperluas dengan menambahkan kode baru. Dengan begitu, kompleksitas dapat dikendalikan karena kode lama tidak terus-menerus dimodifikasi.

Prinsip Solid memang berkaitan erat dengan Open-Closed Principle (OCP), karena OCP adalah salah satu dari lima prinsip dalam Solid. OCP menyatakan bahwa "kelas atau fungsi harus terbuka untuk ekstensi tetapi tertutup untuk modifikasi," artinya Anda dapat menambahkan fungsionalitas baru tanpa mengubah kode yang sudah ada.

Prinsip OCP sangat penting dalam Solid, karena ia membantu mencapai tujuan utama dari prinsip Solid yaitu membuat kode yang mudah dipelihara, fleksibel, dan dapat diperluas. Berikut cara OCP berkaitan dan saling melengkapi dengan prinsip-prinsip lain dalam Solid:

1. Menjaga Kode yang Stabil dan Mudah Dipelihara

   • OCP memastikan bahwa perubahan pada kode tidak mengganggu kode yang sudah berfungsi, sehingga kode lebih stabil dan mudah dipelihara. Prinsip-prinsip lain dalam Solid, seperti SRP dan DIP, membantu mendukung stabilitas ini dengan memastikan bahwa setiap bagian kode memiliki tanggung jawab yang jelas dan bergantung pada abstraksi.

2. Mendukung Extensibility tanpa Modifikasi

   • Solid secara keseluruhan mendukung pembuatan sistem yang modular, dan OCP menegaskan modularitas ini dengan mendorong pengembangan sistem yang bisa diperluas tanpa mengubah kode yang sudah ada. Misalnya, dengan mengikuti SRP, Anda bisa membuat kelas dengan tanggung jawab tunggal, dan dengan OCP, Anda bisa menambah fungsionalitas pada kelas tersebut melalui ekstensi atau subclass tanpa mengubahnya secara langsung.

3. Meminimalkan Dampak Perubahan pada Kode

   • OCP memungkinkan Anda menambahkan fitur baru dengan membuat subclass atau implementasi baru tanpa mengubah kelas atau modul yang sudah ada. Hal ini mendukung prinsip KISS dan DIP, karena perubahan yang tidak perlu diminimalkan, dan kode bisa tetap sederhana dan terstruktur. Dengan menerapkan OCP, Anda juga akan mengurangi risiko bug karena perubahan terbatas pada kelas-kelas baru.

4. Mendorong Penggunaan Polimorfisme dan Abstraksi

   • OCP sering kali diterapkan dengan menggunakan antarmuka dan polimorfisme dalam pemrograman berorientasi objek. DIP mendukung konsep ini dengan menyarankan penggunaan abstraksi alih-alih ketergantungan langsung. Dengan demikian, OCP memanfaatkan polimorfisme untuk mendukung perubahan tanpa memodifikasi kode yang sudah ada, menjaga kode tetap fleksibel.

Secara keseluruhan, Solid dan OCP saling melengkapi dalam menciptakan kode yang lebih modular, fleksibel, dan berkelanjutan. OCP mendukung tujuan utama Solid untuk membuat sistem yang terstruktur dan mudah diperluas, sehingga setiap perubahan dapat dilakukan dengan aman tanpa merusak bagian lain dalam kode.

Contoh Penerapan Open-Closed Principle (OCP)

Berikut contoh real case penerapan pen-Closed Principle (OCP) dalam Java.

Berikut contoh penerapan Open-Closed Principle (OCP) dalam Java dengan kasus sederhana pada sistem pembayaran. Katakan kita memiliki aplikasi yang mendukung beberapa metode pembayaran, seperti pembayaran dengan kartu kredit dan PayPal. Awalnya, kita mungkin memiliki satu kelas PaymentProcessor yang menangani logika pembayaran untuk berbagai jenis pembayaran:

public class PaymentProcessor {
    public void processPayment(String paymentType) {
        if (paymentType.equals("CreditCard")) {
            System.out.println("Memproses pembayaran dengan kartu kredit...");
            // Logika spesifik untuk pembayaran kartu kredit
        } else if (paymentType.equals("PayPal")) {
            System.out.println("Memproses pembayaran dengan PayPal...");
            // Logika spesifik untuk pembayaran PayPal
        }
    }
}

Masalahnya kode ini melanggar OCP karena setiap kali kita ingin menambahkan metode pembayaran baru (misalnya, OVO atau GoPay), kita harus mengubah kode dalam PaymentProcessor, menambahkan lebih banyak if-else untuk menangani metode pembayaran baru. Seiring waktu, kode ini akan menjadi sulit dipelihara dan rentan terhadap bug.

Solusinya adalah dengan OCP Agar kode sesuai dengan OCP, kita perlu mendesain PaymentProcessor agar terbuka untuk ekstensi, tetapi tertutup untuk modifikasi. Kita bisa melakukannya dengan menggunakan abstraksi dalam bentuk interface PaymentMethod dan mengimplementasikan metode pembayaran terpisah untuk setiap jenis pembayaran.

1. Buat Interface PaymentMethod

public interface PaymentMethod {
    void process();
}

2. Implementasi Kelas untuk Setiap Metode Pembayaran

• CreditCardPayment:

public class CreditCardPayment implements PaymentMethod {
    @Override
    public void process() {
        System.out.println("Memproses pembayaran dengan kartu kredit...");
        // Logika spesifik untuk pembayaran kartu kredit
    }
}

• PayPalPayment:

public class PayPalPayment implements PaymentMethod {
    @Override
    public void process() {
        System.out.println("Memproses pembayaran dengan PayPal...");
        // Logika spesifik untuk pembayaran PayPal
    }
}

 3. Refactor PaymentProcessor untuk Menggunakan Polimorfisme

Sekarang kita akan mengubah PaymentProcessor agar hanya bekerja dengan antarmuka PaymentMethod, sehingga tidak perlu dimodifikasi ketika metode pembayaran baru ditambahkan.

public class PaymentProcessor {
    public void processPayment(PaymentMethod paymentMethod) {
        paymentMethod.process();
    }
}

4. Penggunaan di Main

Kita sekarang dapat menambahkan metode pembayaran baru tanpa mengubah PaymentProcessor. Cukup buat kelas baru yang mengimplementasikan PaymentMethod, dan kelas tersebut akan berfungsi dengan PaymentProcessor.

public class Main {
    public static void main(String[] args) {
        PaymentProcessor processor = new PaymentProcessor();

        PaymentMethod creditCardPayment = new CreditCardPayment();
        PaymentMethod payPalPayment = new PayPalPayment();

        processor.processPayment(creditCardPayment);  // Memproses pembayaran dengan kartu kredit...
        processor.processPayment(payPalPayment);      // Memproses pembayaran dengan PayPal...
    }
}

Keuntungan menerapkan OCP:

1. Ekstensi Mudah: Jika ingin menambah metode pembayaran baru, seperti OVO atau GoPay, Anda cukup membuat kelas baru yang mengimplementasikan PaymentMethod, tanpa mengubah PaymentProcessor.
2. Keterbacaan dan Pemeliharaan: Kode menjadi lebih bersih dan terstruktur, memudahkan pemeliharaan.
3. Mendukung OCP: PaymentProcessor tetap tertutup untuk modifikasi (tidak diubah), tetapi terbuka untuk ekstensi, sehingga mendukung prinsip OCP.

Dengan demikian, penerapan OCP membuat kode lebih modular, fleksibel, dan lebih mudah dikembangkan tanpa mengubah kode yang sudah ada.

Open-Closed Principle (OCP) masih termasuk dalam kategori KISS (Keep It Simple, Stupid) karena prinsip ini membantu menjaga kode tetap sederhana, terstruktur, dan mudah dipelihara. KISS menekankan agar solusi tidak lebih rumit dari yang diperlukan, dan OCP mendukung tujuan ini dengan menjaga agar kode mudah diperluas tanpa modifikasi berlebihan. Berikut adalah beberapa cara OCP mendukung prinsip KISS:

1. Mengurangi Kerumitan dalam Menambah Fitur

   • Dengan OCP, menambah fitur baru tidak memerlukan perubahan pada kode yang sudah ada, melainkan cukup menambahkan kelas atau modul baru. Ini mendukung KISS karena kode menjadi lebih sederhana; kita tidak perlu menambahkan banyak kondisi if-else atau mengubah kode lama setiap kali ada penambahan.

2. Meminimalkan Risiko Bug saat Modifikasi

   • Ketika kode tidak perlu dimodifikasi untuk menambah fitur, risiko bug juga berkurang, sehingga kode tetap lebih stabil. Hal ini mendukung prinsip KISS karena kode menjadi lebih terkendali dan bebas dari risiko perubahan yang berlebihan.

3. Membuat Kode Modular dan Mudah Dibaca

   • OCP mendorong penggunaan polimorfisme dan abstraksi, yang membuat kode menjadi modular dan terstruktur dengan baik. Dengan begitu, kode lebih mudah dipahami dan tidak memerlukan penyesuaian ulang saat diperluas—karakteristik yang sangat sesuai dengan filosofi KISS.

4. Menghindari Pengulangan dan Mengurangi Dependensi

   • OCP mengurangi kebutuhan untuk menduplikasi kode atau menambah logika berulang, misalnya dengan memanfaatkan antarmuka dan implementasi terpisah. Hal ini menjaga kode tetap sederhana dan bebas dari kompleksitas yang tidak perlu, sejalan dengan KISS.

Secara keseluruhan, OCP mendorong desain yang sederhana, fleksibel, dan berkelanjutan, sehingga prinsip ini sangat sejalan dengan tujuan utama KISS untuk menjaga kode tetap mudah dipahami dan dikelola.

Artikel ini terkait dengan: menulis clean code dengan prinsip solid dan kiss

Related Article:

1. Menulis clean code dengan prinsip solid dan kiss

2. Menulis Clean Code: Prinsip Single Responsibility Principle (SRP) pada SOLID

3. Menulis Clean Code Dengan Open Closed Principle 

4. Menulis Clean dengan Interface Segregation Principle

5. Menulis Clean Code: Prinsip Dependency Inversion Principle (DIP) Pada SOLID

6. Prinsip Liskov Substitution Principle (LSP) Pada SOLID