TypeScript Academy · Lektion

Implementering af interfaces med klasser

Håndhæv klassers struktur med nøgleordet implements

Lektion 4 af 413 trin

Implementering af interfaces med klasser er en gratis TypeScript Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i TypeScript Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. TypeScript Academy-kurset indeholder 4 lektioner i alt.

Velkommen

Nøgleordet `implements` sikrer, at en klasse opfylder en grænsefladekontrakt. TypeScript kontrollerer, at klassen leverer alle påkrævede egenskaber og metoder.

Grundlæggende implements

Brug `implements InterfaceName` efter klassenavnet. TypeScript giver en fejl, hvis et påkrævet medlem mangler.

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

Manglende medlemmer giver fejl

Hvis klassen ikke implementerer alle påkrævede medlemmer, rapporterer TypeScript en fejl på klassedeklarationen.

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

Implementering af flere grænseflader

En klasse kan implementere flere grænseflader på én gang ved at adskille dem med kommaer.

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

interface leverer ikke en implementering

Grænseflader beskriver kun strukturen. Klassen leverer den faktiske implementering.

implements med valgfrie medlemmer

Valgfrie grænseflademedlemmer behøver ikke at blive implementeret. Klassen må gerne levere dem, men det er ikke et krav.

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
}

Grænseflade til afhængighedsinjektion

Når du bruger grænseflader som typer for konstruktørparametre, muliggør det afhængighedsinjektion – du kan overføre enhver klasse, der implementerer grænsefladen.

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

`extends` nedarver fra en anden klasse og deler dermed implementeringen. `implements` kontrollerer kun strukturen – ingen kode nedarves.

Klasse, der implementerer en grænseflade og udvider en klasse

En klasse kan både udvide en basisklasse OG implementere grænseflader på samme tid.

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

Implementeringer af generiske grænseflader

En klasse kan implementere en generisk grænseflade ved at angive typeargumentet.

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

Typesikkerhed med implements

`implements` tilføjer ingen adfærd ved kørsel. Ved kørsel har klassen intet kendskab til grænsefladen. Det er udelukkende en kontrakt, der gælder ved kompilering.

Hurtig kontrol

Hvad kontrollerer TypeScript, når en klasse bruger nøgleordet `implements`?

Besvar den i den interaktive lektion

Opsummering

`implements` håndhæver ved kompilering, at en klasse opfylder en grænsefladekontrakt. En klasse kan implementere flere grænseflader. Brug grænseflader til afhængighedsinjektion, testbarhed og adskillelse af adfærd fra implementering.

Gratis at komme i gang

Lær TypeScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 101
Lektioner: 352

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Implementering af interfaces med klasser” gratis?

Ja — hele teksten til “Implementering af interfaces med klasser” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af TypeScript Academy-kurset, skal du opgradere til CoddyKit PRO. TypeScript Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Implementering af interfaces med klasser”?

Håndhæv klassers struktur med nøgleordet implements Du øver dig i TypeScript Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på TypeScript Academy?

Der kræves ingen tidligere erfaring. TypeScript Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Implementering af interfaces med klasser”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne TypeScript Academy-lektion?

Ja. Alle TypeScript Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

TypeScript-klasser og konstruktører
Modifikatorerne public, private og protected
readonly-egenskaber og parameter-egenskaber
Implementering af interfaces med klasser

← Tilbage til TypeScript Academy