Mengenal Class dan Object dalam TypeScript: Constructor, Property, dan Access Modifier

Dalam tutorial kali ini kita akan Mengenal Class dan Object dalam TypeScript: Constructor, Property, dan Access Modifier. Sebagaimana diketahui pemrograman berorientasi objek (OOP), Class TypeScript memiliki peran penting sebagai cetak biru untuk membuat objek yang memiliki data (property) dan perilaku (method). Dengan adanya class, kode menjadi lebih terstruktur, mudah dikelola, dan dapat digunakan kembali. TypeScript menambahkan sistem tipe yang kuat pada konsep class dari JavaScript, sehingga pengembang dapat menulis kode dengan lebih aman dan efisien.

Selain itu, TypeScript juga mendukung fitur-fitur khas OOP seperti constructor, inheritance (pewarisan), dan access modifier seperti public, private, dan protected. Fitur-fitur ini membantu menjaga enkapsulasi data serta membatasi akses agar tidak sembarangan dimodifikasi dari luar. Mari kita bahas lebih dalam bagaimana cara membuat dan menggunakan class serta object di TypeScript.

Apa Itu Class dan Object?

Class adalah template atau blueprint yang digunakan untuk membuat object. Sementara object adalah hasil instance dari class tersebut. Dengan menggunakan class, kamu bisa membuat banyak objek yang memiliki struktur dan fungsi yang sama.

Contoh sederhana:

class Mobil {
  merk: string;
  tahun: number;

  constructor(merk: string, tahun: number) {
    this.merk = merk;
    this.tahun = tahun;
  }

  infoMobil(): void {
    console.log(`Mobil ${this.merk} tahun ${this.tahun}`);
  }
}

const mobil1 = new Mobil("Toyota", 2022);
mobil1.infoMobil(); // Output: Mobil Toyota tahun 2022

Pada contoh di atas:

• merk dan tahun adalah property.

• constructor digunakan untuk menginisialisasi property saat objek dibuat.

• infoMobil() adalah method yang memberikan perilaku pada objek.

Constructor, Property, dan Method

Constructor adalah fungsi khusus di dalam class yang otomatis dipanggil saat objek dibuat. Biasanya digunakan untuk memberikan nilai awal pada property.

Property adalah variabel yang dimiliki oleh setiap objek hasil instance class.

Method adalah fungsi yang didefinisikan di dalam class untuk memberikan perilaku tertentu.

Berikut contoh implementasi yang lebih kompleks:

class Buku {
  judul: string;
  penulis: string;
  halaman: number;

  constructor(judul: string, penulis: string, halaman: number) {
    this.judul = judul;
    this.penulis = penulis;
    this.halaman = halaman;
  }

  baca(): void {
    console.log(`Membaca buku "${this.judul}" karya ${this.penulis}.`);
  }

  infoBuku(): string {
    return `${this.judul} memiliki ${this.halaman} halaman.`;
  }
}

const buku1 = new Buku("Belajar TypeScript", "Arvian", 150);
buku1.baca();
console.log(buku1.infoBuku());

Dengan struktur seperti ini, kamu dapat membuat banyak objek buku yang berbeda dengan mudah tanpa perlu menulis ulang kode untuk setiap properti dan perilaku.

Access Modifier: Public, Private, dan Protected

TypeScript menyediakan access modifier untuk mengatur sejauh mana properti atau method bisa diakses dari luar class. Terdapat tiga jenis access modifier utama:

Modifier	Deskripsi
public	Dapat diakses dari mana saja (default).
private	Hanya dapat diakses dari dalam class itu sendiri.
protected	Dapat diakses dari class itu sendiri dan class turunannya.

Mari lihat contoh penerapannya:

class AkunBank {
  public namaPemilik: string;
  private saldo: number;
  protected noRekening: string;

  constructor(namaPemilik: string, saldoAwal: number, noRekening: string) {
    this.namaPemilik = namaPemilik;
    this.saldo = saldoAwal;
    this.noRekening = noRekening;
  }

  public cekSaldo(): void {
    console.log(`Saldo saat ini: Rp${this.saldo}`);
  }

  public setor(uang: number): void {
    this.saldo += uang;
    console.log(`Setoran berhasil. Saldo baru: Rp${this.saldo}`);
  }

  private validasiSaldo(uang: number): boolean {
    return this.saldo >= uang;
  }

  public tarik(uang: number): void {
    if (this.validasiSaldo(uang)) {
      this.saldo -= uang;
      console.log(`Penarikan berhasil. Sisa saldo: Rp${this.saldo}`);
    } else {
      console.log("Saldo tidak mencukupi!");
    }
  }
}

const akun1 = new AkunBank("Rina", 1000000, "1234567890");
akun1.cekSaldo();
akun1.setor(500000);
akun1.tarik(300000);
// akun1.saldo; ❌ Error karena private

Penjelasan:

• public membuat properti/method dapat diakses dari mana saja.

• private melindungi data agar tidak bisa diubah langsung dari luar class.

• protected bisa digunakan di dalam subclass, tetapi tidak bisa diakses langsung dari instance luar.

Contoh Pewarisan (Inheritance)

Access modifier juga berperan penting dalam konsep pewarisan. Contohnya:

class RekeningBisnis extends AkunBank {
  public bonus: number = 0;

  tambahBonus(): void {
    this.bonus += 100000;
    console.log(`Bonus ditambahkan! Total bonus: Rp${this.bonus}`);
  }

  tampilkanRekening(): void {
    console.log(`Nomor rekening (protected): ${this.noRekening}`);
  }
}

const akunBisnis = new RekeningBisnis("Budi", 5000000, "9988776655");
akunBisnis.tambahBonus();
akunBisnis.tampilkanRekening();

Pada contoh di atas, class RekeningBisnis dapat mengakses noRekening karena bersifat protected, namun tidak dapat mengakses saldo karena bersifat private.

Kesimpulan

Class TypeScript memungkinkan pengembang menulis kode yang lebih terstruktur dan modular melalui konsep OOP (Object-Oriented Programming). Dengan memanfaatkan constructor, property, dan method, kamu dapat membuat objek yang memiliki data serta perilaku sendiri.

Selain itu, fitur access modifier seperti public, private, dan protected membantu menjaga keamanan dan integritas data dengan membatasi akses sesuai kebutuhan. Dengan memahami dasar ini, kamu sudah siap melangkah ke topik berikutnya seperti inheritance, abstraction, dan interface implementation dalam TypeScript untuk pengembangan aplikasi yang lebih kompleks.