Revisi OOP

Object-oriented programming (OOP) adalah sebuah pendekatan dalam pengaturcaraan yang menjadikan objek sebagai rujukan akses kepada metod (fungsi) tertentu. Dalam Python, OOP diprogram menggunakan katakunci Class.

Dalam Class, anda boleh rangkumkan beberapa metod atau operasi yang mempunyai perkatainan antara satu sama lain. Misalanya jika kita mencipta Class operasi matematik, dalam Class tersebut seharusnua terdapat metod penambahan, penolakan, pembahagian dan lain-lain lagi, bergantung kepada pengaturcara itu sendiri. Anda juga boleh mencipta atribut (seperti pemboleh ubah jika diluar Class) yang dapat digunakan oleh metod Class tersebut.

Dalam membangunakan OOP, terdapat beberapa konsep atau pendekatan tertentu yang biasa dipraktikkan.

Antara pendekatan yang biasa digunakan adalah:

1. Perwarisan (Inheritance)

2. Pengkapsulan (Encapsulation)

3. Polimorphism (Polymorphism)

Nota:

Jika anda belum terbiasa dengan konsep OOP, penulis menyarankan anda untuk berkenalan dengan OOP dahulu sebelum meneruskan pembacaan artikel ini.

Perwarisan

Seperti namanya, perwarisan boleh dianalogikan seperti ibubapa yang mewariskan genetik mereka pada si anak.

Dalam konteks Python, terdapat Class ibubapa dan Class anak.

Class anak akan mewarisi Class ibu bapa, seperti mana anak yang mewarisi ciri ibu bapanya.

Mari kita lihat bagaimana caranya untuk menggunakan Perwarisan dalam Class.

class Animal:
    def __init__(self, height, animal_type):
        self.size = height
        self.animal_type = animal_type

    def get_height(self):
        print(self.height)

    def get_animal_type(self):
        print(self.animal_type)

# perwarisan
class ExtendAnimal(Animal):
    def init(self, height, weight, animal_type, movement):
        self.height = height
        self.weight = weight
        self.animal_type = animal_type
        self.movement = movement
    def get_height_weight(self):
        self.get_height()
        print(self.weight) # extension
    def get_type_movement(self):
        self.get_animal_type()
        print(self.movement) # extension


fish = ExtendAnimal(5, 10, 'Amphibian', 'Swimming')
fish.get_height_weight()
fish.get_type_movement()

Output:
5
10
Amphibian
Swimming

Contoh kod diatas adalah contoh perwarisan Class.

Class yang pertama iaitu Animal adalah Class yang memaparkan ciri haiwan iaitu height dan animal_type.

Class yang kedua iaitu ExtendAnimal telah mewarisi (class ExtendAnimal(Animal)) daripada Class yang pertama dan telah menambah keupayaan Class pertama jika dilihat pada metodnya.

Kita dapat melihat bagaimana Perwarisan dapat menambah lagi fungsi Class pada metod get_height_weight()yang mengeluarkan output height yang diwariskan daripada Class Animal. Metod ini juga adalah extension daripada metod get_height daripada class Animal yang mana ia mengoutput weight dalam masa yang sama.

Dengan mewarisi Class ibubapa, Class anak mempunyai keupayaan tertentu hasil daripada perwarisan tadi. Antaranya;

1. Class anak mempunyai ciri yang sama daripada Class ibu bapa.

2. Class anak boleh ditambah kemampuan kegunaan metodnya.

3. Class anak boleh dikemasikini (*update*) tanpa mengganggu kod asal daripada Class ibubapa.

4. Atribut dan method dalam Class anak boleh mengatasi (*override*) Class ibubapa.

5. Class ibubapa boleh berkongsi atribut kepada Class anak.

6. Mencipta heirarki Class berturutan daripada Class ibubapa kepada Class anak.

Jadi apa kebaikan jika kita menggunakan pendekatan ini?

1. Pengaturcara mampu menambah baik kod asal tanpa mengubahsuai struktur kod tersebut.

2. Class anak boleh mewarisi keseluruhan ciri Class ibubapa, atau mewarisi sebahagian sahaja daripada ciri Class ibubapa. Ini memberi kawalan yang baik kepada pengaturcara untuk menambah baik Class ibubapa dengan had tertentu.

Pengkapsulan

Pengkapsulan adalah sebuah pendekatan dimana metod-metod dirangkumkan dalam satu unit.

Penggunaan Class dalam Python itu sendiri adalah sebuah pengkapsulan.

Pengkapsulan dapat menyekat akses kepada atribut dan metod dalam Class (underscore variable dan penggunaan metod yang hanya diketahui oleh pencipta kod tersebut) yang dapat mengelakkan daripada data diubahsuai daripada kod atau pengguna luar.

Andaikan anda ingin mencipta sebuah Class yang mengandungi maklumat rahsia ejen peribadi. Tentu sahaja anda tidak mahu informasi ini dimanipulasi atau diubahsuai oleh kod atau pengguna luar.

Maka untuk menjadikan atribut tersebut peribadi, gunakan 2 underscore seperti kod dibawah;

class ClassifiedInfo:
    def init(self, name, height, weight, country, gender):
        self.name = name
        self.__height = height
        self.__weight = weight
        self.__country = country
        self.__gender = gender
    def get_agent_information(self):
        print(f'{self.name} information:\
        \nGender: {self.__gender}, \
        \nCountry: {self.__country},')
    def get_agent_height(self):
        print(f'Height: {self.__height}')

agent_1 = ClassifiedInfo("Jack", 178, 89, "Brazil", "Male")\
agent_1.get_agent_information()
agent_1.__height

Output:

Jack information:
Gender: Male,
Country: Brazil,
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[34], line 20
17 agent_1 = ClassifiedInfo("Jack", 78, 189, "Brazil", "Male")\
19 agent_1.get_agent_information()
---> 20 agent_1.__height
AttributeError: 'ClassifiedInfo' object has no attribute '__height'

Jika diperhatikan, output daripada agent_1.__height adalah ralat atribut. Ini bermakna maklumat height tidak mampu diakses sewenenang-wenangnya.

Dengan menggunakan dua underscore, ia boleh melindungi atribut dalam Class daripada dimanipulasi oleh kod atau pengguna luar.

Jadi bagaimana caranya untuk mengakses atribut peribadi ini? Dengan mencipta metod yang dapat diaksesnya. Dalam kod diatas, penulis telah mencipta sebuah metod get_agent_height yang mana metod ini akan mengeluarkan output maklumat ketinggian agent ini.

Ini bermakna, pengguna luar tidak berupaya untuk mengakses atribut peribadi dalam sesebuah kod, dan hanya pembangun kod sahaja yang mampu mengakses data tersebut dengan menggunakan metod yang dia ciptakan.

Dalam kod diatas, penulis telah mencipta metod get_agent_height() untuk mengakses maklumat atribut height .

# mengakses atribut peribadi
agent_1.get_agent_height()

Output:

Height: 178

Maklumat height telah berjaya diakses.

Kebaikan menggunakan pengkapsulan adalah;

1. Punca ralat dapat dikenalpasti dengan merujuk nama Class dan metod.

2. Pengaturcara dapat melindungi data tertentu daripada diubahsuai oleh pengguna luar.

Polimorfism

Polimorfism berasal daripada bahasa Greek, bermakna sesuatu yang wujud dalam bentuk (morfo) yang pelbagai (poli).

Dalam konteks OOP, Class akan yang sama akan dicipta dalam pelbagai bentuk.

Konsep polimorfism telah digunakapakai secara meluas dalam pengaturcaraan. Antara contoh polimorfism dalam Python adalah simbol tambah (+) itu sendiri.

# penambahan nombor
value_a = 12
value_b = 5
print(a+b)
# penggabungan string
string_1 = “Hello”
space = “ “
string_2 = “World!”
print( string_1 + space + string_2)

Output:
17
Hello World!

Dalam Python, jika simbol tambah digunakan pada nombor (interger), ia akan menambahkan nilai nombor tersebut. Manakala jika digunakan pada perkataan (string), perkataan tersebut akan digabungkan. Maka simbol tambah ini bergantung kepada input apa yang diberikan. Ia simbol yang sama, tapi boleh wujud dalam kegunaan berbeza.

Mari kita lihat bagaimana anda boleh mengaplikasikan polimorfism pada Class dalam Python.

class Jack:
def init(self, age, gender, address):
    self.age = age
    self.gender  = gender
    self.address = address

    def get_age(self):
        print(f'Age: {self.age}')

    def get_gender(self):
        print(f'Gender: {self.gender}')

    def get_address(self):
        print(f'Address: {self.address}')

class Jenny:
    def __init__(self, age, gender, address):
        self.age = age
        self.gender  = gender
        self.address = address

    def get_age(self):
        print(f'Age: {self.age}')

    def get_gender(self):
        print(f'Gender: {self.gender}')

    def get_address(self):
        print(f'Address: {self.address}')

jack = Jack(19, 'male','USA')
jenny = Jenny(21, 'female', 'Colombia')

Dalam kod diatas, Class Jack and Jenny mempunyai struktur yang sama; dengan nama metod yang sama tetapi bentuk (nama Class) yang berbeza. Ini adalah konsep polimorfism.

Daripada objek diatas, anda boleh menggunakan kesemua metod untuk mendapatkan output dengan cara berikut:

1. Menggunakan for loop

for info in (jack, jenny):
    info.get_age()
    info.get_gender()
    info.get_address()

1. atau; Menggunakan class atau function lain

class Extract:
    def get_info(self, object_class):
        object_class.get_age()
        object_class.get_gender()
        object_class.get_address()

extract = Extract()
extract.get_info(jack)
extract.get_info(jenny)

Kedua dua cara di atas akan menghasilkan output yang sama.

Output:

Age: 19
Gender: male
Address: USA
Age: 21
Gender: female
Address: Colombia

Gabungan konsep

Ketiga-tiga pendekatan diatas boleh digunakan secara bersendirian. Namun ini tidak bermakna kita tidak boleh menggabungkannya ataupun menggunakan satu pendekatan untuk mencipta pendekatan yang lain.

Contohnya:

1. Perwarisan dan Polimorfism boleh digunakan untuk mencipta class yang mampu untuk overriding atribut dari Class sebelumnya.

2. Dalam pengkapsulan boleh ada sebuah perwarisan (antara subclass)

Penutup

Bentuk-bentuk ini bergantung kepada kesesuaian keadaan dan bagaimana seorang pengaturcara untuk menyelesaikan masalah yang dihadapinya semasa membangunakan sesebuah kod.

Idea untuk menentukan pendekatan yang mana lebih baik tidak hadir dalam masa yang singkat. Pengalaman yang ditambah secara konsisten dalam pengaturcaraan dan kaedah cubajaya dapat membantu pengaturcara untuk menentukan konsep yang terbaik.

Sampai disini sahaja artikel kali ini. Jangan lupa untuk cipta Class anda selepas ini menggunakan konsep-konsep diatas. Jika terdapat kekeliruan ataupun persoalan atau penambahbaikan, penulis mengalu-alukan komen pembaca pada ruangan dibawah.

Sampai jumpa, salam!