SOLID Principles: Pentingnya Prinsip Interface Segregation dalam Coding

Interface Segregation Principle (ISP) adalah salah satu prinsip SOLID yang menyatakan bahwa sebuah interface tidak boleh memaksa pengembang untuk mengimplementasikan method yang tidak mereka butuhkan. Jika sebuah interface memiliki terlalu banyak metode yang tidak relevan, maka harus dipecah menjadi beberapa interface yang lebih kecil dan spesifik. Dengan menerapkan ISP, kode menjadi lebih modular, mudah dipelihara, dan fleksibel.

Artikel ini membahas secara mendalam tentang prinsip ISP dalam SOLID.

Apa Itu Prinsip SOLID?

Prinsip SOLID adalah kumpulan dari lima prinsip desain dalam pemrograman berorientasi objek (OOP) yang bertujuan untuk membuat kode menjadi lebih mudah dipelihara, diperluas, dan scalable. Prinsip ini pertama kali diperkenalkan oleh Robert C. Martin (Uncle Bob) pada awal tahun 2000-an dan menjadi landasan dalam pengembangan perangkat lunak modern.

Prinsip SOLID terdiri dari lima konsep utama:

1. Single Responsibility Principle (SRP): Setiap class harus memiliki satu tanggung jawab saja.
2. Open/Closed Principle (OCP): Kode harus terbuka untuk perluasan, tetapi tertutup untuk modifikasi.
3. Liskov Substitution Principle (LSP): Objek turunan harus bisa menggantikan objek induknya tanpa mengubah perilaku yang diharapkan.
4. Interface Segregation Principle (ISP): Tidak boleh ada paksaan untuk mengimplementasikan interface yang tidak digunakan.
5. Dependency Inversion Principle (DIP) → Ketergantungan harus diarahkan pada abstraksi, bukan pada implementasi konkret.

Mengapa Perlu Prinsip SOLID?

Mengapa sih kok perlu prinsip SOLID ini segala dalam coding menggunakan OOP? Iya dong, karena hasil codingan kita kan ke depannya tidak hanya digunakan dan dikembangkan kita sendiri? Bisa jadi codingan kita kelak akan digunakan dan dikembangkan oleh orang lain, bahkan oleh tim pengembang.

Dengan demikian perlu semacam penyamaan persepsi dan standarisasi yang disepakati bersama yang tujuan utamanya untuk memudahkan dalam pengembangan kode ke depannya, melalui sebuah prinsip tertentu.

Secara umum, beberapa alasan dan manfaat prinsip SOLID ini antara lain:

• Mengurangi ketergantungan antar komponen
• Meningkatkan fleksibilitas kode
• Mempermudah proses perbaikan dan pengembangan
• Mengurangi potensi bug dan error akibat perubahan kode
• Meningkatkan kemudahan untuk menguji (testability)

Intinya bahwa prinsip SOLID membantu developer untuk menulis kode yang lebih bersih, mudah dibaca, dan lebih mudah dikelola dalam jangka panjang.

Interface Segregation Principle (ISP)

Prinsip Interface Segregation menyatakan bahwa sebuah antarmuka (interface) tidak boleh memaksa klien untuk mengimplementasikan metode yang tidak mereka butuhkan.

Artinya, sebuah interface harus dibuat sesuai kebutuhan klien dengan metode yang relevan saja, sehingga klien tidak dibebani dengan metode yang tidak mereka butuhkan.

Jika sebuah interface memiliki terlalu banyak method yang tidak relevan bagi pengembang, maka:

• Akan muncul method kosong pada implementasi klien.
• Jika ada perubahan pada method yang tidak digunakan, codingan pengembang bisa ikut terdampak.
• Kode menjadi sulit untuk dipelihara karena pengembang dipaksa mematuhi kontrak yang tidak diperlukan (efek penggunaan interface).

Contoh Kode yang Salah (Pelanggaran ISP)

Berikut adalah contoh kasus pelanggaran Interface Segregation Principle dalam Java dan Python:

Java – Interface Terlalu Luas Cakupannya

// Interface yang melanggar ISP karena terlalu besar
interface Pekerjan {
    void kerja();
    void makan();
}

class Robot implements Pekerja {
    @Override
    public void kerja() {
        System.out.println("Robot sedang bekerja");
    }

    @Override
    public void makan() {
        // Robot tidak perlu makan, tetapi terpaksa mengimplementasikan metode ini
        throw new UnsupportedOperationException("Robot tidak makan");
    }
}

Python – Interface Terlalu Luas Cakupannya

from abc import ABC, abstractmethod

class Pekerja(ABC):
    @abstractmethod
    def kerja(self):
        pass
    
    @abstractmethod
    def makan(self):
        pass

class Robot(Pekerja):
    def kerja(self):
        print("Robot sedang bekerja")
    
    def makan(self):
        raise NotImplementedError("Robot tidak makan")

Pada contoh di atas, class Robot terpaksa mengimplementasikan metode makan() meskipun robot tidak memiliki kemampuan untuk makan. Ini adalah pelanggaran ISP karena Robot dipaksa untuk mengikuti kontrak yang tidak diperlukan.

Contoh Kode yang Benar (Mengikuti ISP)

Untuk memperbaiki pelanggaran ISP, kita bisa memisahkan interface menjadi antarmuka yang lebih kecil dan spesifik.

Java – Interface yang Dipisah

// Interface yang terpisah sesuai tanggung jawab
interface DapatBekerja {
    void kerja();
}

interface DapatMakan {
    void makan();
}

class Manusia implements DapatBekerja, DapatMakan {
    @Override
    public void kerja() {
        System.out.println("Manusia sedang bekerja");
    }

    @Override
    public void makan() {
        System.out.println("Manusia sedang makan");
    }
}

class Robot implements DapatBekerja {
    @Override
    public void kerja() {
        System.out.println("Robot sedang bekerja");
    }
}

Python – Interface yang Dipisah

from abc import ABC, abstractmethod

class DapatBekerja(ABC):
    @abstractmethod
    def kerja(self):
        pass

class DapatMakan(ABC):
    @abstractmethod
    def makan(self):
        pass

class Manusia(DapatBekerja, DapatMakan):
    def kerja(self):
        print("Manusia sedang bekerja")

    def makan(self):
        print("Manusia sedang makan")

class Robot(DapatBekerja):
    def work(self):
        print("Robot sedang bekerja")

Dengan memisahkan interface menjadi DapatBekerja dan DapatMakan, setiap class hanya perlu mengimplementasikan metode yang relevan dengan kebutuhannya. Sehingga, Robot hanya mengimplementasikan Workable, sehingga tidak ada implementasi metode yang tidak perlu.

Strategi Implementasi ISP

Untuk menerapkan Interface Segregation Principle, bisa melalui strategi berikut:

Untuk menerapkan Interface Segregation Principle (ISP) dengan efektif, pendekatan utama yang perlu dilakukan adalah dengan memecah interface berdasarkan tanggung jawab spesifik. Sebuah interface harus dirancang agar memiliki metode yang berkaitan erat satu sama lain dan tidak saling tumpang tindih. Jika sebuah interface memiliki terlalu banyak metode dengan fungsi yang tidak saling berhubungan, maka interface tersebut perlu dipecah menjadi beberapa interface yang lebih kecil dan lebih terfokus. Dengan demikian, setiap class yang mengimplementasikan interface hanya perlu menerapkan metode yang memang relevan dengan kebutuhannya.

Selain itu, penggunaan multiple inheritance atau multiple interface dapat menjadi solusi jika sebuah class memerlukan kombinasi dari beberapa tanggung jawab yang berbeda. Strategi ini memungkinkan class untuk mengimplementasikan metode dari beberapa interface tanpa terikat pada satu kontrak besar yang berisi metode yang tidak diperlukan.

Penting juga untuk memastikan bahwa tidak boleh ada pengembang yang dipaksa untuk mengimplementasikan metode yang tidak digunakan. Jika dalam implementasi ditemukan metode kosong atau berisi raise NotImplementedError, maka ini merupakan indikasi kuat bahwa interface perlu dipisah menjadi bagian yang lebih kecil dan lebih spesifik. Dengan merancang interface yang ramping dan modular, kode akan menjadi lebih fleksibel, mudah diperluas, dan lebih mudah dipelihara dalam jangka panjang.