BAB 19 — OOP (Object-Oriented Programming) di JavaScript: Membuat Kode Lebih Terstruktur dan Reusable

Object-Oriented Programming (OOP) adalah paradigma pemrograman yang menggunakan objek dan class untuk mengatur data dan perilaku.

JavaScript modern mendukung OOP melalui class syntax ES6, memungkinkan developer menulis kode lebih modular, reusable, dan maintainable.

---

1. Class & Constructor

Class adalah blueprint untuk membuat objek. Constructor adalah metode khusus yang dipanggil saat objek dibuat.

class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
}

const alice = new Person("Alice", 25);
console.log(alice.name); // Alice
console.log(alice.age);  // 25

Tips:

• Gunakan constructor untuk menginisialisasi properti objek.
• Nama class biasanya PascalCase.

---

2. Method

Method adalah fungsi di dalam class yang berinteraksi dengan properti objek.

class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }

    greet() {
        console.log(`Hello, nama saya ${this.name}`);
    }

    birthday() {
        this.age += 1;
        console.log(`Usia saya sekarang ${this.age}`);
    }
}

const bob = new Person("Bob", 30);
bob.greet();      // Hello, nama saya Bob
bob.birthday();   // Usia saya sekarang 31

Insight:

• Method bisa mengakses properti melalui this.
• Method memungkinkan behavior encapsulation, menyatukan data dan aksi.

---

3. Inheritance

Inheritance memungkinkan class mewarisi properti dan method dari parent class, sehingga kode lebih reusable.

class Employee extends Person {
    constructor(name, age, position) {
        super(name, age); // panggil constructor parent
        this.position = position;
    }

    describe() {
        console.log(`${this.name} bekerja sebagai ${this.position}`);
    }
}

const emp = new Employee("Charlie", 28, "Developer");
emp.greet();     // inherited method → Hello, nama saya Charlie
emp.describe();  // Charlie bekerja sebagai Developer

• extends → menandakan inheritance.
• super() → memanggil constructor parent.

Tips:

• Gunakan inheritance untuk menghindari duplikasi kode.
• Jangan overuse inheritance → pertimbangkan composition jika perilaku berbeda drastis.

---

4. Super

super digunakan untuk:

1. Memanggil constructor parent
2. Memanggil method parent

class Manager extends Employee {
    constructor(name, age, department) {
        super(name, age, "Manager");
        this.department = department;
    }

    greet() {
        super.greet(); // memanggil greet() dari Person
        console.log(`Saya mengelola departemen ${this.department}`);
    }
}

const mgr = new Manager("Dana", 35, "IT");
mgr.greet();
// Hello, nama saya Dana
// Saya mengelola departemen IT

Insight:

• super menjaga kode DRY dan konsistensi perilaku parent.

---

5. Encapsulation (Private Field)

Encapsulation menjaga data internal class tetap aman. JavaScript modern mendukung private field dengan #.

class BankAccount {
    #balance;

    constructor(initialBalance) {
        this.#balance = initialBalance;
    }

    deposit(amount) {
        this.#balance += amount;
        console.log(`Saldo sekarang: ${this.#balance}`);
    }

    getBalance() {
        return this.#balance;
    }
}

const account = new BankAccount(1000);
account.deposit(500);           // Saldo sekarang: 1500
console.log(account.getBalance()); // 1500
// console.log(account.#balance); // Error: private field

Tips:

• Gunakan private field untuk menyembunyikan data sensitif atau internal logic.
• Public method → interface aman untuk mengakses private field.

---

6. Static Method

Static method adalah method milik class, bukan objek, dan bisa dipanggil tanpa membuat instance.

class MathUtils {
    static square(x) {
        return x * x;
    }
}

console.log(MathUtils.square(5)); // 25

const mu = new MathUtils();
// mu.square(5); // Error: square bukan method instance

Kegunaan:

• Utility atau helper function yang tidak membutuhkan state objek.
• Contoh: Math operations, validation, conversion.

---

7. Praktik Terbaik OOP di JavaScript

1. Gunakan class untuk blueprint objek yang jelas.
2. Gunakan inheritance untuk shared behavior, tapi hindari deep hierarchy.
3. Gunakan private field (#) untuk data sensitif atau internal.
4. Gunakan static method untuk utility yang tidak terkait instance.
5. Pisahkan data dan logic dengan method, hindari manipulasi langsung dari luar class.
6. Gunakan super() saat inheritance untuk mengakses constructor dan method parent.

---

8. Contoh Kasus Nyata

8.1 Sistem Bank

class Account {
    #balance;
    constructor(owner, balance){
        this.owner = owner;
        this.#balance = balance;
    }
    deposit(amount){ this.#balance += amount; }
    withdraw(amount){ this.#balance -= amount; }
    getBalance(){ return this.#balance; }
}

class SavingsAccount extends Account {
    constructor(owner, balance, interestRate){
        super(owner, balance);
        this.interestRate = interestRate;
    }
    addInterest(){
        this.deposit(this.getBalance() * this.interestRate);
    }
}

const myAccount = new SavingsAccount("Alice", 1000, 0.05);
myAccount.addInterest();
console.log(myAccount.getBalance()); // 1050

8.2 Utility Class

class StringUtils {
    static capitalize(str){
        return str.charAt(0).toUpperCase() + str.slice(1);
    }
}

console.log(StringUtils.capitalize("hello")); // Hello

---

9. Kesimpulan

• OOP di JavaScript memungkinkan kode modular, reusable, dan maintainable.
• Class → blueprint objek, constructor → inisialisasi properti, method → behavior.
• Inheritance & super → berbagi perilaku parent dan menjaga DRY.
• Encapsulation → melindungi data internal dengan private field (#).
• Static method → fungsi utilitas yang tidak terkait instance.
• Praktik OOP yang baik meningkatkan readability, keamanan data, dan struktur aplikasi.

💡 Insight: Menguasai OOP sangat penting di aplikasi skala besar, framework modern, dan enterprise projects karena membantu developer menulis kode yang bersih, modular, dan mudah di-maintain.