Belajar JavaScript OOP: Pemrograman Berorientasi Objek

Pengantar OOP dalam JavaScript

Pemrograman Berorientasi Objek (OOP) adalah paradigma pemrograman yang menggunakan "objek" untuk mendesain aplikasi dan program. JavaScript, meskipun awalnya bukan bahasa OOP murni, telah mengadopsi banyak konsep OOP melalui fitur-fitur seperti class, inheritance, encapsulation, dan polymorphism.

Dalam artikel ini, kita akan menjelajahi berbagai aspek OOP di JavaScript modern, mulai dari class dasar hingga fitur-fitur canggih seperti private field dan static method. Dengan memahami OOP, Anda dapat menulis kode yang lebih terstruktur, mudah dipelihara, dan dapat digunakan kembali.

Class dalam JavaScript

Class adalah blueprint untuk membuat objek. Di JavaScript, class diperkenalkan di ES6 sebagai sintaks yang lebih jelas untuk membuat objek dan menangani inheritance.

Contoh Class Dasar

class Person {
  // Constructor, properties, dan methods akan ditambahkan di sini
}

Class sendiri tidak melakukan apa-apa sampai Anda membuat instance (objek) dari class tersebut:

const person1 = new Person();
console.log(person1); // Person {}

Constructor di Class

Constructor adalah method khusus yang dipanggil otomatis ketika instance class dibuat. Biasanya digunakan untuk inisialisasi properti.

Contoh Constructor

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

const person1 = new Person('Andi', 25);
console.log(person1); // Person { name: 'Andi', age: 25 }

Property di Class

Property adalah data yang dimiliki oleh instance class. Di JavaScript, property biasanya didefinisikan di constructor.

Contoh Property

class Car {
  constructor(brand, year) {
    this.brand = brand;  // Property
    this.year = year;    // Property
  }
}

const myCar = new Car('Toyota', 2020);
console.log(myCar.brand); // Toyota

Method di Class

Method adalah fungsi yang dimiliki oleh class dan dapat dipanggil pada instance class tersebut.

Contoh Method

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

  // Method
  greet() {
    return `Halo, nama saya ${this.name}`;
  }
}

const person1 = new Person('Budi');
console.log(person1.greet()); // Halo, nama saya Budi

Class Inheritance

Inheritance memungkinkan class untuk mewarisi property dan method dari class lain menggunakan kata kunci extends.

Contoh Inheritance

class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    return `${this.name} bersuara`;
  }
}

class Dog extends Animal {
  // Dog mewarisi dari Animal
}

const dog1 = new Dog('Rex');
console.log(dog1.speak()); // Rex bersuara

Super Constructor

super() digunakan untuk memanggil constructor dari parent class. Harus dipanggil sebelum menggunakan this.

Contoh Super Constructor

class Animal {
  constructor(name) {
    this.name = name;
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name); // Memanggil constructor Animal
    this.breed = breed;
  }
}

const dog1 = new Dog('Rex', 'Golden Retriever');
console.log(dog1); // Dog { name: 'Rex', breed: 'Golden Retriever' }

Super Method

super juga bisa digunakan untuk memanggil method dari parent class.

Contoh Super Method

class Animal {
  speak() {
    return 'Bunyi hewan';
  }
}

class Dog extends Animal {
  speak() {
    return super.speak() + ', Guk Guk!';
  }
}

const dog1 = new Dog();
console.log(dog1.speak()); // Bunyi hewan, Guk Guk!

Getter dan Setter di Class

Getter dan setter memungkinkan Anda mendefinisikan akses ke property dengan kontrol lebih.

Contoh Getter dan Setter

class Person {
  constructor(firstName, lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  // Getter
  get fullName() {
    return `${this.firstName} ${this.lastName}`;
  }

  // Setter
  set fullName(name) {
    const [first, last] = name.split(' ');
    this.firstName = first;
    this.lastName = last;
  }
}

const person1 = new Person('Andi', 'Ardiansyah');
console.log(person1.fullName); // Andi Ardiansyah

person1.fullName = 'Budi Nugroho';
console.log(person1.firstName); // Budi

Public Class Field

Public class field memungkinkan mendeklarasikan property langsung dalam class tanpa constructor.

Contoh Public Class Field

class Counter {
  count = 0; // Public class field

  increment() {
    this.count++;
  }
}

const counter = new Counter();
counter.increment();
console.log(counter.count); // 1

Private Class Field

Private field (diawali dengan #) hanya bisa diakses dari dalam class itu sendiri.

Contoh Private Class Field

class Counter {
  #count = 0; // Private field

  increment() {
    this.#count++;
  }

  getCount() {
    return this.#count;
  }
}

const counter = new Counter();
counter.increment();
console.log(counter.getCount()); // 1
console.log(counter.#count); // Error: Private field

Private Method

Seperti private field, private method juga hanya bisa diakses dari dalam class.

Contoh Private Method

class Auth {
  #checkPassword(password) { // Private method
    return password.length >= 8;
  }

  login(username, password) {
    if (this.#checkPassword(password)) {
      return `Welcome ${username}`;
    }
    return 'Password too short';
  }
}

const auth = new Auth();
console.log(auth.login('user1', '12345678')); // Welcome user1
console.log(auth.#checkPassword('123')); // Error: Private method

Operator instanceof

Operator instanceof memeriksa apakah suatu objek adalah instance dari class tertentu.

Contoh instanceof

class Animal {}
class Dog extends Animal {}

const dog = new Dog();

console.log(dog instanceof Dog); // true
console.log(dog instanceof Animal); // true
console.log(dog instanceof Object); // true

Static Field

Static field adalah property yang dimiliki oleh class itu sendiri, bukan instance-nya.

Contoh Static Field

class Config {
  static API_URL = 'https://api.example.com';
}

console.log(Config.API_URL); // https://api.example.com

const config = new Config();
console.log(config.API_URL); // undefined

Static Method

Static method adalah method yang dipanggil pada class itu sendiri, bukan pada instance.

Contoh Static Method

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

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

const utils = new MathUtils();
console.log(utils.square(5)); // Error: utils.square is not a function

Error Handling dalam OOP

Kita bisa membuat custom error class dengan mewarisi dari class Error.

Contoh Custom Error

class ValidationError extends Error {
  constructor(message) {
    super(message);
    this.name = 'ValidationError';
  }
}

function validateInput(input) {
  if (!input) {
    throw new ValidationError('Input tidak boleh kosong');
  }
}

try {
  validateInput('');
} catch (err) {
  if (err instanceof ValidationError) {
    console.error(err.message); // Input tidak boleh kosong
  }
}

Kesimpulan

OOP dalam JavaScript modern menyediakan banyak fitur canggih untuk membangun aplikasi yang terstruktur. Dengan class, inheritance, encapsulation (melalui private field/method), dan static member, kita dapat mengorganisasi kode dengan lebih baik. Fitur-fitur seperti getter/setter memberikan kontrol lebih terhadap akses property, sementara custom error memungkinkan penanganan error yang lebih spesifik.

Memahami konsep-konsep OOP ini penting untuk pengembangan aplikasi JavaScript yang scalable dan maintainable. Meskipun JavaScript menggunakan prototypal inheritance di balik layar, sintaks class membuat OOP lebih mudah dipahami bagi developer yang berasal dari bahasa OOP tradisional.