Cara Menggunakan Kelas TypeScript dengan Contoh Sederhana

TypeScript menghadirkan fitur-fitur canggih pada JavaScript, termasuk konsep kelas, yang memungkinkan pemrograman berorientasi objek. Kelas menyediakan cetak biru untuk membuat objek, merangkum data, dan mendefinisikan perilaku. Panduan ini akan memandu Anda melalui dasar-dasar kelas TypeScript dengan contoh-contoh sederhana.

Apa itu Kelas?

Kelas adalah cetak biru untuk membuat objek dengan properti dan metode yang telah ditentukan sebelumnya. Kelas membantu dalam mengatur kode, meningkatkan penggunaan ulang, dan membuat aplikasi yang dapat diskalakan. Kelas dalam TypeScript bekerja sama dengan kelas dalam bahasa pemrograman berorientasi objek lainnya.

Mendefinisikan Kelas Dasar

Untuk mendefinisikan kelas dalam TypeScript, gunakan kata kunci class diikuti dengan nama kelas dan serangkaian kurung kurawal yang berisi properti dan metode.

Contoh Kelas Dasar

Berikut adalah contoh kelas Person sederhana dengan properti dan metode:

class Person {
  name: string;
  age: number;

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

  greet(): void {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

const person1 = new Person("Alice", 30);
person1.greet(); // Output: Hello, my name is Alice and I am 30 years old.

Dalam contoh ini, kelas Person memiliki dua properti: name dan age. Metode konstruktor menginisialisasi properti ini, dan metode greet menghasilkan pesan ucapan.

Pengubah Akses

TypeScript menyediakan tiga pengubah akses untuk mengontrol visibilitas anggota kelas:

• public: Anggota dapat diakses dari mana saja (default).
• private: Anggota hanya dapat diakses di dalam kelas.
• protected: Anggota dapat diakses dalam kelas dan subkelasnya.

Menggunakan Pengubah Akses

Berikut ini cara Anda dapat menggunakan pengubah akses di kelas TypeScript:

class Animal {
  public name: string;
  private age: number;

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

  public getAge(): number {
    return this.age;
  }
}

const dog = new Animal("Buddy", 5);
console.log(dog.name); // Output: Buddy
console.log(dog.getAge()); // Output: 5
// console.log(dog.age); // Error: 'age' is private and only accessible within class 'Animal'.

Dalam contoh ini, nama adalah properti publik, yang dapat diakses dari luar kelas, sementara usia adalah properti pribadi, yang hanya dapat diakses di dalam kelas.

Pewarisan dalam TypeScript

TypeScript mendukung pewarisan, yang memungkinkan suatu kelas mewarisi properti dan metode dari kelas lain. Ini membantu dalam penggunaan kembali kode dan pembuatan hierarki kelas.

Contoh Pewarisan

Di bawah ini adalah contoh kelas Anjing yang mewarisi kelas dasar Hewan:

class Animal {
  constructor(public name: string) {}

  makeSound(): void {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name); // Call the constructor of the base class
  }

  makeSound(): void {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog("Buddy");
dog.makeSound(); // Output: Buddy barks.

Dalam contoh ini, kelas Dog memperluas kelas Animal dan mengganti metode makeSound.

Pengambil dan Pengatur

TypeScript memungkinkan Anda menentukan pengambil dan penyetel untuk properti, menyediakan akses terkendali ke anggota kelas.

Contoh Getter dan Setter

class Person {
  private _name: string;

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

  get name(): string {
    return this._name;
  }

  set name(newName: string) {
    if (newName) {
      this._name = newName;
    } else {
      console.log("Name cannot be empty.");
    }
  }
}

const person = new Person("Alice");
console.log(person.name); // Output: Alice
person.name = "Bob";
console.log(person.name); // Output: Bob

Dalam contoh ini, properti name diakses dan dimodifikasi menggunakan metode getter dan setter.

Kesimpulan

Kelas TypeScript merupakan cara yang ampuh untuk menulis kode berorientasi objek dengan cara yang bersih dan efisien. Kelas ini menyediakan cara terstruktur untuk menentukan properti, metode, pengubah akses, pewarisan, dan banyak lagi. Dengan memahami cara menggunakan kelas TypeScript, Anda dapat menulis kode yang lebih tangguh dan mudah dipelihara untuk aplikasi Anda.