TypeScript Academy · Lezione

Implementazione delle interfacce con le classi

Imposti la struttura delle classi con la parola chiave implements.

Implementazione delle interfacce con le classi è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Benvenuto

La parola chiave `implements` garantisce che una classe soddisfi il contratto di un'interfaccia. TypeScript verifica che la classe fornisca tutte le proprietà e i metodi richiesti.

implements di base

Utilizzi `implements InterfaceName` dopo il nome della classe. TypeScript segnala un errore se manca un membro richiesto.

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

I membri mancanti causano errori

Se la classe non implementa tutti i membri richiesti, TypeScript segnala un errore nella dichiarazione della classe.

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

Implementazione di più interfacce

Una classe può implementare più interfacce contemporaneamente, separandone i nomi con virgole.

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

interface non fornisce un'implementazione

Le interfacce descrivono solo la struttura. È la classe a fornire l'implementazione effettiva.

implements con membri facoltativi

I membri facoltativi dell'interfaccia non devono essere implementati. La classe può fornirli, ma non è obbligata a farlo.

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 per l'iniezione delle dipendenze

Utilizzare le interfacce come tipi dei parametri del costruttore abilita l'iniezione delle dipendenze: è possibile passare qualsiasi classe che implementi l'interfaccia.

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

`extends` eredita da un'altra classe, condividendone l'implementazione. `implements` controlla solo la struttura: non viene ereditato alcun codice.

Una classe che implementa un'interfaccia ed estende una classe

Una classe può estendere una classe base E implementare contemporaneamente una o più interfacce.

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

Implementazioni di interfacce generiche

Una classe può implementare un'interfaccia generica fornendo l'argomento di tipo.

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

Sicurezza dei tipi con implements

`implements` non aggiunge alcun comportamento a runtime. A runtime, la classe non ha informazioni sull'interfaccia. È esclusivamente un contratto verificato in fase di compilazione.

Verifica rapida

Che cosa verifica TypeScript quando una classe utilizza la parola chiave `implements`?

Riepilogo

`implements` impone in fase di compilazione che una classe soddisfi il contratto di un'interfaccia. Una classe può implementare più interfacce. Utilizzi le interfacce per l'iniezione delle dipendenze, la testabilità e la separazione del comportamento dall'implementazione.

Domande Frequenti

La lezione «Implementazione delle interfacce con le classi» è gratuita?

Sì — il testo completo di «Implementazione delle interfacce con le classi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Implementazione delle interfacce con le classi»?

Imposti la struttura delle classi con la parola chiave implements. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Implementazione delle interfacce con le classi»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?

Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Classi e costruttori in TypeScript
Modificatori public, private e protected
Proprietà readonly e proprietà dei parametri
Implementazione delle interfacce con le classi

← Torna a TypeScript Academy