Kelas #

Kelas (class) adalah salah satu fitur utama dalam TypeScript yang memungkinkan Anda untuk membuat blueprint untuk objek, yang menggabungkan data (dalam bentuk properti) dan perilaku (dalam bentuk metode). Kelas di TypeScript mirip dengan kelas di bahasa pemrograman berorientasi objek lainnya seperti Java, C#, dan C++. Kelas membantu dalam pengorganisasian kode dan meningkatkan kemampuan untuk mengelola kompleksitas aplikasi.

Mendefinisikan Kelas #

Kelas didefinisikan menggunakan kata kunci class, diikuti oleh nama kelas. Di dalam kelas, Anda dapat mendefinisikan properti dan metode.

Contoh:

class Person {
    name: string;
    age: number;

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

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

let john = new Person("John Doe", 30);
console.log(john.greet()); // Output: Hello, my name is John Doe and I am 30 years old.

• name dan age: Properti kelas yang menyimpan data.
• constructor: Fungsi khusus yang dipanggil ketika objek dibuat dari kelas. Digunakan untuk menginisialisasi properti kelas.
• greet(): Metode kelas yang dapat dipanggil pada instance objek untuk melakukan tindakan tertentu.

Inisialisasi Objek #

Anda dapat membuat instance objek dari kelas dengan menggunakan kata kunci new, diikuti oleh panggilan ke konstruktor kelas.

Contoh:

let alice = new Person("Alice", 25);
console.log(alice.greet()); // Output: Hello, my name is Alice and I am 25 years old.

Aksesibilitas (Access Modifiers) #

TypeScript menyediakan aksesibilitas untuk properti dan metode kelas melalui modifier public, private, dan protected.

• public: Properti atau metode yang dapat diakses dari mana saja. Ini adalah default jika tidak ada modifier yang ditentukan.

  Contoh:

  class Car {
      public brand: string;
  
      constructor(brand: string) {
          this.brand = brand;
      }
  
      public drive() {
          console.log(`Driving a ${this.brand}`);
      }
  }
  
  let myCar = new Car("Toyota");
  console.log(myCar.brand); // Output: Toyota
  myCar.drive(); // Output: Driving a Toyota
  

• private: Properti atau metode yang hanya dapat diakses dari dalam kelas itu sendiri.

  Contoh:

  class Car {
      private brand: string;
  
      constructor(brand: string) {
          this.brand = brand;
      }
  
      public drive() {
          console.log(`Driving a ${this.brand}`);
      }
  }
  
  let myCar = new Car("Toyota");
  // console.log(myCar.brand); // Error: 'brand' is private and only accessible within class 'Car'.
  myCar.drive(); // Output: Driving a Toyota
  

• protected: Properti atau metode yang dapat diakses dari dalam kelas itu sendiri dan dari kelas turunan (subclass).

  Contoh:

  class Car {
      protected brand: string;
  
      constructor(brand: string) {
          this.brand = brand;
      }
  }
  
  class SportsCar extends Car {
      constructor(brand: string) {
          super(brand);
      }
  
      public showBrand() {
          console.log(`This is a ${this.brand}`);
      }
  }
  
  let mySportsCar = new SportsCar("Ferrari");
  mySportsCar.showBrand(); // Output: This is a Ferrari
  

Kelas Turunan (Inheritance) #

TypeScript mendukung pewarisan, yang memungkinkan satu kelas untuk mewarisi properti dan metode dari kelas lain menggunakan kata kunci extends.

Contoh:

class Animal {
    name: string;

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

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

class Dog extends Animal {
    constructor(name: string) {
        super(name); // Memanggil konstruktor kelas induk
    }

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

let myDog = new Dog("Buddy");
myDog.makeSound(); // Output: Buddy makes a sound
myDog.bark();      // Output: Buddy barks

• extends: Digunakan untuk mendefinisikan hubungan pewarisan antara dua kelas.
• super(): Digunakan untuk memanggil konstruktor atau metode dari kelas induk dalam kelas turunan.

Static Properties dan Methods #

TypeScript memungkinkan Anda untuk mendefinisikan properti dan metode static, yang tidak terkait dengan instance kelas, tetapi terkait dengan kelas itu sendiri.

Contoh:

class MathUtil {
    static pi: number = 3.14;

    static calculateArea(radius: number): number {
        return this.pi * radius * radius;
    }
}

console.log(MathUtil.pi); // Output: 3.14
console.log(MathUtil.calculateArea(5)); // Output: 78.5

• static: Menunjukkan bahwa properti atau metode tersebut milik kelas, bukan instance.

Abstract Classes #

Kelas abstrak adalah kelas yang tidak dapat diinstansiasi secara langsung dan sering digunakan sebagai blueprint untuk kelas lain. Kelas abstrak dapat memiliki metode abstrak (yang tidak memiliki implementasi) yang harus diimplementasikan oleh kelas turunan.

Contoh:

abstract class Animal {
    abstract makeSound(): void;

    move(): void {
        console.log("Moving...");
    }
}

class Dog extends Animal {
    makeSound(): void {
        console.log("Bark");
    }
}

let myDog = new Dog();
myDog.makeSound(); // Output: Bark
myDog.move();      // Output: Moving...

• abstract: Menandai kelas atau metode sebagai abstrak. Kelas abstrak tidak dapat diinstansiasi langsung dan metode abstrak harus diimplementasikan dalam kelas turunan.

Interfaces dengan Kelas #

Kelas di TypeScript dapat mengimplementasikan interface, yang memaksa kelas tersebut untuk memenuhi kontrak yang ditentukan oleh interface.

Contoh:

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

class Cat implements IAnimal {
    name: string;

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

    makeSound(): void {
        console.log("Meow");
    }
}

let myCat = new Cat("Whiskers");
myCat.makeSound(); // Output: Meow

• implements: Digunakan untuk menunjukkan bahwa kelas memenuhi kontrak yang ditentukan oleh interface.

Kesimpulan #

Kelas di TypeScript memungkinkan Anda untuk menulis kode yang lebih terstruktur dan modular, dengan fitur-fitur seperti konstruktor, properti, metode, pewarisan, encapsulation, dan polymorphism. Dengan memahami dan menggunakan kelas, Anda dapat membangun aplikasi yang lebih efisien, mudah dipelihara, dan scalable.