OOP Python: Teknik Overloading

Di dalam Object Oriented Programming (OOP), tentu tidak asing dengan istilah overloading. Fitur yang menarik ini dapat diimplementasikan dalam bahasa pemrograman Java dan C++.

Bagaimana dengan Python? Bisakah overloading diterapkan juga di Python? Bagaimanakah caranya? Melalui artikel ini akan dibahas mengenai hal tersebut.

Pengertian Overloading

Overloading adalah konsep dalam OOP di mana sebuah kelas dapat memiliki beberapa method dengan nama yang sama tetapi dengan parameter yang berbeda. Keuntungan dari overloading ini adalah kita bisa membuat sebuah method yang bisa menangani beberapa variasi jumlah parameter.

Overloading di Python

Dalam Python, secara teori kita tidak bisa membuat beberapa method yang sama dengan parameter yang berbeda secara sekaligus. Perhatikan contoh berikut ini.

class Penjumlahan:
    
    # method hasil() dengan 2 parameter
    def hasil(self, bil1, bil2):
        print(bil1 + bil2)

    # method hasil() dengan 3 parameter
    def hasil(self, bil1, bil2, bil3):
        print(bil1 + bil2 + bil3)

Pada contoh di atas, kita mencoba membuat sebuah class Penjumlahan yang memiliki dua buah method hasil(). Method ini nantinya diharapkan dapat menghitung hasil penjumlahan semua parameternya. Kita mencoba menerapkan overloading untuk method hasil() ini dengan dua bentuk variasi parameter yang berbeda, yaitu dengan 2 parameter dan 3 parameter.

Selanjutnya apabila kita mencoba membuat sebuah obyek kemudian memanggil hasil() sebagai berikut:

# membuat instance atau obyek 'coba' dari class Penjumlahan
coba = Penjumlahan()

# memanggil method hasil() dari obyek 'coba'
coba.hasil(3, 4)

maka akan muncul pesan error:

hasil() missing 1 required positional argument: 'bil3'

Pesan error tersebut muncul karena method hasil() dianggap memiliki 3 buah parameter. Sedangkan method hasil() dengan 2 parameter yang sudah didefinisikan di atasnya diabaikan.

Sehingga apabila kita ingin menerapkan overloading di Python dengan teknik di atas, maka tidaklah bisa.

Meskipun tidak mendukung overloading secara langsung seperti bahasa pemrograman lain seperti C++ atau Java, tetapi kita masih bisa membuat efek overloading menggunakan sebuah trik. Paling tidak, terdapat dua buah trik yang bisa kita lakukan.

Trik menggunakan variabel *args

Dalam Python, *args adalah sebuah parameter khusus yang digunakan dalam pendefinisian fungsi atau method. Istilah args adalah singkatan dari “arguments” (argumen). Parameter *args memungkinkan sebuah fungsi atau method untuk menerima sejumlah argumen posisional yang tidak terbatas dalam bentuk tuple.

Berikut ini class Penjumlahan yang sudah dimodifikasi supaya memiliki efek seperti overloading menggunakan *args.

class Penjumlahan:
    
    # method hasil() dengan variasi parameter
    def hasil(self, *args):
        sum = 0
        for num in args:
            sum += num
        print(sum)

Agak sedikit berbeda dengan sebelumnya, untuk mendapatkan hasil pejumlahan nilai parameternya, kita gunakan perulangan for. Secara satu persatu nilai parameter dijumlahkan dalam perulangan tersebut.

Dengan menggunakan *args, method hasil() dapat menangani berapapun banyaknya parameter yang diberikan. Misalnya:

coba = Penjumlahan()

coba.hasil(1, 2)              # output: 3
coba.hasil(1, 2, 3)           # output: 6
coba.hasil(1, 2, 3, 4)        # output: 10

Selanjutnya bagaimana jika kita ingin membatasi banyaknya argumen? misalnya dalam kasus di atas kita hanya ingin maksimal banyaknya argumen adalah 4. Caranya kita batasi dengan menghitung banyaknya argumen dengan fungsi len().

class Penjumlahan:
    
    # method hasil() dengan variasi parameter
    def hasil(self, *args):
        if (len(args) <= 4):
            sum = 0
            for num in args:
                sum += num
            print(sum)
        else:
            print("Maksimum 4 argumen")

Berikut ini adalah beberapa output untuk beberapa macam variasi jumlah parameter.

coba = Penjumlahan()

coba.hasil(1, 2)              # output: 3
coba.hasil(1, 2, 3)           # output: 6
coba.hasil(1, 2, 3, 4)        # output: 10
coba.hasil(1, 2, 3, 4, 5)     # output: Maksimum 4 argumen

Trik Menggunakan Default Parameter

Trik kedua yang bisa dilakukan adalah menggunakan default parameter yang lebih mudah diimplementasikan dibandingkan sebelumnya. Ide dari trik ini adalah menjadikan parameter yang sifatnya opsional dengan memberinya nilai default.

Perhatikan kembali contoh class Penjumlahan di atas. Misalkan kita tetap menginginkan supaya method hasil() bisa menangani dua sampai dengan empat buah parameter. Dengan trik ke dua ini, cukup kita jadikan parameter ke tiga dan empatnya memiliki default nilai parameter.

class Penjumlahan:
    
    # method hasil() dengan variasi parameter
    def hasil(self, num1, num2, num3=0, num4=0):
       print(num1 + num2 + num3 + num4) 

Pada contoh di atas, parameter num3 dan num4 diberi nilai default 0. Artinya jika num3 dan num4 tidak disertakan dalam pemanggilan method hasil() maka keduanya diberi nilai 0. Sehingga apabila dipanggil perintah berikut ini, akan dihasilkan output yang sama seperti sebelumnya.

coba = Penjumlahan()

coba.hasil(1, 2)              # output: 3
coba.hasil(1, 2, 3)           # output: 6
coba.hasil(1, 2, 3, 4)        # output: 10

Kesimpulan

Mudah bukan membuat overloading method di OOP Python? Dari penjelasan di atas dapat kita simpulkan bahwa teknik overloading di OOP Python berbeda implementasinya dengan bahasa pemrograman lain. Hal ini disebabkan kita tidak bisa membuat beberapa method dengan nama yang sama untuk jumlah parameter yang berbeda dalam sebuah class. Sebagai solusinya, kita bisa menggunakan dua cara, yaitu dengan menggunakan variabel *args, atau menggunakan default parameter.

Semoga artikel ini mudah dipahami dan bermanfaat. Salam coding!! 😀