Coba perhatikan kamar kalian sendiri. Ada yang rapi banget — baju di lemari, buku di rak, kabel-kabel dikelompokkan dalam kotak kecil. Ada juga yang isinya numpuk begitu saja di lantai, campur aduk antara baju kotor, charger, dan sisa makanan ringan. Dua-duanya sama-sama "berfungsi" — barangnya tetap ada di kamar itu — tapi jelas satu jauh lebih mudah diurus daripada yang lain.

Ternyata, cara kita menulis kode program juga punya masalah yang sama. Ada pendekatan yang menyusun semuanya secara berurutan seperti daftar tugas panjang, dan ada pendekatan yang mengelompokkan data serta perilakunya jadi satu paket rapi. Yang pertama disebut pemrograman terstruktur, yang kedua disebut pemrograman berorientasi objek (OOP). Artikel ini akan membahas keduanya, plus empat konsep inti OOP yang wajib kalian kuasai: class, object, atribut, metode, enkapsulasi, dan inheritance.

Pemrograman Terstruktur: Titik Awal Semua Programmer

Pemrograman terstruktur adalah paradigma yang menyusun program secara berurutan (sequence), memecah proses menjadi fungsi atau prosedur, dan dijalankan dari atas ke bawah (top-down). Ini biasanya paradigma pertama yang dipelajari programmer pemula — termasuk kalian di semester-semester awal.

Ciri-ciri utamanya:

Alur eksekusi berurutan, baris demi baris. Program dipecah menjadi fungsi atau prosedur yang masing-masing mengerjakan satu tugas spesifik. Data dan fungsi bersifat terpisah — fungsi hanya "meminjam" data lewat parameter, tidak memilikinya.

Contoh sederhana di Python:

python def hitung_luas(panjang, lebar): return panjang * lebar

def cetak_hasil(luas): print(f"Luas persegi panjang: {luas}")

program utama

p = 5 l = 3 luas = hitung_luas(p, l) cetak_hasil(luas)

Perhatikan bahwa hitung_luas() dan cetak_hasil() berdiri sendiri-sendiri. Keduanya tidak "tahu" satu sama lain, dan tidak ada yang benar-benar "memiliki" data p, l, atau luas — semua nilai itu cuma dilempar-lempar sebagai argumen.

Selama programnya kecil, ini tidak masalah. Tapi begitu aplikasi mulai membesar — katakanlah kalian membangun sistem informasi sekolah dengan ratusan fungsi — pendekatan ini mulai goyah:

Sulit dikelola untuk aplikasi besar dan kompleks. Karena data dan fungsi terpisah, kode jadi rawan error dan sulit digunakan ulang. Kurang mampu merepresentasikan objek dunia nyata — padahal dunia nyata isinya benda-benda dengan data dan perilakunya sendiri (mobil punya warna dan bisa berjalan, rekening punya saldo dan bisa menerima setoran).

Dari keterbatasan inilah OOP lahir.

Object-Oriented Programming (OOP): Menyatukan Data dan Perilaku

OOP mengorganisasi program berdasarkan objek — gabungan antara data (disebut atribut) dan perilaku (disebut metode) dalam satu kesatuan yang saling berhubungan. Alih-alih menulis fungsi yang melayang bebas, kalian membungkus data dan fungsi yang berkaitan ke dalam satu struktur bernama class.

OOP dibangun di atas empat pilar besar:

Pilar Inti Gagasan Enkapsulasi Membungkus dan melindungi data Inheritance Mewariskan struktur & perilaku antar class Polimorfisme Satu metode, banyak bentuk Abstraksi Menyembunyikan detail yang rumit

Di artikel ini kita akan fokus dulu ke enkapsulasi dan inheritance — dua pilar dasar yang jadi pondasi sebelum masuk ke polimorfisme dan abstraksi di pertemuan berikutnya.

Terstruktur vs OOP, Apa Bedanya? Aspek Pemrograman Terstruktur Pemrograman OOP Pendekatan Berbasis fungsi / prosedur Berbasis objek (data + perilaku) Struktur data Terpisah dari fungsi Menyatu dalam objek (class) Reusability Relatif rendah Tinggi, lewat inheritance Contoh bahasa C, Pascal Python, Java, C++ 3. Class dan Object: Cetakan dan Hasil Cetakannya

Dua istilah ini paling sering bikin bingung pemula, padahal analoginya sederhana:

Class adalah blueprint atau cetakan yang mendefinisikan struktur objek — atribut dan metode apa saja yang akan dimiliki. Object adalah instance, perwujudan nyata yang dibuat berdasarkan sebuah class. Satu class bisa menghasilkan banyak object.

Bayangkan class Mobil seperti cetakan kue. Dari satu cetakan itu, kalian bisa membuat banyak kue (object) — mobil_budi dan mobil_ani — yang bentuknya sama tapi isinya (merk, warna) bisa berbeda-beda.

Atribut dan Metode

Di dalam sebuah class, ada dua jenis anggota:

Atribut — data atau karakteristik yang dimiliki objek, disimpan sebagai variabel di dalam class. Contoh: merk, warna, saldo. Metode — perilaku atau aksi yang bisa dilakukan objek, ditulis sebagai function di dalam class. Contoh: klakson(), setor(), cek_saldo().

Berikut contoh lengkap yang menggabungkan class, object, atribut, dan metode sekaligus:

python class Mobil: def init(self, merk, warna): self.merk = merk # atribut self.warna = warna # atribut

def klakson(self):         # metode
    print(f"{self.merk} berbunyi: Tin tin!")

mobil1 = Mobil("Toyota", "Merah") # object mobil1.klakson()

merk dan warna adalah atribut, klakson() adalah metode, dan mobil1 adalah object dari class Mobil. Fungsi init sendiri adalah constructor — kode yang otomatis dijalankan setiap kali sebuah object baru dibuat, biasanya untuk mengisi nilai awal atributnya.

Enkapsulasi: Melindungi Data dari "Tangan Jahil"

Enkapsulasi (encapsulation) berarti membungkus data dan metode dalam satu unit (class), sekaligus menyembunyikan detail internal dari akses langsung di luar class. Tujuannya:

Melindungi data dari perubahan yang tidak diinginkan. Menyediakan akses terkontrol lewat metode (biasanya disebut getter dan setter). Menyembunyikan kompleksitas implementasi dari pengguna class.

Di Python, enkapsulasi diterapkan lewat konvensi penamaan:

_atribut — protected, sebaiknya diakses dari dalam class atau turunannya saja. __atribut — private, secara teknis tidak bisa diakses langsung dari luar class (mekanismenya disebut name mangling). python class RekeningBank: def init(self, saldo_awal): self.__saldo = saldo_awal # atribut private

def setor(self, jumlah):
    self.__saldo += jumlah

def cek_saldo(self):
    return self.__saldo

rekening = RekeningBank(100000) rekening.setor(50000) print(rekening.cek_saldo()) # 150000

print(rekening.__saldo) # Error, tidak bisa diakses langsung

Bayangkan kalau __saldo bisa diubah sembarangan dari luar class — siapa pun bisa langsung menulis rekening.__saldo = 999999999 tanpa lewat proses setor yang semestinya. Enkapsulasi mencegah skenario semacam itu.

Inheritance: Mewariskan Sifat Antar Class

Inheritance (pewarisan) adalah mekanisme di mana class baru (disebut child atau subclass) mewarisi atribut dan metode dari class lain (disebut parent atau superclass). Manfaatnya:

Mengurangi duplikasi kode (reusability). Membentuk hierarki class yang logis. Memudahkan pengembangan dan pemeliharaan program jangka panjang. python class Kendaraan: def init(self, merk): self.merk = merk

def jalan(self):
    print(f"{self.merk} sedang berjalan")

class Motor(Kendaraan): # Motor mewarisi Kendaraan def klakson(self): print(f"{self.merk}: Tin tin!")

motor1 = Motor("Honda") motor1.jalan() # dari parent class motor1.klakson() # dari child class

class Motor(Kendaraan) mewarisi metode jalan() tanpa perlu menulis ulang kodenya sama sekali. Motor cukup menambahkan hal baru yang jadi ciri khasnya sendiri, yaitu klakson().

Yuk, Latihan Sendiri

Sebelum lanjut ke materi berikutnya (Pemodelan Perangkat Lunak Berorientasi Objek / UML), coba kerjakan latihan ini secara mandiri atau bersama teman:

Buat class Hewan dengan atribut nama dan suara, serta metode bersuara(). Buat class Kucing dan Anjing yang mewarisi (inheritance) dari class Hewan. Tambahkan satu atribut privat (enkapsulasi) pada salah satu class, misalnya __berat_badan. Buat object dari masing-masing class, lalu uji coba dengan memanggil metodenya. Uji Pemahaman

Coba jawab pertanyaan berikut untuk mengecek pemahaman kalian:

Apa perbedaan utama antara pemrograman terstruktur dan pemrograman berorientasi objek (OOP)? Jelaskan hubungan antara class dan object, lengkap dengan contoh dari kehidupan sehari-hari. Apa perbedaan antara atribut dan metode dalam sebuah class? Mengapa enkapsulasi penting dalam pengembangan perangkat lunak? Berikan contohnya. Buatlah contoh sederhana (boleh pseudocode) penerapan inheritance dari class yang kalian tentukan sendiri. Refleksi

Sebelum menutup sesi belajar hari ini, coba renungkan tiga hal berikut:

Bagian materi mana yang paling mudah kalian pahami? Bagian mana yang masih terasa membingungkan dan perlu dipelajari ulang? Bagaimana konsep class, object, enkapsulasi, atau inheritance bisa kalian terapkan dalam proyek RPL kalian ke depan? Penutup

Singkatnya: pemrograman terstruktur memisahkan fungsi dan data lalu menjalankannya secara linear, sementara OOP menyatukan keduanya dalam objek yang lebih mudah dikelola dan digunakan ulang. Class adalah cetakan, object adalah hasil nyatanya. Enkapsulasi menjaga data tetap aman, dan inheritance membuat kode lebih efisien lewat pewarisan struktur antar class.

Di artikel berikutnya, kita akan lanjut ke pemodelan perangkat lunak berorientasi objek (UML) — bagaimana menggambarkan alur kerja sistem, model, relasi, dan interaksi antar class sebelum benar-benar menuliskannya jadi kode.

Selamat belajar, dan sampai jumpa di materi berikutnya!