Introduzione alle funzionalità avanzate delle classi

TypeScript offre diverse funzionalità avanzate delle classi che aiutano a scrivere codice orientato agli oggetti modulare, scalabile e facilmente manutenibile.

In questa lezione imparerà a conoscere i modificatori di accesso, le classi astratte, i membri statici e altro ancora.

Introduzione alle funzionalità avanzate delle classi

TypeScript offre diverse funzionalità avanzate delle classi che aiutano a scrivere codice orientato agli oggetti modulare, scalabile e facilmente manutenibile.

In questa lezione imparerà a conoscere i modificatori di accesso, le classi astratte, i membri statici e altro ancora.

Modificatori di accesso

TypeScript fornisce tre modificatori di accesso per controllare la visibilità dei membri di una classe:

• public: Accessibile ovunque (impostazione predefinita).
• private: Accessibile solo all'interno della classe.
• protected: Accessibile all'interno della classe e delle relative sottoclassi.

class Person {
  public name: string;
  private age: number;
  protected role: string;

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

class Employee extends Person {
  getRole(): string {
    return this.role; // Accessible because it's protected
  }
}

Classi astratte

Le classi astratte vengono usate come modelli per altre classi. Non possono essere istanziate direttamente e possono includere metodi astratti.

abstract class Shape {
  abstract getArea(): number;
}

class Circle extends Shape {
  constructor(public radius: number) {
    super();
  }

  getArea(): number {
    return Math.PI * this.radius ** 2;
  }
}

const circle = new Circle(5);
console.log(circle.getArea()); // 78.54

Membri statici

I membri statici appartengono alla classe stessa, non a una sua istanza. Vi si accede usando il nome della classe.

class MathUtils {
  static PI = 3.14;

  static calculateCircleArea(radius: number): number {
    return this.PI * radius ** 2;
  }
}

console.log(MathUtils.PI); // 3.14
console.log(MathUtils.calculateCircleArea(5)); // 78.5

Getter e setter

I getter e i setter consentono di controllare il modo in cui si accede alle proprietà di una classe o le si modifica.

class Person {
  private _name: string;

  constructor(name: string) {
    this._name = name;
  }

  get name(): string {
    return this._name;
  }

  set name(newName: string) {
    this._name = newName;
  }
}

const person = new Person('Alice');
console.log(person.name); // Alice
person.name = 'Bob';
console.log(person.name); // Bob

Proprietà di sola lettura

Il modificatore readonly garantisce che una proprietà possa essere impostata solo durante l'inizializzazione e non modificata in seguito.

class Vehicle {
  readonly make: string;

  constructor(make: string) {
    this.make = make;
  }
}

const car = new Vehicle('Toyota');
console.log(car.make); // Toyota
// car.make = 'Honda'; // Error: Cannot assign to 'make' because it is a read-only property.

Costruttori privati e protetti

Le classi possono avere costruttori privati o protetti per controllare come e dove vengono istanziate.

class Singleton {
  private static instance: Singleton;

  private constructor() {}

  static getInstance(): Singleton {
    if (!this.instance) {
      this.instance = new Singleton();
    }
    return this.instance;
  }
}

const singleton = Singleton.getInstance();
console.log(singleton);

Attività pratica

Crei una classe con un costruttore protected ed estenda la classe in una sottoclasse. Aggiunga metodi per accedere alle proprietà protected nella sottoclasse.

Congratulazioni!

Ha appreso funzionalità avanzate delle classi, come i modificatori di accesso, le classi astratte, i membri statici e altro ancora. Metta in pratica questi concetti per scrivere codice TypeScript orientato agli oggetti pulito ed efficiente!