Program Studi Bisnis Digital • FEB UNDIP

Algoritma dan Pemrograman

Pertemuan 12 — Konsep Object-Oriented Programming (OOP)

Dari kumpulan fungsi menuju cara berpikir baru: class, object, dan encapsulation — fondasi pemrograman modern yang dipakai hampir semua aplikasi bisnis digital.

RPS MINGGU 13 • 2 × 50 MENIT

Selamat pagi/siang, Anda semua. Sejak pertemuan pertama, kita menulis program dengan cara "prosedural" — variabel dan fungsi berdiri sendiri-sendiri, lalu kita panggil satu per satu secara berurutan. Hari ini kita berkenalan dengan cara berpikir yang berbeda dan jauh lebih dekat dengan dunia nyata bisnis: Object-Oriented Programming, atau OOP. Bayangkan Anda sedang membangun sistem kasir untuk toko online kecil — ada produk, ada pelanggan, ada keranjang belanja. Alih-alih menyimpan semuanya di variabel terpisah yang membingungkan, OOP membiarkan kita membungkus data dan perilaku itu jadi satu paket rapi bernama "objek". Hari ini kita akan belajar apa itu class, apa itu object, dan satu prinsip penting bernama encapsulation, semuanya dengan contoh toko online dan UMKM yang dekat dengan keseharian Anda.

Tujuan Pembelajaran Hari Ini

Sesuai RPS minggu 13, setelah pertemuan ini Anda diharapkan mampu menjelaskan dan menerapkan konsep dasar object-oriented programming. Secara rinci:

Konsep

Class & Object

Memahami perbedaan class (cetakan/blueprint) dan object (hasil nyata dari cetakan itu), serta cara membuat keduanya di Python.

Konsep

Encapsulation

Memahami mengapa data sebuah objek perlu "dibungkus" dan dilindungi, bukan diakses sembarangan dari luar.

Mengapa Kita Butuh OOP?

Ingat kembali Pertemuan 6 (fungsi) dan Pertemuan 7–8 (list, dict). Bayangkan Anda mengelola 100 produk toko online: nama, harga, stok, kategori — semua disimpan di variabel dan list terpisah.

Cara lama (prosedural): nama_produk = [...], harga_produk = [...], stok_produk = [...] — semua list terpisah, mudah tertukar indeksnya, sulit dirawat saat aplikasi membesar.

Cara OOP: satu class Produk membungkus nama, harga, dan stok jadi satu paket per produk — rapi, aman, dan mudah dipakai ulang untuk ribuan produk.

Hampir semua framework bisnis digital yang akan Anda temui nanti — Django, Laravel, sistem POS UMKM — dibangun di atas OOP.

Mari kita mulai dengan masalah nyata. Kalau Anda pernah membuka toko di Shopee atau Tokopedia, coba bayangkan tim developer di baliknya harus mengelola jutaan produk, jutaan pelanggan, dan jutaan transaksi setiap hari. Kalau semua data itu disimpan di variabel dan list yang berdiri sendiri seperti yang kita pelajari di pertemuan tujuh dan delapan, programnya akan menjadi kacau dan gampang error — bayangkan indeks nomor lima di list harga ternyata bukan produk yang sama dengan indeks lima di list nama. OOP menyelesaikan masalah ini dengan cara yang sangat intuitif: setiap produk, setiap pelanggan, setiap transaksi jadi satu "objek" yang membawa data dan perilakunya sendiri. Ini bukan sekadar gaya penulisan kode — ini adalah cara berpikir yang dipakai hampir semua sistem bisnis digital besar di dunia, termasuk yang Anda pakai setiap hari.

Bagian 1 dari 3

Dari Fungsi ke Objek

Mengenal class dan object sebagai satuan dasar OOP — apa bedanya cetakan kue dengan kue yang sudah jadi.

Prosedural vs Object-Oriented

Gaya Prosedural (P1–P11)

Data dan fungsi terpisah
Variabel/list berdiri sendiri
Cocok untuk skrip pendek dan sederhana
Contoh: hitung_diskon(harga, persen)

Gaya OOP (mulai hari ini)

Data dan perilaku dibungkus jadi satu objek
Satu class = cetakan untuk banyak objek serupa
Cocok untuk aplikasi besar yang terus berkembang
Contoh: produk.hitung_diskon()

Bukan berarti fungsi (Pertemuan 6) menjadi tidak berguna — dalam OOP, fungsi tetap dipakai, hanya sekarang "menempel" pada objek dan disebut method.

Class dan Object: Cetakan vs Kue

Class

Cetakan

Blueprint atau rancangan. Mendefinisikan data apa saja (atribut) dan bisa melakukan apa saja (method) yang akan dimiliki setiap objek. Class sendiri belum berupa data konkret.

Object

Kue Jadi

Hasil nyata dari class — disebut juga instance. Satu class Produk bisa menghasilkan ratusan object produk berbeda, masing-masing dengan nama dan harga sendiri.

Analogi: class = cetakan kue bulat; object = kue nastar, kue kastengel, kue putri salju — semua dari cetakan yang sama, isinya beda-beda.

Menulis Class Pertama di Python

Struktur dasar sebuah class: kata kunci class, nama class (huruf besar di awal), lalu method khusus __init__ untuk mengisi data awal.

class Produk: # __init__ = constructor, jalan otomatis saat objek dibuat def __init__(self, nama, harga): self.nama = nama # atribut self.harga = harga # atribut def info(self): # method return f"{self.nama}: Rp{self.harga}" kaos = Produk("Kaos Polos", 150000) # membuat object print(kaos.info())

Glosarium: atribut = data yang dimiliki objek (mis. nama, harga). Method = fungsi milik objek (mis. info()). Constructor = method __init__ yang otomatis dijalankan saat objek dibuat. self = rujukan ke objek itu sendiri (dibahas detail di Slide 11).

Sekarang kita masuk ke kode nyata. Perhatikan struktur ini pelan-pelan: kita mulai dengan kata kunci class, lalu nama class kita tulis dengan huruf besar di awal — konvensi ini disebut PascalCase, berbeda dari nama variabel dan fungsi biasa yang huruf kecil semua. Di dalam class, ada method khusus bernama double-underscore init double-underscore yang disebut constructor — method ini otomatis berjalan setiap kali kita membuat objek baru, tugasnya mengisi data awal seperti nama dan harga. Baris kaos sama dengan Produk kurung buka "Kaos Polos" koma seratus lima puluh ribu itulah momen kita "mencetak" object dari class. Setelah itu, kaos titik info kurung buka kurung tutup akan memanggil method info milik objek kaos tadi. Jangan khawatir kalau belum lancar — kita akan latihan langsung di slide-slide berikutnya.

Hitung dari Nol: Kalkulator Harga Toko Online

Object Produk: nama "Kaos Polos", harga satuan Rp150.000, kuantitas 3, diskon member 10%. Method hitung_total() menghitung total bayar.

Langkah	Perhitungan	Nilai
1. Atribut harga satuan	self.harga	Rp150.000
2. Atribut kuantitas	self.kuantitas	3
3. Subtotal	150.000 × 3	Rp450.000
4. Nilai diskon (10%)	450.000 × 10%	Rp45.000
5. Total bayar	450.000 − 45.000	Rp405.000

Total Bayar (method hitung_total)

Rp405.000

Mari kita hitung langkah demi langkah persis seperti method di dalam class akan mengerjakannya. Objek Produk kita punya atribut harga seratus lima puluh ribu rupiah dan kuantitas tiga potong kaos. Langkah ketiga, subtotal dihitung dengan mengalikan seratus lima puluh ribu dengan tiga, hasilnya empat ratus lima puluh ribu rupiah. Langkah keempat, karena pelanggan ini member dengan diskon sepuluh persen, kita hitung nilai diskonnya: empat ratus lima puluh ribu dikali sepuluh persen sama dengan empat puluh lima ribu rupiah. Langkah terakhir, total bayar adalah subtotal dikurangi nilai diskon tadi: empat ratus lima puluh ribu dikurangi empat puluh lima ribu, hasilnya empat ratus lima ribu rupiah. Inilah yang akan dikembalikan oleh method hitung_total milik objek kaos tersebut — perhatikan bahwa semua angka ini "menempel" pada objek itu sendiri, bukan variabel lepas.

Hitung dari Nol: Poin Loyalitas Pelanggan UMKM

Object Pelanggan bernama "Bu Siti". Program loyalitas UMKM: 1 poin per Rp10.000 belanja, dibulatkan ke bawah. Method tambah_poin(total_belanja).

Langkah	Perhitungan	Nilai
1. Atribut total belanja	total_belanja	Rp245.000
2. Rasio program poin	1 poin : Rp10.000	1 : 10.000
3. Poin mentah	245.000 ÷ 10.000	24,5
4. Dibulatkan ke bawah	int(24,5)	24
5. Saldo poin baru	0 (saldo lama) + 24	24 poin

Saldo Poin Bu Siti

24 poin

Contoh kedua ini menunjukkan bagaimana sebuah method bisa mengubah atribut objek, bukan sekadar menghitung dan menampilkan. Bu Siti berbelanja senilai dua ratus empat puluh lima ribu rupiah di sebuah toko kelontong daring yang menerapkan program poin loyalitas: setiap sepuluh ribu rupiah belanja bernilai satu poin. Langkah ketiga, kita bagi dua ratus empat puluh lima ribu dengan sepuluh ribu, hasilnya dua puluh empat koma lima. Karena poin harus bilangan bulat, kita bulatkan ke bawah menggunakan fungsi int, sehingga menjadi dua puluh empat poin — ingat, pembulatan ke bawah artinya sisa nol koma lima tidak dihitung, ini kebijakan bisnis yang wajar supaya program loyalitas tidak merugikan toko. Langkah terakhir, dua puluh empat poin ini ditambahkan ke saldo poin lama Bu Siti yang tadinya nol, sehingga saldo barunya dua puluh empat poin — inilah contoh nyata bagaimana method mengubah data yang tersimpan di dalam objek.

Bagian 2 dari 3

Self dan Encapsulation

Bagaimana Python tahu objek mana yang sedang "berbicara", dan mengapa data objek perlu dilindungi.

Apa Itu `self`?

self adalah rujukan ke objek yang sedang memanggil method itu. Python otomatis mengoper objeknya sebagai parameter pertama — Anda tidak perlu menuliskannya saat memanggil method.

Encapsulation: Membungkus dan Melindungi Data

Encapsulation (enkapsulasi) adalah prinsip membungkus atribut di dalam objek dan membatasi akses langsung dari luar — data hanya boleh diubah lewat method yang disediakan class.

Tanpa encapsulation: siapa pun bisa menulis rekening.saldo = -500000 langsung dari luar class — saldo minus tidak masuk akal, tapi Python tidak mencegahnya.

Dengan encapsulation: atribut ditandai "privat" (awalan _), diubah hanya lewat method seperti tarik_saldo() yang bisa memvalidasi aturan bisnis.

Encapsulation adalah salah satu dari empat pilar besar OOP — dua pilar lainnya, inheritance dan polymorphism, akan kita bahas tuntas di pertemuan ketiga belas. Konsepnya sederhana: bayangkan rekening tabungan BCA Anda. Anda tidak bisa langsung membuka database bank dan mengetik ulang angka saldo Anda — Anda harus lewat mesin ATM atau aplikasi yang punya aturan, misalnya tidak boleh menarik lebih dari saldo yang ada. Di dalam program, encapsulation bekerja dengan cara yang sama: kita "membungkus" atribut penting seperti saldo, lalu hanya mengizinkan perubahan lewat method tertentu yang sudah kita beri aturan validasi. Konvensi di Python untuk menandai atribut privat adalah dengan menambahkan garis bawah di depan nama atribut, misalnya underscore saldo — ini sinyal bagi programmer lain "jangan diubah langsung dari luar".

Encapsulation dalam Kode: Rekening Pelanggan

class RekeningPelanggan: def __init__(self, nama, saldo_awal): self.nama = nama self._saldo = saldo_awal # underscore = privat def tarik_saldo(self, jumlah): if jumlah > self._saldo: return "Saldo tidak cukup" self._saldo -= jumlah return f"Berhasil, sisa saldo: Rp{self._saldo}" rek = RekeningPelanggan("Pak Budi", 100000) print(rek.tarik_saldo(150000)) # ditolak, saldo < 150000

Method tarik_saldo() jadi "pintu resmi" satu-satunya untuk mengubah _saldo — di sinilah aturan bisnis (saldo tidak boleh minus) ditegakkan.

Perhatikan class RekeningPelanggan ini menerapkan encapsulation dengan dua cara. Pertama, atribut saldo diberi awalan underscore menjadi underscore saldo, menandakan ini data privat yang idealnya tidak diubah langsung dari luar class. Kedua, satu-satunya cara resmi untuk mengurangi saldo adalah lewat method tarik_saldo, dan di dalam method itu ada pengecekan: kalau jumlah yang ingin ditarik lebih besar dari saldo yang ada, permintaan ditolak dengan pesan "Saldo tidak cukup". Coba bayangkan kalau Pak Budi punya saldo seratus ribu rupiah lalu mencoba menarik seratus lima puluh ribu rupiah — sesuai kode ini, permintaannya akan ditolak karena seratus lima puluh ribu lebih besar dari seratus ribu. Inilah kekuatan encapsulation: aturan bisnis tertanam rapi di satu tempat, bukan tersebar di banyak bagian kode yang berisiko lupa divalidasi.

Satu Class, Banyak Object

Class hanya ditulis sekali, tapi bisa "mencetak" object sebanyak yang dibutuhkan — masing-masing punya data sendiri, method yang sama.

Tiga object di atas semuanya lahir dari class Produk yang sama — struktur (atribut & method) identik, isi data berbeda-beda.

Diagram ini adalah inti dari mengapa OOP begitu efisien. Kita hanya menulis class Produk satu kali di kode kita, lengkap dengan atribut nama dan harga serta method seperti info dan hitung_total yang sudah kita bahas. Dari satu class itu, kita bisa membuat objek kaos dengan harga seratus lima puluh ribu, objek tas ransel dengan harga dua ratus tujuh puluh lima ribu, dan objek sepatu dengan harga empat ratus dua puluh ribu — bayangkan toko online sungguhan yang punya ribuan produk, semuanya cukup dibuat dari satu class yang sama. Ini jauh lebih hemat dan rapi dibanding menulis kode terpisah untuk setiap produk seperti yang mungkin terpikir kalau kita masih memakai gaya prosedural. Setiap objek "mengingat" datanya sendiri, tapi berbagi cara kerja (method) yang persis sama dari class induknya.

Constructor: Nilai Wajib vs Nilai Default

Parameter __init__ bisa diberi nilai default — objek tetap bisa dibuat walau sebagian data belum diisi saat itu.

class Produk: def __init__(self, nama, harga, stok=0): self.nama = nama # wajib diisi self.harga = harga # wajib diisi self.stok = stok # default 0 jika tidak diisi p1 = Produk("Kaos Polos", 150000, 20) # stok = 20 p2 = Produk("Topi", 50000) # stok = 0 (default)

p1.stok

p2.stok

Ini adalah pola yang sangat sering dipakai di kode Python nyata. Parameter nama dan harga di constructor kita tandai wajib — artinya setiap kali membuat objek Produk, kedua data ini harus diisi, kalau tidak Python akan memunculkan error. Sebaliknya, parameter stok kita beri nilai default nol dengan menulis stok sama dengan nol di definisi method — ini berarti kalau saat membuat objek kita tidak menyebutkan stoknya, Python otomatis mengisi nol. Perhatikan objek p1 dibuat dengan tiga argumen lengkap termasuk stok dua puluh, sementara objek p2 hanya diberi nama dan harga, sehingga stoknya otomatis nol. Pola nilai default ini berguna untuk kasus seperti produk baru yang belum ada stoknya, atau member baru yang poin loyalitasnya otomatis dimulai dari nol tanpa kita perlu menuliskannya berulang kali.

Bagian 3 dari 3

OOP dalam Bisnis Digital

Menerapkan class dan object pada studi kasus sistem antrian UMKM, lalu mengenali jebakan yang sering dilakukan pemula.

Studi Kasus: Sistem Antrian Sederhana UMKM

Warung makan ingin sistem antrian digital. Setiap pelanggan jadi satu object AntrianPelanggan dengan nomor urut otomatis.

class AntrianPelanggan: total_antrian = 0 # dihitung bersama semua object def __init__(self, nama): self.nama = nama AntrianPelanggan.total_antrian += 1 self.nomor = AntrianPelanggan.total_antrian def panggil(self): return f"Nomor {self.nomor}: {self.nama}, silakan" p1 = AntrianPelanggan("Bu Ani") # nomor = 1 p2 = AntrianPelanggan("Pak Joko") # nomor = 2 print(p2.panggil()) # "Nomor 2: Pak Joko, silakan"

Kesalahan Umum Pemula Menulis Class

Lupa parameter self
def info(): ... akan error — setiap method wajib punya self sebagai parameter pertama.

Salah nama constructor
Menulis def init(self): (lupa dua underscore) — Python tidak akan memanggilnya otomatis.

Lupa self. di dalam method
Menulis nama = nama tanpa self. — data tidak tersimpan di objek, hilang setelah method selesai.

Class tanpa huruf besar
Menulis class produk: tetap berjalan, tapi melanggar konvensi PascalCase yang dipakai seluruh komunitas Python.

Empat kesalahan ini adalah yang paling sering saya temui saat memeriksa tugas mahasiswa semester-semester sebelumnya, jadi mohon perhatikan baik-baik. Kesalahan pertama, lupa menuliskan self sebagai parameter pertama di setiap method, akan langsung memunculkan pesan error saat method dipanggil. Kesalahan kedua, salah menulis nama constructor — harus persis dua garis bawah di depan dan belakang kata init, kalau salah ketik menjadi init saja tanpa garis bawah, Python tidak akan mengenalinya sebagai constructor dan tidak akan memanggilnya otomatis saat objek dibuat. Kesalahan ketiga cukup halus: menulis nama sama dengan nama tanpa awalan self titik di depan berarti Anda membuat variabel lokal biasa yang hilang begitu method selesai berjalan, bukan menyimpannya sebagai atribut objek. Kesalahan keempat bukan error teknis, tapi soal konvensi penulisan kode yang rapi — nama class selalu diawali huruf besar, ini akan memudahkan orang lain membaca kode Anda nanti di dunia kerja.

Latihan Kelas: Class Pelanggan UMKM

Kerjakan berpasangan, 15 menit. Buat class Pelanggan untuk toko kelontong daring:

Instruksi

Atribut: nama, total_belanja (mulai dari 0)
Method belanja(jumlah) — menambah total_belanja
Method cek_status() — kembalikan "Member VIP" jika total_belanja > Rp500.000, selain itu "Member Biasa"
Buat 2 object pelanggan, uji method-nya, cetak hasilnya

Gunakan pola encapsulation dari Slide 13 sebagai referensi — validasi di dalam method, bukan di luar class.

Sekarang giliran Anda praktik langsung. Silakan berpasangan dengan teman sebelah, dan Anda punya waktu lima belas menit untuk menyelesaikan latihan ini sebelum kita bahas bersama. Buat class bernama Pelanggan dengan dua atribut: nama, dan total_belanja yang dimulai dari nol menggunakan nilai default seperti yang kita pelajari di Slide 15. Kemudian buat method belanja yang menerima parameter jumlah dan menambahkannya ke total_belanja — pola ini mirip dengan method tarik_saldo di Slide 13, hanya arahnya menambah bukan mengurangi. Method cek_status akan mengembalikan teks "Member VIP" kalau total belanja pelanggan sudah melebihi lima ratus ribu rupiah, atau "Member Biasa" jika belum. Setelah class selesai, buat dua objek pelanggan yang berbeda, uji dengan beberapa nilai belanja, lalu cetak hasil cek_status masing-masing untuk memastikan logikanya benar.

Rangkuman & Menuju Pertemuan 13

Istilah	Arti Singkat
Class	Cetakan/blueprint — mendefinisikan atribut & method
Object / Instance	Hasil nyata dari class, punya data sendiri
Atribut	Data yang dimiliki objek (mis. `nama`, `harga`)
Method	Fungsi yang menempel pada objek
self	Rujukan ke objek yang sedang memanggil method
Encapsulation	Membungkus & melindungi data, akses lewat method

Pertemuan 13: Implementasi OOP lanjutan — inheritance (pewarisan antar-class) dan polymorphism. Tugas: selesaikan & kumpulkan latihan class Pelanggan sebelum pertemuan berikutnya.

Mari kita rangkum perjalanan kita hari ini lewat tabel istilah di layar — saya sarankan Anda foto atau salin tabel ini sebagai catatan cepat, karena semua istilah ini akan terus dipakai sampai akhir semester. Kita sudah belajar bahwa class adalah cetakan, object adalah hasil nyatanya, atribut adalah data yang dibawa objek, method adalah fungsi yang menempel padanya, self merujuk ke objek yang sedang aktif, dan encapsulation melindungi data itu dari perubahan sembarangan. Minggu depan, di pertemuan ketiga belas, kita akan melanjutkan dengan dua pilar OOP lainnya: inheritance, yaitu bagaimana satu class bisa "mewarisi" sifat class lain — misalnya class ProdukDiskon mewarisi semua yang dimiliki class Produk lalu menambah fitur baru — dan polymorphism, bagaimana objek berbeda bisa merespons perintah yang sama dengan cara masing-masing. Sebelum pertemuan berikutnya, tolong selesaikan dan kumpulkan latihan class Pelanggan dari slide sebelumnya, karena kita akan memakainya sebagai fondasi latihan minggu depan. Sampai jumpa di pertemuan berikutnya!

Algoritma dan Pemrograman

Pertemuan 12 — Konsep Object-Oriented Programming (OOP)

Tujuan Pembelajaran Hari Ini

Mengapa Kita Butuh OOP?

Prosedural vs Object-Oriented

Class dan Object: Cetakan vs Kue

Menulis Class Pertama di Python

Hitung dari Nol: Kalkulator Harga Toko Online

Hitung dari Nol: Poin Loyalitas Pelanggan UMKM

Apa Itu self?

Encapsulation: Membungkus dan Melindungi Data

Encapsulation dalam Kode: Rekening Pelanggan

Satu Class, Banyak Object

Constructor: Nilai Wajib vs Nilai Default

Studi Kasus: Sistem Antrian Sederhana UMKM

Kesalahan Umum Pemula Menulis Class

Latihan Kelas: Class Pelanggan UMKM

Rangkuman & Menuju Pertemuan 13

Apa Itu `self`?