Risposta.

Storia della questione

I tipi di classi e l'ereditarietà sono stati aggiunti a TypeScript per supportare modelli orientati agli oggetti comuni in altri linguaggi (Java, C#). TypeScript consente di creare classi con tipi espliciti per proprietà e metodi, oltre a implementare l'ereditarietà con sicurezza di tipo.

Problema

Senza una tipizzazione esplicita in JavaScript, gli errori legati all'uso improprio delle proprietà non vengono rilevati durante la fase di compilazione. I problemi sorgono quando si sovrascrivono metodi/proprietà nelle classi derivate, quando si viola il contratto della classe base e quando si lavora in modo errato con protected/private.

Soluzione

TypeScript consente di utilizzare le parole chiave public, private, protected, di specificare esplicitamente i tipi di proprietà e metodi, ereditare classi utilizzando extends e implementare interfacce.

Esempio di codice:

class Animal {
  public name: string;
  protected age: number;
  private secret: string = "hidden";

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

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

class Dog extends Animal {
  constructor(name: string, age: number) {
    super(name, age);
  }

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

const dog = new Dog("Rex", 4);
dog.speak(); // Rex barks.

Caratteristiche chiave:

Dichiarazione esplicita dei tipi di proprietà e metodi della classe
Utilizzo dei modificatori di accesso per incapsulamento
Supporto per ereditarietà e sovrascrittura di metodi con controllo dei tipi

Domande trabocchetto.

Cosa succede se non si specifica il tipo di un campo della classe?

TypeScript cercherà di inferire il tipo dallo valore assegnato, se presente. Se non c'è, il tipo sarà any, il che riduce la sicurezza del codice.

class Test {
  value;
  constructor(v: number) {
    this.value = v;
  }
}

value sarà di tipo any se non è assegnato un valore predefinito — una potenziale falla nella sicurezza di tipo.

Si può cambiare il modificatore di accesso di un metodo ereditato?

Sì, ma solo rafforzandolo (ad esempio, da public a protected o non è consentito con private), mentre da private a public non è possibile, poiché il membro privato non è ereditato. Questo porterà a un errore di compilazione.

Si può ereditare da più classi in TypeScript?

No, l'ereditarietà multipla delle classi è vietata. È possibile implementare più interfacce ma solo una extends da una classe.

Errori tipici e anti-pattern

Mancata indicazione dei tipi di proprietà porta a implicit any
Sovrascrittura errata di metodi (con firma non corrispondente)
Violazione dell'incapsulamento (apertura di proprietà private)

Esempio della vita reale

Caso negativo

Nel progetto tutte le classi erano dichiarate senza modificatori di accesso e tipi espliciti, per velocizzare lo sviluppo.

Vantaggi:

Prototipazione iniziale rapida

Svantaggi:

Difficoltà nel rintracciare errori di accesso
Bug frequenti a causa di sovrascritture involontarie delle proprietà

Caso positivo

Tutti i membri della classe erano accuratamente tipizzati, utilizzavano private/protected/public, tipizzazione rigorosa delle proprietà e dei metodi.