OOP di Javascript menggunakan TypeScript

Pemrograman Berorientasi Objek (OOP) dengan TypeScript

Pemrograman berorientasi objek (OOP) adalah paradigma yang menggunakan objek dan kelas untuk mengorganisir kode. TypeScript, yang merupakan superset dari JavaScript, memungkinkan kita untuk menambahkan tipe statis ke dalam aplikasi JavaScript, meningkatkan keamanan dan pemeliharaan kode. Dalam artikel ini, kita akan membahas konsep dasar OOP di TypeScript, termasuk kelas, objek, inheritance, polymorphism, encapsulation, dan abstraction.

1. Apa itu OOP?

OOP adalah paradigma pemrograman yang berfokus pada objek, yang dapat memiliki data dan metode untuk mengelola data tersebut. Beberapa konsep utama dalam OOP adalah:

• Encapsulation (Enkapsulasi): Menyembunyikan detail implementasi dan hanya menampilkan antarmuka yang diperlukan.
• Inheritance (Pewarisan): Membuat kelas baru yang mewarisi sifat dan perilaku dari kelas lain.
• Polymorphism (Polimorfisme): Mengizinkan objek dari kelas yang berbeda untuk menggunakan metode yang sama dengan implementasi yang berbeda.
• Abstraction (Abstraksi): Menyembunyikan kompleksitas dan hanya menunjukkan informasi yang relevan kepada pengguna.

2. Membuat Kelas dan Objek di TypeScript

Di TypeScript, kita bisa membuat kelas menggunakan kata kunci class. Kelas adalah template yang digunakan untuk membuat objek, dan objek adalah instance dari kelas tersebut.

Contoh Kelas dan Objek

// Mendefinisikan kelas dengan tipe data untuk properti
class Person {
    name: string;
    age: number;

    // Constructor untuk inisialisasi objek
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }

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

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

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

Penjelasan:

• name dan age adalah properti dengan tipe data string dan number, yang ditentukan pada kelas Person.
• constructor digunakan untuk inisialisasi objek saat dibuat.
• greet() adalah metode yang digunakan untuk mencetak informasi tentang objek.

3. Inheritance (Pewarisan)

Inheritance memungkinkan kita untuk membuat kelas baru yang mewarisi properti dan metode dari kelas lain. Ini mengurangi duplikasi kode dan memungkinkan penggunaan kembali.

Contoh Inheritance

// Kelas induk (Parent class)
class Animal {
    name: string;

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

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

// Kelas anak (Child class) yang mewarisi kelas Animal
class Dog extends Animal {
    breed: string;

    constructor(name: string, breed: string) {
        super(name); // Memanggil constructor kelas induk
        this.breed = breed;
    }

    // Override method speak()
    speak(): void {
        console.log(`${this.name} barks.`);
    }
}

const dog = new Dog("Buddy", "Golden Retriever");
dog.speak(); // Output: Buddy barks.

Penjelasan:

• Dog mewarisi kelas Animal dan menambahkan properti breed.
• Metode speak() di kelas Dog menimpa (override) metode speak() dari kelas Animal.

4. Polymorphism (Polimorfisme)

Polimorfisme memungkinkan objek dari kelas yang berbeda untuk menggunakan metode yang sama dengan implementasi yang berbeda. Ini biasanya dicapai melalui inheritance dan method overriding.

Contoh Polymorphism

class Cat extends Animal {
    speak(): void {
        console.log(`${this.name} meows.`);
    }
}

const cat = new Cat("Whiskers");
cat.speak(); // Output: Whiskers meows.

const animal = new Animal("Generic Animal");
animal.speak(); // Output: Generic Animal makes a sound.

Penjelasan:

• Kelas Cat mengoverride metode speak() dari kelas Animal untuk memberikan perilaku yang berbeda.
• Meskipun kedua objek (Cat dan Dog) menggunakan metode speak(), hasil outputnya berbeda tergantung pada kelas yang digunakan.

5. Encapsulation (Enkapsulasi)

Enkapsulasi adalah prinsip untuk menyembunyikan detail implementasi dan hanya menyediakan antarmuka yang diperlukan untuk interaksi dengan objek. Di TypeScript, kita bisa menggunakan akses modifier seperti private, protected, dan public untuk mengatur visibilitas properti dan metode.

Contoh Enkapsulasi

class BankAccount {
    private balance: number; // Properti privat

    constructor(balance: number) {
        this.balance = balance;
    }

    // Method publik untuk mengakses balance
    getBalance(): number {
        return this.balance;
    }

    // Method untuk deposit uang
    deposit(amount: number): void {
        if (amount > 0) {
            this.balance += amount;
        }
    }

    // Method untuk menarik uang
    withdraw(amount: number): void {
        if (amount > 0 && amount <= this.balance) {
            this.balance -= amount;
        } else {
            console.log("Insufficient balance");
        }
    }
}

const account = new BankAccount(1000);
console.log(account.getBalance()); // Output: 1000
account.deposit(500);
console.log(account.getBalance()); // Output: 1500
account.withdraw(200);
console.log(account.getBalance()); // Output: 1300

Penjelasan:

• Properti balance adalah privat dan hanya bisa diakses melalui metode getBalance(), deposit(), dan withdraw().
• Menggunakan akses modifier private untuk menyembunyikan properti balance dari luar kelas.

6. Abstraction (Abstraksi)

Abstraksi adalah proses menyembunyikan implementasi yang kompleks dan hanya memperlihatkan fitur yang diperlukan kepada pengguna. Di TypeScript, kita bisa menggunakan kelas abstrak untuk membuat kelas dasar yang tidak bisa langsung diinstansiasi, tetapi harus diwarisi oleh kelas lain.

Contoh Abstraksi

abstract class Shape {
    name: string;

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

    // Method abstrak yang harus diimplementasikan oleh subclass
    abstract area(): number;
}

class Circle extends Shape {
    radius: number;

    constructor(radius: number) {
        super("Circle");
        this.radius = radius;
    }

    // Implementasi dari method abstrak area()
    area(): number {
        return Math.PI * this.radius * this.radius;
    }
}

const circle = new Circle(5);
console.log(circle.area()); // Output: 78.53981633974483

Penjelasan:

• Shape adalah kelas abstrak dengan metode area() yang tidak diimplementasikan dan harus diimplementasikan oleh kelas turunan seperti Circle.
• Circle mengimplementasikan metode area() sesuai dengan rumus luas lingkaran.

7. Interface di TypeScript

Interface adalah cara untuk mendefinisikan bentuk objek tanpa menyertakan implementasi. Interface sangat berguna untuk mendefinisikan struktur yang harus diikuti oleh kelas atau objek tertentu.

Contoh Interface

interface IAnimal {
    name: string;
    speak(): void;
}

class Dog implements IAnimal {
    name: string;

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

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

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

Penjelasan:

• IAnimal adalah interface yang mendefinisikan properti dan metode yang harus ada pada kelas yang mengimplementasikannya.
• Kelas Dog mengimplementasikan interface IAnimal dengan menyediakan properti name dan metode speak().

Kesimpulan

OOP dalam TypeScript memberikan cara yang efisien dan terstruktur untuk membangun aplikasi. Dengan konsep seperti kelas, objek, inheritance, polymorphism, encapsulation, abstraction, dan interface, Anda dapat membuat aplikasi yang lebih terkelola dan mudah dipelihara.

Dengan TypeScript, Anda mendapatkan keuntungan tambahan berupa tipe statis yang membantu Anda mendeteksi kesalahan lebih awal, meningkatkan produktivitas, dan membuat kode lebih mudah dipahami. Semoga artikel ini membantu Anda memahami dasar-dasar OOP dalam TypeScript dan memotivasi Anda untuk menggali lebih dalam!