OOP Python: Penerapan Konsep Interface

Dalam pemrograman berorientasi objek (PBO) atau object oriented programming (OOP), interface adalah sebuah konsep yang memungkinkan kita untuk mendefinisikan metode tanpa implementasinya. Interface berfungsi sebagai kontrak yang harus diimplementasikan oleh kelas yang menggunakannya.

Berdasarkan pengertian tersebut, interface ini sebenarnya mirip dengan konsep abstraksi, namun ada perbedaan dari keduanya. Konsep abstraksi hanya diterapkan pada class-class yang memiliki hubungan pewarisan (inheritance), di mana super class nya yang menjadi class abstrak. Penggunaan class abstrak dalam konsep abstraksi ini bertujuan untuk menggambarkan fitur-fitur dari super class secara umum saja, yang detil fiturnya nanti akan diimplementasikan pada subclassnya. Adapun untuk interface, penerapannya tidak harus pada class-class yang memiliki hubungan pewarisan. Tujuan dari pembuatan class abstrak dalam interface ini adalah untuk menggambarkan sebuah fitur secara umum. Fitur ini nanti bisa diterapkan pada class lainnya secara detil.

Selain itu dalam konsep abstraksi, sebuah subclass hanya boleh terlibat kontrak dengan sebuah class abstrak yang menjadi super classnya. Adapun untuk interface, sebuah class dapat terlibat kontrak dengan beberapa class abstrak.

Bagaimana penerapan interface di Python? akan dibahas tuntas melalui artikel ini.

Apa Manfaat Penggunaan Interface?

Untuk melihat gambaran apa sih sebenarnya manfaat dari interface, perhatikan contoh sederhana berikut ini.

Misalkan kita ingin membuat sistem yang mengatur perangkat elektronik. Setiap perangkat elektronik ada yang memiliki kemampuan untuk dihidupkan dan dimatikan. Dalam hal ini kita bisa membuat interface bernama Switchable. Selain itu ada beberapa perangkat juga memiliki fitur volume yang bisa diatur. Sehingga dalam hal ini kita bisa juga membuat interface bernama Adjustable.

Kemudian misalnya kita ingin membuat class TV yang bisa dihidupkan dan dimatikan (mewarisi fitur Switchable), dan yang bisa dinaikkan atau diturunkan volumenya (mewarisi Adjustable).

Berdasarkan hal tersebut, misalkan kita buatkan codingannya sebagai berikut:

from abc import ABC, abstractmethod

# Interface pertama: Switchable
class Switchable(ABC):
    @abstractmethod
    def turn_on(self):
        pass
    
    @abstractmethod
    def turn_off(self):
        pass

# Interface kedua: Adjustable
class Adjustable(ABC):
    @abstractmethod
    def increase_volume(self):
        pass
    
    @abstractmethod
    def decrease_volume(self):
        pass

# Subclass TV yang mewarisi dari kedua interface
class TV(Switchable, Adjustable):
    def __init__(self):
        self.is_on = False
        self.volume = 10
    
    def turn_on(self):
        if not self.is_on:
            self.is_on = True
            print("TV is now ON")
        else:
            print("TV is already ON")

    def turn_off(self):
        if self.is_on:
            self.is_on = False
            print("TV is now OFF")
        else:
            print("TV is already OFF")

    def increase_volume(self):
        if self.is_on:
            self.volume += 1
            print(f"Volume increased to {self.volume}")
        else:
            print("Cannot adjust volume. TV is OFF")

    def decrease_volume(self):
        if self.is_on:
            self.volume -= 1
            print(f"Volume decreased to {self.volume}")
        else:
            print("Cannot adjust volume. TV is OFF")

# Membuat objek TV dan menguji fungsionalitas
tv = TV()

# Menghidupkan TV
tv.turn_on()  # Output: TV is now ON

# Menaikkan volume
tv.increase_volume()  # Output: Volume increased to 11

# Menurunkan volume
tv.decrease_volume()  # Output: Volume decreased to 10

# Mematikan TV
tv.turn_off()  # Output: TV is now OFF

# Mencoba menaikkan volume saat TV mati
tv.increase_volume()  # Output: Cannot adjust volume. TV is OFF

Perhatikan baris ke 24, di mana menunjukkan bahwa class TV menggunakan class abstrak Switchable dan Adjustable. Sehingga konsekuensinya, di dalam class TV harus mengimplementasikan semua method abstrak yang dimiliki oleh kedua class abstrak tersebut (perhatikan baris: 29, 36, 43, 50).

Langkah Penerapan Interface di Python

Meskipun di dalam Python tidak ada fitur bawaan yang mendukung konsep interface (tidak seperti bahasa Java), namun dalam praktiknya untuk menerapkan interface ini caranya sama dengan ketika menerapkan abstraksi, yaitu menggunakan module ABC (Abstract Base Class) seperti yang dicontohkan pada script di atas.

Inilah yang menjadi kelebihan dari Python, hanya dengan menggunakan module ABC kita bisa menerapkan konsep abstraksi dan interface secara sekaligus. Namun kekurangannya adalah dengan menerapkan module ABC ini, kita agak kesulitan dalam melacak struktur class, mana yang merupakan super class dan subclass, atau mana class yang menerapkan interface, ini disebabkan karena struktur codingnya sama persis 😀