TypeScript Academy · Lektion

Interfaces mit Klassen implementieren

Erzwingen Sie mit dem Schlüsselwort implements die Klassenstruktur.

Interfaces mit Klassen implementieren ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

Das Schlüsselwort `implements` stellt sicher, dass eine Klasse einen Interface-Vertrag erfüllt. TypeScript überprüft, ob die Klasse alle erforderlichen Eigenschaften und Methoden bereitstellt.

Grundlagen von implements

Verwenden Sie `implements InterfaceName` nach dem Klassennamen. TypeScript meldet einen Fehler, wenn ein erforderliches Member fehlt.

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

Fehlende Member verursachen Fehler

Wenn die Klasse nicht alle erforderlichen Member implementiert, meldet TypeScript einen Fehler bei der Klassendeklaration.

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

Mehrere Interfaces implementieren

Eine Klasse kann mehrere Interfaces gleichzeitig implementieren, indem Sie sie durch Kommas trennen.

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

interface stellt keine Implementierung bereit

Interfaces beschreiben nur die Struktur. Die Klasse stellt die eigentliche Implementierung bereit.

implements mit optionalen Membern

Optionale Interface-Member müssen nicht implementiert werden. Die Klasse kann sie bereitstellen, ist dazu aber nicht verpflichtet.

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
}

Interface für Dependency Injection

Wenn Sie Interfaces als Typen von Konstruktorparametern verwenden, ermöglichen Sie Dependency Injection – Sie können jede Klasse übergeben, die das Interface implementiert.

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 vs implements

`extends` erbt von einer anderen Klasse und übernimmt deren Implementierung. `implements` prüft nur die Struktur – es wird kein Code geerbt.

Eine Klasse implementiert ein Interface und erweitert eine Klasse

Eine Klasse kann gleichzeitig eine Basisklasse erweitern UND Interfaces implementieren.

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

Generische Interface-Implementierungen

Eine Klasse kann ein generisches Interface implementieren, indem sie das Typargument angibt.

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

Typsicherheit von implements

`implements` fügt kein Laufzeitverhalten hinzu. Zur Laufzeit kennt die Klasse das Interface nicht. Es handelt sich ausschließlich um einen Vertrag zur Compilezeit.

Schnellüberprüfung

Was überprüft TypeScript, wenn eine Klasse das Schlüsselwort `implements` verwendet?

Zusammenfassung

`implements` erzwingt zur Compilezeit, dass eine Klasse einen Interface-Vertrag erfüllt. Eine Klasse kann mehrere Interfaces implementieren. Verwenden Sie Interfaces für Dependency Injection, Testbarkeit und die Entkopplung von Verhalten und Implementierung.

Häufig gestellte Fragen

Ist die Lektion „Interfaces mit Klassen implementieren“ kostenlos?

Ja — der vollständige Text von „Interfaces mit Klassen implementieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Interfaces mit Klassen implementieren“?

Erzwingen Sie mit dem Schlüsselwort implements die Klassenstruktur. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Interfaces mit Klassen implementieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

TypeScript-Klassen und Konstruktoren
public-, private- und protected-Modifikatoren
readonly-Eigenschaften und Parameter-Eigenschaften
Interfaces mit Klassen implementieren

← Zurück zu TypeScript Academy