Materi · OOP
Materi OOP
Disusun bertahap: fondasi dasar dulu, baru masuk 4 Pilar OOP, ditutup istilah yang sering muncul di soal. Baca ini dulu kalau istilah-istilah di soal masih terasa asing.
Tiap konsep di bawah dilengkapi contoh kode Java sebagai ilustrasi visual — dipilih Java karena bahasa ini representatif untuk OOP dan aturannya jelas, BUKAN karena tes aslinya pakai Java. Fokusnya memahami konsepnya, bukan menghafal sintaks Java.
Tahap 1 · Dasar
1
Class & Object
Class adalah rancangan atau cetakan yang mendeskripsikan bentuk umum suatu jenis objek — data apa saja yang dipunya, dan aksi apa saja yang bisa dilakukan. Class itu sendiri masih abstrak, belum berupa sesuatu yang nyata.
Object adalah wujud nyata yang lahir dari sebuah Class. Satu Class bisa melahirkan banyak Object, masing-masing berdiri sendiri dengan nilai data sendiri-sendiri.
Contoh
Class Buku menentukan bahwa setiap buku pasti punya judul dan jumlahHalaman. Ketika itu dipakai membuat buku "Laskar Pelangi" (529 halaman) dan buku "Bumi Manusia" (535 halaman), keduanya adalah Object — hasil nyata dari Class yang sama.
Analogi: Class itu seperti resep masakan, Object adalah masakan yang benar-benar dimasak mengikuti resep itu — resepnya satu, tapi masakan yang dihasilkan bisa banyak dan masing-masing independen begitu sudah jadi.
Kode (Java)public class Buku {
String judul;
int jumlahHalaman;
}
Buku buku1 = new Buku();
buku1.judul = "Laskar Pelangi";
buku1.jumlahHalaman = 529;
Buku buku2 = new Buku();
buku2.judul = "Bumi Manusia";
buku2.jumlahHalaman = 535;
// buku1 dan buku2 adalah dua Object berbeda dari Class Buku yang sama
2
Property & Method
Isi sebuah Class terbagi jadi dua jenis anggota: Property yang menyimpan data, dan Method yang menjalankan aksi.
Property menjawab pertanyaan "objek ini PUNYA apa?" — nilai yang melekat dan bisa dibaca/diubah. Method menjawab pertanyaan "objek ini BISA melakukan apa?" — aksi yang dijalankan, kadang mengubah nilai property miliknya sendiri.
Contoh
Class Pemain pada sebuah game punya property nama dan level (data), serta method serang() dan naikLevel() (aksi). Pemain "Rian" punya nama="Rian", level=5, dan bisa memanggil serang() atau naikLevel() kapan saja.
Cara mudah membedakan: kalau berupa NILAI/DATA (tanpa tanda kurung), itu Property. Kalau berupa AKSI yang dijalankan (ditulis pakai tanda kurung, misal serang()), itu Method.
Kode (Java)public class Pemain {
String nama;
int level;
void serang() { // method (aksi)
System.out.println(nama + " menyerang!");
}
void naikLevel() { // method (aksi)
level += 1;
}
}
Pemain rian = new Pemain();
rian.nama = "Rian"; // property (data)
rian.level = 5; // property (data)
rian.serang(); // memanggil method
3
Constructor
Constructor adalah method istimewa yang otomatis dipanggil tepat saat sebuah Object baru dibuat. Tugasnya cuma satu: mengisi nilai awal ke property-property object itu, sebelum object tersebut mulai dipakai — supaya object tidak "kosong" begitu lahir.
Ciri Constructor di Java: namanya harus SAMA PERSIS dengan nama Class-nya, dan tidak punya tipe kembalian sama sekali (bukan void, bukan apa pun).
Contoh
Class Robot punya property nama dan levelBaterai. Waktu developer menulis new Robot("R2", 100), Constructor otomatis mengisi nama="R2" dan levelBaterai=100 ke object baru itu — tanpa perlu developer mengisi satu-satu secara manual setelahnya.
Kenapa penting: tanpa Constructor, developer harus mengisi tiap property secara manual satu per satu setiap kali membuat object baru — rawan lupa dan bikin kode berulang-ulang. Di beberapa bahasa lain, Constructor ini juga disebut Initializer.
Analogi: Constructor itu seperti proses pendaftaran murid baru di sekolah — begitu murid baru terdaftar, formulir otomatis terisi nama dan kelasnya, tanpa perlu ditulis manual belakangan.
Kode (Java)public class Robot {
String nama;
int levelBaterai;
Robot(String nama, int levelBaterai) { // nama method = nama class
this.nama = nama;
this.levelBaterai = levelBaterai;
}
}
Robot r2 = new Robot("R2", 100);
// Constructor otomatis jalan saat "new Robot(...)" dipanggil
Tahap 2 · 4 Pilar OOP
4
Encapsulation
Pilar pertama: membungkus data dan method yang berkaitan jadi satu kesatuan di dalam Class, sekaligus menutup akses langsung ke data itu dari luar.
Caranya: property dijadikan private, dan satu-satunya jalan mengubahnya adalah lewat method yang sudah disediakan Class itu sendiri — biasanya sambil memvalidasi nilainya dulu.
Contoh
Class Termostat menyimpan properti suhu sebagai private. Untuk mengubahnya, harus lewat method naikkanSuhu() atau turunkanSuhu() yang membatasi suhu tetap di rentang 16–30°C — bukan langsung mengubah variabel suhu sembarangan dari luar.
Kenapa penting: mencegah data diubah sembarangan/tidak valid dari luar class.
Kode (Java)public class Termostat {
private int suhu = 22; // private = tidak bisa diakses langsung dari luar
void naikkanSuhu() {
if (suhu < 30) suhu += 1;
}
void turunkanSuhu() {
if (suhu > 16) suhu -= 1;
}
}
Termostat ac = new Termostat();
ac.naikkanSuhu(); // OK, lewat method
// ac.suhu = 100; // ERROR — properti private tidak bisa diakses dari luar
5
Inheritance
Pilar kedua: mekanisme di mana satu class bisa mewarisi properti dan method dari class lain, tanpa perlu menulis ulang kode yang sama.
Contoh
Class Kendaraan punya method bergerak() dan berhenti(). Class Motor dan Sepeda mewarisi dari Kendaraan, otomatis punya bergerak() dan berhenti() juga, plus bisa menambah method sendiri (misal Motor punya isiBensin()).
Istilah: class yang diwarisi disebut superclass / parent class (di sini: Kendaraan). Class yang mewarisi disebut subclass / child class (Motor, Sepeda).
Kode (Java)public class Kendaraan {
void bergerak() { System.out.println("Bergerak"); }
void berhenti() { System.out.println("Berhenti"); }
}
public class Motor extends Kendaraan { // "extends" = mewarisi dari Kendaraan
void isiBensin() { System.out.println("Mengisi bensin"); }
}
Motor motor = new Motor();
motor.bergerak(); // diwarisi dari Kendaraan, tidak perlu ditulis ulang
motor.isiBensin(); // method baru, cuma milik Motor
6
Polymorphism
Pilar ketiga: kemampuan satu method/interface yang sama untuk menghasilkan perilaku berbeda tergantung object yang memanggilnya.
Contoh
Masih dari class Kendaraan: method bunyikanKlakson() di-override berbeda-beda — Motor menghasilkan "Brm brm", Sepeda menghasilkan "Kring kring". Kalau kode memanggil bunyikanKlakson() pada object mana pun tanpa tahu tipe spesifiknya, hasilnya otomatis menyesuaikan.
Kenapa berguna: bisa menulis kode generik yang bekerja untuk banyak tipe object berbeda, tanpa perlu if-else untuk tiap tipe satu-satu.
Kode (Java)public class Motor extends Kendaraan {
void bunyikanKlakson() { System.out.println("Brm brm"); }
}
public class Sepeda extends Kendaraan {
void bunyikanKlakson() { System.out.println("Kring kring"); }
}
void bunyikan(Kendaraan k) { // parameter bertipe superclass
k.bunyikanKlakson(); // tidak perlu tahu tipe spesifiknya
}
bunyikan(new Motor()); // "Brm brm"
bunyikan(new Sepeda()); // "Kring kring" — perilaku beda, method sama
7
Abstraction
Pilar keempat: menyederhanakan interaksi dengan sesuatu yang kompleks, dengan hanya menampilkan fungsionalitas penting dan menyembunyikan detail implementasi yang rumit.
Analogi
Saat memakai mesin cuci, kamu cukup menekan tombol "Mulai" — tanpa perlu paham detail mekanisme motor penggerak dan pompa air di dalamnya.
Beda dengan Encapsulation: Abstraction fokus menyembunyikan KOMPLEKSITAS (supaya pemakai nggak pusing dengan detail), sedangkan Encapsulation fokus membatasi AKSES ke data (supaya nggak diubah sembarangan). Keduanya sering dipakai bersamaan, tapi tujuannya beda — ini pasangan konsep yang paling sering tertukar di soal.
Kode (Java)public class MesinCuci {
public void mulai() { // satu-satunya yang perlu dipanggil
putarMotor();
pompaAir();
System.out.println("Cucian selesai!");
}
private void putarMotor() { /* detail rumit disembunyikan */ }
private void pompaAir() { /* detail rumit disembunyikan */ }
}
MesinCuci cuci = new MesinCuci();
cuci.mulai(); // pengguna cukup panggil ini, tidak perlu tahu detailnya
Tahap 3 · Istilah yang Sering Muncul
8
Overriding
Overriding adalah ketika sebuah subclass menuliskan ULANG implementasi method yang sudah ada di superclass, dengan signature yang SAMA PERSIS (nama & parameter identik) — isinya diganti dengan perilaku baru. Ini BUKAN salah satu dari 4 Pilar, tapi istilah teknis yang sering jadi MEKANISME di balik Polymorphism (lihat Tahap 2).
Contoh
Class AlatMusik (superclass) punya method mainkanMusik() yang menampilkan "Memainkan alat musik" secara umum. Class Gitar (subclass dari AlatMusik) menimpa ulang method mainkanMusik() itu, dengan nama & parameter identik, supaya menampilkan "Memetik senar gitar" sebagai gantinya.
Kenapa berguna: subclass bisa punya perilaku lebih spesifik/berbeda dari superclass-nya, tanpa perlu membuat method baru dengan nama lain — cukup timpa ulang method yang sudah ada.
Catatan: Overriding HANYA terjadi antara superclass dan subclass (lewat pewarisan), dan signature method-nya harus sama persis — kalau parameternya beda, itu bukan Overriding, tapi Overloading (dibahas di bawah).
Kode (Java)public class AlatMusik {
void mainkanMusik() {
System.out.println("Memainkan alat musik");
}
}
public class Gitar extends AlatMusik {
@Override // menandai bahwa ini menimpa method superclass
void mainkanMusik() {
System.out.println("Memetik senar gitar");
}
}
Gitar gitar = new Gitar();
gitar.mainkanMusik(); // "Memetik senar gitar" — versi Gitar yang jalan
Catatan Java: anotasi @Override tidak wajib secara sintaks, tapi sangat disarankan — kompilator akan memberi error kalau ternyata method itu TIDAK benar-benar menimpa method superclass mana pun (misal karena salah ketik nama method), jadi anotasi ini mencegah kesalahan tanpa sadar.
9
Overloading
Overloading adalah ketika sebuah class punya BEBERAPA method dengan NAMA SAMA, tapi jumlah/tipe parameter berbeda — semuanya berada DALAM SATU class yang sama (tidak melibatkan pewarisan sama sekali). Seperti Overriding, ini BUKAN salah satu dari 4 Pilar, tapi istilah yang sering muncul berdampingan dan gampang tertukar dengan Overriding.
Contoh
Class Undangan punya dua method bernama kirim(): satu versi kirim(nama) hanya menerima nama penerima, versi lain kirim(nama, alamat) menerima nama sekaligus alamat pengiriman. Keduanya ada dalam class Undangan yang sama.
Kenapa berguna: memberi fleksibilitas memanggil method yang sama dengan cara berbeda, tergantung informasi apa yang tersedia saat itu.
Cara gampang mengingat (vs Overriding): Overloading = "beban lebih" dalam SATU class (banyak versi method nama sama). Overriding = "menimpa" method dari class LAIN (induk ke turunan). Dua istilah ini sering tertukar karena bunyinya mirip, padahal konteksnya beda jauh — satu class vs lintas class.
Kode (Java)public class Undangan {
void kirim(String nama) {
System.out.println("Undangan untuk " + nama);
}
void kirim(String nama, String alamat) { // nama sama, parameter beda
System.out.println("Undangan untuk " + nama + ", dikirim ke " + alamat);
}
}
Undangan u = new Undangan();
u.kirim("Sari"); // panggil versi 1 parameter
u.kirim("Budi", "Jl. Merdeka 1"); // panggil versi 2 parameter
Catatan: beda dengan PHP yang TIDAK mendukung Overloading klasik (dua method nama sama dalam satu class akan error "Cannot redeclare"), Java justru mendukungnya secara native persis seperti contoh di atas, asal jumlah atau tipe parameternya berbeda.
Ini rangkuman buatan sendiri untuk latihan, bukan materi resmi Apple Developer Academy — cocok buat pegangan cepat sebelum mengerjakan soal.