Dasar Object-oriented Programming dalam Typescript

Pemrograman Berorientasi Objek (OOP) adalah paradigma pemrograman yang berfokus pada objek sebagai unit utama untuk mengorganisasi dan mengelola kode. Dalam TypeScript, OOP diterapkan melalui penggunaan kelas (class), objek, properti (properties), dan metode (methods).

Konsep Dasar

Class

Dalam TypeScript, Kita dapat menggunakan "class" untuk membuat objek yang memiliki sifat-sifat (properties) dan perilaku/fungsi (methods) tertentu. Class adalah kerangka dasar yang digunakan untuk membuat objek, bayangkan ini seperti pembungkus dari banyak fungsi yang memiliki kesamaan. Contoh class:

class Kendaraan {
    constructor() {
    }
}

// Membuat objek dari class Kendaraan
const mobil = new Kendaraan();

Property

Properti adalah variabel yang terkait dengan suatu objek atau kelas. Digunakan untuk menyimpan data atau informasi yang berkaitan dengan objek tersebut. Dalam TypeScript, Anda dapat mendefinisikan properti dalam sebuah class.

Contoh properti dalam sebuah class:

class Kendaraan {
  roda: number;
  bahanBakar: string;
}

Dalam contoh di atas, class Kendaraan memiliki dua properti: roda yang bertipe number dan bahanBakar yang bertipe string. Properti ini akan digunakan untuk menyimpan informasi tentang jumlah roda dan jenis bahan bakar dari kendaraan.

Kita dapat mengakses properti objek dengan menggunakan notasi dot (.). Contoh:

const mobil = new Kendaraan();
mobil.roda = 4;
mobil.bahanBakar = 'bensin';

Method

Method adalah fungsi yang terkait dengan suatu objek atau kelas. Mereka digunakan untuk mendefinisikan fungsi, perilaku atau tindakan yang dapat dilakukan oleh objek tersebut.

class Kendaraan {
    roda: number;
    bahanBakar: string;

    constructor(roda: number, bahanBakar: string) {
        this.roda = roda;
        this.bahanBakar = bahanBakar;
    }

    bergerak(): void {
        console.log(`Kendaraan bergerak dengan ${this.roda} roda dan menggunakan ${this.bahanBakar} sebagai bahan bakar.`);
    }
}

Dalam contoh di atas, class Kendaraan memiliki satu method yaitu bergerak. Method ini digunakan untuk mencetak informasi tentang bagaimana kendaraan bergerak.

Mari lihat contoh penggunaan penuh:

class Kendaraan {
  roda: number;
  bahanBakar: string;

  constructor(roda: number, bahanBakar: string) {
    this.roda = roda;
    this.bahanBakar = bahanBakar;
  }

  bergerak(): void {
    console.log(`Kendaraan bergerak dengan ${this.roda} roda dan menggunakan ${this.bahanBakar} sebagai bahan bakar.`);
  }
}

// Membuat objek dari class Kendaraan
const mobil = new Kendaraan(4, 'bensin');
mobil.bergerak(); // Output: Kendaraan bergerak dengan 4 roda dan menggunakan bensin sebagai bahan bakar.

Dalam contoh di atas, kita telah membuat class Kendaraan dengan dua properti (roda dan bahan bakar) dan satu method (bergerak). Method constructor digunakan untuk menginisialisasi objek saat objek dibuat. Method bergerak mencetak informasi tentang kendaraan.

Konsep Lanjutan

A. Inheritance

Pewarisan (Inheritance): Konsep ini memungkinkan kita untuk membuat kelas baru yang mewarisi properti dan metode dari kelas yang sudah ada. Ini membantu dalam pembuatan hierarki kelas dan penggunaan kembali kode (Reusable Code).

• Kelas Induk (Base Class atau Super Class): Kelas yang memberikan fungsi dan properti umum yang akan diwariskan ke kelas anak.
• Kelas Anak (Derived Class atau Sub Class): Kelas yang mewarisi fungsi dan properti dari kelas induk, dan juga dapat memiliki fungsi dan properti tambahan yang spesifik untuk dirinya sendiri.

Contoh:

// Kelas Induk (Parent)
class Hewan {
    nama: string;

    constructor(nama: string) {
        this.nama = nama;
    }

    makan() {
        console.log(`${this.nama} sedang makan.`);
    }
}

// Kelas Anak (Child)
class Kucing extends Hewan {
    tidur() {
        console.log(`${this.nama} sedang tidur.`);
    }
}

// Membuat objek dari kelas anak
const kucing = new Kucing("Kitty");
kucing.makan(); // Memanggil metode dari kelas induk
kucing.tidur(); // Memanggil metode dari kelas anak

Dalam contoh di atas, kita memiliki kelas induk Hewan yang memiliki properti nama dan metode makan(). Kemudian kita memiliki kelas anak Kucing yang menggunakan extends untuk mewarisi semua properti dan metode dari kelas Hewan. Selain itu, kelas Kucing juga memiliki metode tambahan tidur().

Dengan inheritance, kita dapat menggunakan kode yang sudah ada dalam kelas induk dan membuat kelas anak yang memiliki fungsi tambahan atau modifikasi yang sesuai dengan kebutuhan kita. Hal ini memungkinkan penggunaan kembali (reuse) kode dan mempermudah pemeliharaan.

B. Polimorfisme (Polymorphism)

Adalah konsep di mana objek dari kelas yang berbeda dapat memiliki fungsi yang sama atau nama metode yang sama, tetapi implementasinya berbeda. Polimorfisme memungkinkan kita untuk menggunakan method yang sama pada objek yang berbeda tanpa perlu mengetahui tipe objek tersebut.

Function Overloading

ketika dua atau lebih metode dengan nama yang sama ada dalam sebuah kelas, tetapi dengan parameter yang berbeda. Saat objek dipanggil dengan metode tersebut, bahasa pemrograman akan menentukan metode mana yang harus dijalankan berdasarkan jenis dan jumlah parameter yang diberikan.

Contoh TypeScript:

class Matematika {
    tambah(x: number, y: number): number {
        return x + y;
    }

    tambah(x: string, y: string): string {
        return x + y;
    }
}

const mat = new Matematika();
console.log(mat.tambah(2, 3)); // Output: 5
console.log(mat.tambah("Hello", " World")); // Output: "Hello World"

Inheritance Polymorphism

Terjadi ketika objek dari kelas anak dapat digunakan secara interchangeably dengan objek dari kelas induk (Parent). Dalam hal ini, metode dari kelas anak dapat menggantikan metode dari kelas induk.

Contoh TypeScript:

class Hewan {
    bersuara() {
        console.log("Hewan bersuara.");
    }
}

class Anjing extends Hewan {
    bersuara() {
        console.log("Anjing menggonggong.");
    }
}

class Kucing extends Hewan {
    bersuara() {
        console.log("Kucing mengeong.");
    }
}

function suaraHewan(hewan: Hewan) {
    hewan.bersuara();
}

const hewan1 = new Anjing();
const hewan2 = new Kucing();

suaraHewan(hewan1); // Output: "Anjing menggonggong."
suaraHewan(hewan2); // Output: "Kucing mengeong."

Dalam contoh di atas, kelas Anjing dan Kucing mewarisi kelas Hewan, tetapi memiliki implementasi berbeda untuk metode bersuara(). Meskipun kita menggunakan variabel hewan dengan tipe Hewan, kita dapat menggantinya dengan objek dari kelas anak seperti Anjing atau Kucing, dan metode yang sesuai akan dipanggil berdasarkan jenis objek tersebut.

C. Abstraksi (Abstraction)

Segera

D. Enkapsulasi (Encapsulation)

Segera

E. Komposisi (Composition)

Segera

F. Kontrak (Interface)

Segera