Tutorial TypeScript #8: Class dan Object-Oriented Programming (OOP)

• 1. Membuat Class dan Object
• 2. Access Modifier: Public, Private, dan Protected
  • Public (default)
  • Private
  • Protected
• 3. Inheritance (Pewarisan)
• 4. Polymorphism
• Kesimpulan

Halo teman-teman semuanya, pada artikel sebelumnya kita telah belajar bersama-sama tentang Enum dan Tuple di dalam TypeScript dan pada artikel kali ini kita semua akan belajar tentang implementasi Class dan Object Oriented Programming di dalam TypeScript.

TypeScript mendukung paradigma Object-Oriented Programming (OOP) dengan fitur seperti class, object, inheritance, interface, dan access modifier. OOP membantu kita menulis kode yang lebih terstruktur, reusable, dan mudah dipelihara.

1. Membuat Class dan Object

Class adalah blueprint untuk membuat object.

class Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  introduce(): void {
    console.log(`Halo, nama saya ${this.name} dan saya berusia ${this.age} tahun.`);
  }
}

const person1 = new Person("Fika", 25);
person1.introduce(); // Output: Halo, nama saya Fika dan saya berusia 25 tahun.

• class Person memiliki properti name dan age.

• constructor digunakan untuk menginisialisasi properti saat object dibuat.

• Method introduce() menampilkan informasi tentang object.

2. Access Modifier: Public, Private, dan Protected

Access modifier menentukan apakah properti atau method bisa diakses dari luar class.

• Public (default)

  Jika tidak ditentukan, properti atau method bersifat public dan bisa diakses dari mana saja.

  class Animal {
    public name: string;
  
    constructor(name: string) {
      this.name = name;
    }
  }
  
  const cat = new Animal("Kitty");
  console.log(cat.name); // Output: Kitty
  

  name bisa diakses dari luar class karena bersifat public.

• Private

  private hanya bisa diakses di dalam class yang mendeklarasikannya.

  class BankAccount {
    private balance: number;
  
    constructor(balance: number) {
      this.balance = balance;
    }
  
    getBalance(): number {
      return this.balance;
    }
  }
  
  const myAccount = new BankAccount(1000);
  // console.log(myAccount.balance); // ❌ Error: Property 'balance' is private
  console.log(myAccount.getBalance()); // ✅ Output: 1000
  

  balance hanya bisa diakses melalui method getBalance(), bukan langsung dari object.

• Protected

  protected mirip private, tetapi bisa diakses oleh class turunan (subclass).

  class Vehicle {
    protected speed: number = 0;
  
    accelerate(amount: number): void {
      this.speed += amount;
      console.log(`Kecepatan sekarang: ${this.speed} km/h`);
    }
  }
  
  class Car extends Vehicle {
    boost(): void {
      this.accelerate(50);
    }
  }
  
  const myCar = new Car();
  myCar.boost(); // ✅ Output: Kecepatan sekarang: 50 km/h
  

  speed tidak bisa diakses langsung dari object, tetapi bisa digunakan dalam subclass.

3. Inheritance (Pewarisan)

Pewarisan memungkinkan sebuah class mewarisi properti dan method dari class lain.

class Employee {
  name: string;
  role: string;

  constructor(name: string, role: string) {
    this.name = name;
    this.role = role;
  }

  work(): void {
    console.log(`${this.name} bekerja sebagai ${this.role}`);
  }
}

class Manager extends Employee {
  manage(): void {
    console.log(`${this.name} sedang mengelola tim.`);
  }
}

const emp1 = new Employee("Budi", "Developer");
emp1.work(); // ✅ Output: Budi bekerja sebagai Developer

const manager1 = new Manager("Siti", "Manager");
manager1.work(); // ✅ Output: Siti bekerja sebagai Manager
manager1.manage(); // ✅ Output: Siti sedang mengelola tim.

Manager mewarisi Employee, sehingga bisa menggunakan method work() dan menambahkan method manage().

4. Polymorphism

Polymorphism memungkinkan subclass mengubah atau menimpa (override) method dari parent class.

class Animal {
  makeSound(): void {
    console.log("Hewan mengeluarkan suara...");
  }
}

class Dog extends Animal {
  makeSound(): void {
    console.log("Guk guk!");
  }
}

const animal = new Animal();
animal.makeSound(); // ✅ Output: Hewan mengeluarkan suara...

const dog = new Dog();
dog.makeSound(); // ✅ Output: Guk guk!

Dog mengubah method makeSound() agar memiliki perilaku yang berbeda dari Animal.

Kesimpulan

Dalam artikel ini, kita telah belajar tentang:

• Membuat class dan object di TypeScript.
• Access modifier (public, private, protected) untuk kontrol akses properti dan method.
• Inheritance untuk mewarisi properti dan method dari class lain.
• Polymorphism untuk mengubah method dalam subclass.

Pada artikel selanjutnya, kita semua akan belajar tentang Generics di dalam TypeScript.

Terima Kasih