OOP (Object Oriented Programming) — Konsep, 4 Pilar, dan Contoh Lengkap untuk Programmer Pemula

“Kalau fungsi itu kayak mesin di pabrik, OOP itu kayak satu pabrik utuh — punya berbagai mesin, karyawan, aturan, dan semuanya bekerja bareng-bareng buat ngeluarin produk. Objek-objek ini saling komunikasi dan punya tugas masing-masing.”

Daftar Isi

• Apa Itu OOP?
• Mengapa OOP Dibutuhkan?
• Class vs Object — Cetakan vs Hasilnya
• Empat Pilar OOP
  • 1. Encapsulation (Enkapsulasi)
  • 2. Inheritance (Pewarisan)
  • 3. Polymorphism (Polimorfisme)
  • 4. Abstraction (Abstraksi)
• Constructor dan Method
• Contoh Lengkap di 3 Bahasa
• Kapan Pakai OOP, Kapan Tidak?
• Kesimpulan

Apa Itu OOP?

Object Oriented Programming (OOP) atau Pemrograman Berorientasi Objek adalah paradigma pemrograman yang mengorganisir kode di sekitar objek — bukan di sekitar fungsi atau logika prosedural.

Dalam OOP, setiap objek punya:

• Atribut (properties) — data atau ciri-ciri yang dimiliki objek
• Method (behaviors) — aksi atau perilaku yang bisa dilakukan objek

Bayangkan kamu ingin ngebuat program buat restoran. Tanpa OOP, kamu harus nulis:

nama_pelanggan = "Budi"
pesanan_pelanggan = ["Nasi Goreng", "Es Teh"]
total_harga = 25000

Itu belasan variabel yang berserakan. Dengan OOP, kamu buat satu cetakan bernama Pelanggan:

class Pelanggan:
    def __init__(self, nama, pesanan):
        self.nama = nama
        self.pesanan = pesanan
        self.total = 0
    
    def tambah_pesanan(self, item, harga):
        self.pesanan.append(item)
        self.total += harga

Satu class bisa bikin banyak object — Budi, Siti, Andi — masing-masing dengan data dan perilaku mereka sendiri.

Mengapa OOP Dibutuhkan?

Sebelum OOP populer, programmer nulis kode secara procedural — semua fungsi dan data bercampur jadi satu. Ini masalah besar saat proyek mulai besar:

Masalah	Procedural	OOP
Organisasi	Data dan fungsi terpisah	Data + fungsi menyatu dalam objek
Reusability	Copy-paste kode	Bisa buat ulang class berkali-kali
Maintenance	Ganti satu fungsi berdampak ke mana-mana	Enkapsulasi — perubahan terisolasi
Kolaborasi	Sulit dibagi antar developer	Class jadi kontrak yang jelas
Real-world mapping	Code nggak mencerminkan dunia nyata	Objek mirip entitas nyata

OOP adalah jawaban atas kompleksitas. Semakin besar aplikasi, semakin kamu butuh struktur yang jelas.

Keterkaitan: Konsep ini adalah evolusi dari yang kita bahas di Fungsi dalam Programming. Kalau fungsi adalah blok bangunan, OOP adalah cara menyusun blok-blok itu jadi struktur yang lebih besar dan terorganisir.

Class vs Object — Cetakan vs Hasilnya

Ini konsep paling fundamental di OOP. Sering bikin bingung, padahal sederhana:

• Class = cetakan (template / blueprint)
• Object = hasil cetakan (instance)

Istilah	Analogi	Coding
Class	Cetakan kue	class Mobil:
Object	Kue jadi	mobilku = Mobil()
Atribut	Warna, ukuran kue	mobilku.warna = "merah"
Method	Cara memanggang	mobilku.maju()

Contoh class mobil:

class Mobil:
    def __init__(self, merk, warna):
        self.merk = merk
        self.warna = warna
        self.kecepatan = 0
    
    def gas(self, tambah):
        self.kecepatan += tambah
    
    def rem(self):
        self.kecepatan = 0

# Bikin 2 object dari class yang sama
mobil_andi = Mobil("Toyota", "Hitam")
mobil_budi = Mobil("Honda", "Putih")

mobil_andi.gas(20)
print(mobil_andi.kecepatan)  # 20
print(mobil_budi.kecepatan)  # 0 — beda object, beda data

Satu class, banyak object. Masing-masing object punya data sendiri-sendiri.

Empat Pilar OOP

1. Encapsulation (Enkapsulasi)

Enkapsulasi adalah prinsip menyembunyikan data internal suatu object dan hanya membuka akses melalui method tertentu. Ini mencegah data diubah sembarangan dari luar.

Di Python, data “private” ditandai dengan underscore (_ atau __):

class RekeningBank:
    def __init__(self, pemilik, saldo_awal):
        self.pemilik = pemilik
        self.__saldo = saldo_awal  # private
    
    def lihat_saldo(self):
        return f"Rp {self.__saldo:,}"
    
    def transfer(self, jumlah, tujuan):
        if jumlah > self.__saldo:
            return "Saldo tidak cukup!"
        self.__saldo -= jumlah
        tujuan.__saldo += jumlah  # ⚠️ ini cuma contoh
        return f"Transfer Rp {jumlah:,} berhasil"
    
    def setor(self, jumlah):
        self.__saldo += jumlah

rek = RekeningBank("Budi", 1000000)
print(rek.lihat_saldo())  # Rp 1,000,000
# rek.__saldo = 999999999  # ❌ ERROR! AttributeError

Manfaat: Data tidak bisa diubah sembarangan dari luar. Kalau mau ubah saldo, harus lewat method setor() atau transfer() yang udah ada validasinya.

2. Inheritance (Pewarisan)

Inheritance memungkinkan sebuah class mewarisi atribut dan method dari class lain. Ini mengurangi duplikasi kode dan menciptakan hierarki.

class Hewan:
    def __init__(self, nama):
        self.nama = nama
    
    def bersuara(self):
        return "..."

class Kucing(Hewan):  # Kucing mewarisi Hewan
    def bersuara(self):
        return "Meow!"
    
    def goyang_ekor(self):
        return "Ekor bergoyang..."

class Anjing(Hewan):  # Anjing mewarisi Hewan
    def bersuara(self):
        return "Guk guk!"
    
    def jilat(self):
        return "Jilat-jilat..."

kucing = Kucing("Milo")
anjing = Anjing("Doggy")

print(kucing.nama)      # Milo — diwarisi dari Hewan
print(kucing.bersuara())  # Meow! — override
print(anjing.bersuara())  # Guk guk! — override

Istilah	Arti
Parent class / Superclass	Class yang mewariskan (Hewan)
Child class / Subclass	Class yang mewarisi (Kucing, Anjing)
Override	Child class ganti method dari parent
super()	Panggil method parent dari child

3. Polymorphism (Polimorfisme)

Polymorphism berarti “banyak bentuk”. Method yang sama bisa berperilaku berbeda tergantung object yang memanggilnya.

def sound_check(hewan):
    print(f"{hewan.nama} bersuara: {hewan.bersuara()}")

kucing = Kucing("Milo")
anjing = Anjing("Doggy")

sound_check(kucing)  # Milo bersuara: Meow!
sound_check(anjing)  # Doggy bersuara: Guk guk!

Fungsi sound_check nggak peduli objectnya Kucing atau Anjing — yang penting punya method bersuara(). Ini namanya duck typing: “If it walks like a duck and quacks like a duck, it’s a duck.”

Polymorphism juga bekerja lewat inheritance (method override) dan interface (dalam bahasa yang mendukung seperti Java).

4. Abstraction (Abstraksi)

Abstraksi menyembunyikan detail implementasi dan cuma menampilkan fungsionalitas esensial. Ini bikin kode lebih simpel dipakai — kamu nggak perlu tahu gimana cara kerjanya di dalam.

from abc import ABC, abstractmethod

class Kendaraan(ABC):  # Abstract class
    @abstractmethod
    def mulai(self):
        pass
    
    @abstractmethod
    def berhenti(self):
        pass

class Mobil(Kendaraan):
    def mulai(self):
        return "Mesin dinyalakan, gigi 1..."
    
    def berhenti(self):
        return "Rem diinjak, mesin mati"

class Sepeda(Kendaraan):
    def mulai(self):
        return "Kayuh pedal..."
    
    def berhenti(self):
        return "Rem tangan ditarik..."

Perbedaan Abstraction vs Encapsulation:

Aspect	Encapsulation	Abstraction
Fokus	Menyembunyikan data	Menyembunyikan implementasi
Caranya	Private/public access	Abstract class / interface
Tujuannya	Melindungi data	Menyederhanakan penggunaan
Contoh	__saldo di RekeningBank	Method mulai() tanpa detail mesin

Constructor dan Method

Constructor adalah method spesial yang otomatis dipanggil saat object dibuat. Di Python, constructor adalah __init__():

class Mahasiswa:
    # Constructor — dijalankan saat object baru dibuat
    def __init__(self, nama, nim, jurusan):
        self.nama = nama
        self.nim = nim
        self.jurusan = jurusan
        self.mata_kuliah = []
    
    def daftar_matkul(self, matkul):
        self.mata_kuliah.append(matkul)
        return f"{matkul} ditambahkan"
    
    def info(self):
        return f"{self.nama} ({self.nim}) - {self.jurusan}"

Contoh Lengkap di 3 Bahasa

Python

class Karyawan:
    def __init__(self, nama, gaji):
        self.nama = nama
        self.__gaji = gaji  # encapsulation
    
    def info(self):
        return f"{self.nama}: Rp{self.__gaji:,}"
    
    def naik_gaji(self, persen):
        self.__gaji += self.__gaji * persen / 100

class Manager(Karyawan):  # inheritance
    def __init__(self, nama, gaji, divisi):
        super().__init__(nama, gaji)
        self.divisi = divisi
        self.tim = []
    
    def info(self):  # polymorphism
        return f"Manager {self.nama} - {self.divisi}"

Java

// Class definition
class Karyawan {
    private String nama;        // encapsulation
    private double gaji;
    
    // Constructor
    public Karyawan(String nama, double gaji) {
        this.nama = nama;
        this.gaji = gaji;
    }
    
    public String info() {
        return nama + ": Rp" + gaji;
    }
}

// Inheritance
class Manager extends Karyawan {
    private String divisi;
    
    public Manager(String nama, double gaji, String divisi) {
        super(nama, gaji);
        this.divisi = divisi;
    }
    
    @Override
    public String info() {  // polymorphism
        return "Manager " + super.info() + " - " + divisi;
    }
}

JavaScript (ES6)

class Karyawan {
    #gaji;  // private field (ES6+)
    
    constructor(nama, gaji) {
        this.nama = nama;
        this.#gaji = gaji;
    }
    
    info() {
        return `${this.nama}: Rp${this.#gaji}`;
    }
}

class Manager extends Karyawan {
    constructor(nama, gaji, divisi) {
        super(nama, gaji);
        this.divisi = divisi;
    }
    
    info() {
        return `Manager ${this.nama} - ${this.divisi}`;
    }
}

Kapan Pakai OOP, Kapan Tidak?

OOP bukan satu-satunya paradigma. Kadang pendekatan lain lebih cocok:

Situasi	Pakai OOP?	Kenapa?
Aplikasi besar dengan banyak entitas	✅ Ya	Struktur jelas, mudah diperluas
Game development	✅ Ya	Karakter, item, level = object alami
GUI / UI framework	✅ Ya	Tombol, form, window = object
Microservices / API	⚠️ Mungkin	Lebih cocok functional + modular
Script kecil (1 file)	❌ Tidak	Overhead nggak sebanding
Data processing pipeline	❌ Tidak	Cukup pakai function saja
Sistem real-time / embedded	❌ Tidak	Performance overhead OOP tinggi

Catatan: Banyak proyek modern pake hybrid — OOP untuk struktur besar, functional untuk logika murni. Nggak harus milih salah satu. Kalau penasaran, baca juga artikel Functional Programming setelah ini (coming soon).

Kesimpulan

OOP adalah paradigma yang mengubah cara kita berpikir tentang kode — dari sekadar instruksi berurutan menjadi kumpulan objek yang saling berinteraksi. Empat pilarnya (encapsulation, inheritance, polymorphism, abstraction) bukan teori abstrak, tapi alat praktis yang bikin kode lebih terstruktur, mudah di-maintain, dan scalable.

Aspek	Intinya
Apa itu OOP	Paradigma programming berbasis objek — gabungan data + fungsi
Class vs Object	Class = cetakan, Object = hasil cetakan
4 Pilar	Encapsulation, Inheritance, Polymorphism, Abstraction
Kapan dipakai	Aplikasi besar, game, GUI, sistem kompleks
Kapan dihindari	Script kecil, data pipeline, sistem real-time

---

Related Posts

• Fungsi dalam Programming — Blok Bangunan yang Bikin Kode Rapi — Pendahuluan tentang fungsi, cikal bakal method dalam OOP
• Struktur Data Dasar: Array, Linked List, Stack, Queue — Struktur data yang sering dipakai di dalam class
• Tipe Data dan Variabel di Berbagai Bahasa — Fondasi sebelum membuat properti dalam class