Belajar TypeScript - Class, Inheritance, Modifiers, dan Abstraksi

#Pendahuluan

Class di TypeScript adalah class JavaScript yang diperkuat sistem tipe. Di atas sintaks class standar, TypeScript menambahkan deklarasi properti yang harus diinisialisasi, modifier akses yang dijamin compiler, serta kemampuan menandai anggota abstrak. Hasilnya adalah OOP yang bisa diandalkan untuk model domain yang kompleks.

Sebagian komunitas modern lebih suka fungsi dan objek polos. Namun class tetap menjadi pilihan utama di banyak codebase, terutama yang berinteraksi dengan kerangka kerja berorientasi objek atau yang butuh antarmuka perilaku yang jelas.

Episode 9 membedah cara menulis class bertipe, mewarisi dari class lain, mengatur visibilitas anggota, dan merancang abstraksi dengan abstract class serta interface.

#Menulis Class Bertipe

#Properti dan Constructor

Properti harus dideklarasikan dan diinisialisasi sebelum dipakai:

class Akun {
    nama: string;
    saldo: number;
 
    constructor(nama: string, saldo: number) {
        this.nama = nama;
        this.saldo = saldo;
    }
 
    simpan(amount: number): void {
        this.saldo += amount;
    }
}

Deklarasi nama: string dan saldo: number adalah kontrak properti. Constructor menerima argumen bertipe dan menyalinnya ke properti. Metode simpan memodifikasi saldo dengan argumen number. TypeScript memastikan tidak ada properti yang dipakai sebelum diinisialisasi.

#Parameter Properties

TypeScript menyediakan cara ringkas mendeklarasikan properti langsung dari parameter constructor:

class Akun {
    constructor(
        public nama: string,
        private saldo: number = 0,
    ) {}
 
    tampilkanSaldo(): number {
        return this.saldo;
    }
}

Parameter yang diberi modifier seperti public atau private otomatis menjadi properti. Kode di atas setara dengan deklarasi properti plus penyalinan manual di constructor, tapi jauh lebih ringkas.

#Inheritance

Class bisa mewarisi properti dan metode dari class lain:

class Tabungan extends Akun {
    private bunga: number;
 
    constructor(nama: string, saldo: number, bunga: number) {
        super(nama, saldo);
        this.bunga = bunga;
    }
 
    tambahBunga(): void {
        const nilai = (this.saldo * this.bunga) / 100;
        this.simpan(nilai);
    }
}

Kata kunci extends membuat Tabungan memiliki semua yang dimiliki Akun. Constructor subclass harus memanggil super sebelum menyentuh this. Method bisa ditimpa untuk menyesuaikan perilaku, dan TypeScript memeriksa kesesuaian tipe saat overriding.

#Access Modifiers

#public, private, dan protected

Modifier mengatur siapa yang boleh mengakses anggota:

class Rekening {
    public pemilik: string;
    protected history: string[] = [];
    private pin: number;
 
    constructor(pemilik: string, pin: number) {
        this.pemilik = pemilik;
        this.pin = pin;
    }
}

public bisa diakses dari mana saja dan menjadi bawaan. protected hanya bisa diakses dari dalam class dan subclass. private hanya bisa diakses dari dalam class yang sama. Modifier ini mencegah penggunaan anggota internal yang seharusnya tersembunyi, dan dicek penuh oleh compiler.

#readonly untuk Properti

Properti yang tidak boleh berubah setelah inisialisasi diberi readonly:

class Transaksi {
    readonly id: string;
 
    constructor(id: string) {
        this.id = id;
    }
}

Properti id hanya bisa diberi nilai saat deklarasi atau di constructor. Setelah itu, penulisan ulang akan error. readonly bisa dikombinasikan dengan modifier akses seperti private readonly.

#Abstract Class dan implements

#Abstract Class

Abstract class adalah cetak biru yang tidak bisa di-instance langsung:

abstract class Pembayaran {
    abstract jumlah(): number;
 
    deskripsi(): string {
        return `Total: ${this.jumlah()}`;
    }
}
 
class Kartu extends Pembayaran {
    jumlah(): number {
        return 50_000;
    }
}

Metode abstract jumlah() dideklarasikan tanpa tubuh; setiap subclass wajib mengimplementasikannya. Metode konkret seperti deskripsi bisa memanggil metode abstrak. Pola ini memaksa konsistensi struktur tanpa menyalin implementasi.

#implements untuk Kontrak

Class juga bisa berjanji memenuhi bentuk interface dengan implements:

interface Penyimpan {
    simpan(data: string): void;
}
 
class FilePenyimpan implements Penyimpan {
    simpan(data: string): void {
        console.log(`Menulis: ${data}`);
    }
}

implements memaksa class menyediakan semua anggota yang diminta interface. Berbeda dengan extends, tidak ada pewarisan implementasi, hanya pemeriksaan struktur.

#Penutup

Episode 9 membekali kalian dengan OOP bertipe penuh: properti yang terjamin, parameter properties yang ringkas, inheritance dengan pemeriksaan tipe, modifier akses, serta abstraksi melalui abstract class dan interface.

Inti yang harus dibawa pulang:

• Properti class harus dideklarasikan dan diinisialisasi.
• Parameter properties menyingkat deklarasi properti dari constructor.
• extends mewarisi perilaku; subclass wajib memanggil super.
• public terbuka, protected untuk subclass, private untuk class sendiri.
• readonly mengunci properti setelah inisialisasi.
• Abstract class menyediakan cetak biru; implements memaksa kontrak interface.

Di episode 10 selanjutnya kita akan membahas namespace, modul, dan import/export tipe, yaitu cara mengorganisir kode dan tipe ke dalam unit yang terisolasi dan mudah diimpor.