TypeScript Academy · Pelajaran

Mengimplementasikan Antarmuka dengan Class

Pastikan struktur class dengan kata kunci implements.

Mengimplementasikan Antarmuka dengan Class adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar TypeScript Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus TypeScript Academy mencakup 4 pelajaran total.

Selamat Datang

Kata kunci `implements` memastikan bahwa sebuah kelas memenuhi kontrak antarmuka. TypeScript memverifikasi bahwa kelas tersebut menyediakan semua properti dan metode yang diperlukan.

Penerapan Dasar

Gunakan `implements InterfaceName` setelah nama kelas. TypeScript melaporkan kesalahan jika ada anggota yang diperlukan tidak tersedia.

interface Printable {
  print(): void;
}
class Document implements Printable {
  print() { console.log('Printing...'); }
}

Anggota yang Hilang Menyebabkan Kesalahan

Jika kelas tidak mengimplementasikan semua anggota yang diperlukan, TypeScript melaporkan kesalahan pada deklarasi kelas.

interface Serializable { serialize(): string; }
// Error: Class 'Broken' incorrectly implements interface 'Serializable'
// class Broken implements Serializable {}

Mengimplementasikan Beberapa Antarmuka

Sebuah kelas dapat mengimplementasikan beberapa antarmuka sekaligus dengan memisahkannya menggunakan koma.

interface Flyable { fly(): void; }
interface Swimmable { swim(): void; }
class Duck implements Flyable, Swimmable {
  fly() { console.log('Flying'); }
  swim() { console.log('Swimming'); }
}

Antarmuka Tidak Menyediakan Implementasi

Antarmuka hanya mendeskripsikan struktur. Kelas menyediakan implementasi sebenarnya.

Penerapan dengan Anggota Opsional

Anggota antarmuka yang opsional tidak perlu diimplementasikan. Kelas boleh menyediakannya, tetapi tidak diwajibkan.

interface Logger {
  log(msg: string): void;
  warn?(msg: string): void; // optional
}
class SimpleLogger implements Logger {
  log(msg: string) { console.log(msg); }
  // warn is not required
}

Antarmuka untuk Injeksi Dependensi

Menggunakan antarmuka sebagai tipe parameter konstruktor memungkinkan injeksi dependensi—Anda dapat meneruskan kelas apa pun yang mengimplementasikan antarmuka tersebut.

interface Storage { save(data: string): void; }
class Service {
  constructor(private storage: Storage) {}
  run() { this.storage.save('data'); }
}
class LocalStorage implements Storage {
  save(data: string) { localStorage.setItem('key', data); }
}

`extends` versus `implements`

`extends` mewarisi dari kelas lain dan menggunakan implementasinya bersama-sama. `implements` hanya memeriksa struktur—tidak ada kode yang diwariskan.

Kelas yang Mengimplementasikan Antarmuka dan Memperluas Kelas

Sebuah kelas dapat memperluas kelas dasar DAN mengimplementasikan antarmuka secara bersamaan.

class Animal { breathe() { return 'breathing'; } }
interface Trainable { train(): void; }
class Dog extends Animal implements Trainable {
  train() { console.log('Sit!'); }
}

Implementasi Antarmuka Generik

Sebuah kelas dapat mengimplementasikan antarmuka generik dengan memberikan argumen tipe.

interface Repository<T> {
  findById(id: number): T | null;
}
class UserRepo implements Repository<User> {
  findById(id: number): User | null {
    return null; // stub
  }
}

Keamanan Tipe pada `implements`

`implements` tidak menambahkan perilaku saat program dijalankan. Saat dijalankan, kelas tidak mengetahui antarmuka tersebut. Fitur ini semata-mata merupakan kontrak saat kompilasi.

Pemeriksaan Singkat

Apa yang diperiksa TypeScript saat sebuah kelas menggunakan kata kunci `implements`?

Ringkasan

`implements` menegakkan pemenuhan kontrak antarmuka oleh kelas saat kompilasi. Sebuah kelas dapat mengimplementasikan beberapa antarmuka. Gunakan antarmuka untuk injeksi dependensi, kemudahan pengujian, dan pemisahan perilaku dari implementasi.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengimplementasikan Antarmuka dengan Class” gratis?

Ya — teks lengkap “Mengimplementasikan Antarmuka dengan Class” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus TypeScript Academy, upgrade ke CoddyKit PRO. Kursus TypeScript Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Mengimplementasikan Antarmuka dengan Class”?

Pastikan struktur class dengan kata kunci implements. Kamu berlatih TypeScript Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai TypeScript Academy?

Tidak diperlukan pengalaman sebelumnya. TypeScript Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Mengimplementasikan Antarmuka dengan Class” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran TypeScript Academy ini?

Ya. Setiap pelajaran TypeScript Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Class dan Konstruktor TypeScript
Pengubah public, private, dan protected
Properti readonly dan Properti Parameter
Mengimplementasikan Antarmuka dengan Class

← Kembali ke TypeScript Academy