Apa Itu OOP??

Tinggalkan Komentar / Uncategorized / Oleh
Halo, selamat datang di Bony3D!

Sebelum kita membahas tentang OOP (Object Oriented Programming), sebaiknya kita memahami konsep dasar dari OOP itu sendiri. Pada bahasa Indonesia, penyusunan kalimat dikenal sebagai Subjek + Predikat + Objek. Seperti pada contoh, Saya minum es coklat. Es Coklat merupakan objek dalam kalimat ini dan dalam OOP, es coklat didefinisikan sebagai program. Objek yang dalam hal ini adalah es coklat memiliki berbagai macam jenis, seperti harganya, produksinya, dan proporsinya.

Secara singkat, OOP adalah metode programming dengan tujuan mempermudah pekerjaan programmer. OOP hanya fokus dan berorientasi pada objek. Lalu mengapa OOP penting untuk dipahami? Karena dengan OOP, para programmer dimudahkan dalam mengembangkan kode, mengubah implementasi objek tanpa harus mengubah data, membentuk metode umum untuk objek lain tanpa harus menulis ulang, mengembangkan 1 jenis data dan menjadikan 1 fungsi ke fungsi lainnya tanpa harus mengganti data, dan hanya dengan OOP, bisa memiliki fungsi beragam yang diterapkan di berbagai data. Pada artikel ini, saya akan membahas lebih detail mengenai konsep dasar OOP, 3 prinsip yang paling sering digunakan, kelebihan, serta kekurangan OOP itu sendiri.

Dalam memprogram suatu kodingan, kita pasti menyertakan beberapa fungsi di dalamnya, karena setiap fungsi memiliki tujuan yang berbeda dan fungsi tersebut tidak bisa di satukan karena mereka berbeda. Ada 2 cara menyatukan beberapa fungsi, pertama dengan memisahkannya per-file atau dengan cara yang kedua yaitu dibuat objek. Cara yang paling efektif adalah membuatnya menjadi objek karena tugas kita sebagai programmer hanya perlu import 1 class tanpa harus mengulang 1 per 1 fungsinya. Sebagai contoh:

professor = 'amanda'
def professor_minum():
print('{} minum es coklat'.format(professor)) petani = 'ani'
def petani_minum():
print('{} minum es coklat'.format(petani))
dokter = 'sandy'
def dokter_minum():
print('{} minum es coklat'.format(dokter))
professor_minum()
petani_minum()
 dokter_minum()

Hasil:

Amanda minum es coklat
ani minum es coklat
dokter minum es coklat

Masalah yang dihadapi para programmer ialah harus mengulang kodingan padahal keterangannya sama. Contohnya saya membuat keterangan bahwa Amanda, Ani, dan Sandy minum es coklat. Biasanya programmer membuat kodingan untuk setiap nama, namun cara ini tidak efektif. Bagaimana jika data yang kita miliki berjumlah ratusan? Maka solusinya adalah membuatnya menjadi objek.

Sebagai contoh: Amanda, Ani, dan Sandy minum es coklat. Hal yang perlu diperhatikan adalah "Apa yang sama?" Mereka adalah manusia, memiliki nama, dan bisa minum. Jadi, manusia, nama, dan minum adalah objeknya. Langkah pertama yang dilakukan adalah membuat rancangannya dulu, kelasnya, atau dalam bahasa teknik sipil ialah denah rumahnya. Setelah jadi class-nya maka itu yang disebut dengan objek.

Sekarang, masuk ke pembahasan class, class umum yaitu manusia, memiliki nama, fungsi (minum), dan profesi. Minum hanya bisa dipanggil setelah ada objeknya yaitu nama dan nama baru bisa dipanggil ketika ada kelas umumnya yaitu manusia.
class Manusia (object):
nama = None
def minum(self):
print('{} minum es coklat'.format((self.nama)) )
professor = Manusia()
professor.miunun()

Hasil:

none minum es coklat

Dalan kodingan ini, masih belum ada namanya. Lalu, bagaimana cara menyimpan nama? Konstruktor adalah jawaban terbaik untuk hal ini, karena setiap membuat objek maka otomatis membuat nama. Seperti contoh:

class Manusia (object):
nama = None
def _ _ init__(self, nama)
self.nama = nama
def minum(self):
print('{} minum es coklat'.format((self.nama)) )
professor = Manusia('amanda')
professor.miunun()
petani = Manusia('ani')
petani.miunun()
dokter = Manusia('sandy')  
dokter.miunun()

Hasil:
Amanda minum es coklat
ani minum es coklat
dokter minum es coklat

Pada hasil kodingan ini, bisa dilihat bahwa nama bisa langsung tercantum dan sama seperti hasil kodingan sebelumnya namun dengan menggunakan OOP maka tidak perlu mengulang 1 per 1 kodingan untuk keterangan yang sama.
Setelah kita mengetahui dasar dari OOP maka selanjutnya ada 3 prinsip yang digunakan dalam OOP. Pertama, inheritance. Bisa diartikan sebagai turunan atau mewariskan dari kelas utama tapi dengan menambahkan fungsi lain. Contohnya di kelas utama kita memiliki fungsi minum, maka di prinsip inheritance kita menambahkan email dan pastinya dengan menggunakan kode baru. Sebagai contoh:

class Manusia (object):
nama = None
def _ _ init__(self, nama)
self.nama = nama
def minum(self):
print('{} minum es coklat'.format((self.nama)) )
class ManusiaMilenial (object):
nama = None
email = None
def _ _ init__(self, nama)
self.nama = nama
def minum(self):
print('{} minum es coklat'.format((self.nama)) )
def Set.email(self, email):
self.email = email
professor = ManusiaMilenial('amanda')
professor.Set_email('amanda@test.com')
professor.miunun()
petani = ManusiaMilenial('ani')
petani.Set_email('ani@test.com')
petani.miunun()
dokter = ManusiaMilenial('sandy')
dokter.Set_email('sandy@test.com')  
dokter.miunun()

Hasil:
Amanda minum es coklat
ani minum es coklat
dokter minum es coklat

Hasilnya akan sama. Kelas ini disebut subclass dari kelas manusia atau turunan dari kelas manusia. Manusia milenial adalah anak kelas dari kelas utama "manusia." Secara singkat, apapun yang dimiliki kelas utama juga akan dimiliki kelas turunan. Menggunakan prinsip inheritance ini, kode jadi lebih sederhana dan para programmer hanya perlu menambahkan apa yang belum ada di kelas utama. Menambahkan fungsi baru di kelas turunan tidak akan mengurangi fungsi asli dari kelas utama. Sebagai contoh:

class Manusia (object):
nama = None
def _ _ init__(self, nama)
self.nama = nama
def minum(self):
print('{} minum es coklat'.format((self.nama)) )
class ManusiaMilenial (Manusia):
email = None
def Set.email(self, email):
self.email = email
def info(self):
print('nama = {}, email = {}' .format(self.nama, self.email))

professor = ManusiaMilenial('amanda')
professor.Set_email('amanda@test.com')
professor.info()

petani = ManusiaMilenial('ani')
petani.Set_email('ani@test.com')
petani.info()
dokter = ManusiaMilenial('sandy')
dokter.Set_email('sandy@test.com')    
dokter.info()

Hasil:
nama = amanda, email = amanda@test.com
nama = ani, email = ani@test.com
nama = sandy, email = sandy@test.com

Kesimpulannya pada prinsip inheritance ini, kita membuat kelas turunan dari kelas sebelumnya dengan jumlah kelas turunan tak terbatas serta kita bisa menambahkan fungsi baru dari fungsi asli yang dimiliki.
Prinsip kedua dari OOP ialah encapsulation. Secara sederhana konsep dari prinsip ini adalah membungkus semua hal yang ada di dalam kelas (email, self email, info, dan self password) tapi hanya mengizinkan akses untuk hal-hal tertentu saja. Seperti contoh:

professor = ManusiaMilenial('amanda')
professor.Set_email('amanda@test.com')
print (professor.email)

Hasil:
amanda@test.com

Disini saya mengatur email aksesnya dibuka untuk semua orang atau publik. Namun bagaimana jika saya ingin membuatnya menjadi privat? Maka saya hanya perlu menambahkan 2 underscore didepan objek-nya semisal password. Dengan cara ini, password akan menjadi privat dan hanya bisa diakses dari info tapi tidak bisa diperlihatkan secara terang-terangan. Selanjutnya bagaimana membuat agar fungsi privat bisa dilihat secara samar-samar oleh orang dalam? Berikut adalah kodingan untuk membuat password privat dan disamarkan.

class Manusia (object):
nama = None
def _init_(self, nama)
self.nama = nama
def minum(self):
print('{} minum es coklat'.format((self.nama)) )
class ManusiaMilenial (Manusia):
email = None
__password = None
def Set.email(self, email):
self.email = email
def Set.pass(self, password):
self.__password = password
def __samarkan_password(self):
return self.__password.replace('a', '*')
def info(self):
print('nama = {}, email = {}, pass = {}' .format(self.nama, self.email, self.__samarkan_password))
professor = ManusiaMilenial('amanda')
professor.Set_email('amanda@test.com')
professor.pass('rahasia')
professor.info()
print (professor.email)
Hasil:
nama = amanda, email = amanda@test.com, pass = r*h*si*

Menggunakan fungsi samar ini, fungsi tidak akan bisa dipanggil oleh orang dari luar kelas dan tidak bisa dimodifikasi
Prinsip ketiga yang sering digunakan dalam OOP ialah polymorphism. Prinsip ini mengartikan bahwa walaupun kelas utamanya sama, kelas turunannya bisa berbagai bentuk. Seperti contoh, kelas utama memiliki fungsi minum, kelas turunan memiliki fungsi minum dan email. Kelas baru dari kelas turunan disebut subclass. Misalnya subclass dari kelas turunan (manusia milenial). Subclass tidak bisa akses samarkan password kecuali sudah diizinkan. Berikut adalah contoh kodingan dari subclass manusia milenial.

class Manusia (object):
nama = None
def _init_(self, nama)
self.nama = nama
def minum(self):
print('{} minum es coklat'.format((self.nama)) )
class ManusiaMilenial (Manusia):
email = None
__password = None
def Set.email(self, email):
self.email = email
def Set.pass(self, password):
self.__password = password
def __samarkan_password(self):
return self.__password.replace('a', '*')
def info(self):
print('nama = {}, email = {}, pass = {}' .format(self.nama, self.email, self.__samarkan_password))
class professor(ManusiaMilenial):
def info(self):
print('nama = {}/email = {}' .format(self.nama, self.email))
class konsultan(ManusiaMilenial):
def info(self):
print('nama = {}:email = {}' .format(self.nama, self.email))
professor = ManusiaMilenial('amanda')
professor.Set_email('amanda@test.com')
professor.pass('rahasia')
professor.info()
konsultan = ManusiaMilenial('ani')
konsultan.Set_email('ani@test.com')
konsultan.pass('abc123')
konsultan.info()

Hasil:
nama = amanda/email = amanda@test.com
nama = sandy:email = sandy@test.com

Dengan prinsip ini, kita bisa mengubah fungsi jadi hal lain atau menghapusnya. Semisal saya menghilangkan samarkan password, mengganti koma menjadi garis miring atau titik dua. Prinsip ini juga bisa digunakan untuk 2 fungsi dengan nama sama namun parameternya berbeda, seperti:

class professor(ManusiaMilenial):
def info(self):
print('nama = {}/email = {}' .format(self.nama, self.email))
def info(self, data):
print('nama = {}/email = {}, {}' .format(self.nama, self.email))

Jadi itulah gambaran singkat mengenai apa itu OOP, nah sekarang jadi semakin paham kan? Oh iya sebelum ditutup ada baiknya mengetahui apa kelebihan dan kekurangan dari OOP. Kelebihannya, dengan menggunakan OOP masing-masing programmer bisa membangun kelas individual dan komponen dapat menjadi 1 kesatuan, kelas dapat digunakan kembali tanpa harus membuat kode ulang, dan data menjadi lebih mudah diakses ketika dibutuhkan. Kekurangan OOP sendiri diantaranya menggunakan tenaga CPU yang lebih besar serta harus cermat dalam mengontrolnya karena OOP akan membuat sendiri program yang akan membebani komputer. Jadi harus tetap cermat ya dalam menggunakannya:)
Referensi: Redaksi Jagoan Hosting (2023, 19 Januari). Pengertian OOP (Object Oriented Programming) dan 4 Prinsipnya. Blog Jagoan Hosting. https://www.jagoanhosting.com/blog/oop-adalah/

Tinggalkan Komentar

Alamat email Anda tidak akan dipublikasikan. Ruas yang wajib ditandai *

Keranjang Belanja