Introdução aos recursos avançados de classes

O TypeScript oferece vários recursos avançados de classes que ajudam você a escrever código modular, escalável e de fácil manutenção, orientado a objetos.

Nesta lição, você aprenderá sobre modificadores de acesso, classes abstratas, membros estáticos e muito mais.

Introdução aos recursos avançados de classes

O TypeScript oferece vários recursos avançados de classes que ajudam você a escrever código modular, escalável e de fácil manutenção, orientado a objetos.

Nesta lição, você aprenderá sobre modificadores de acesso, classes abstratas, membros estáticos e muito mais.

Modificadores de acesso

O TypeScript fornece três modificadores de acesso para controlar a visibilidade dos membros de uma classe:

• public: acessível em qualquer lugar (padrão).
• private: acessível somente dentro da classe.
• protected: acessível dentro da classe e de suas subclasses.

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
  }
}

Classes abstratas

As classes abstratas são usadas como modelos para outras classes. Elas não podem ser instanciadas diretamente e podem incluir métodos abstratos.

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

Membros estáticos

Os membros estáticos pertencem à própria classe, e não a uma instância da classe. Eles são acessados usando o nome da 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

Métodos de leitura e atribuição

Os métodos de leitura e atribuição permitem controlar como as propriedades são acessadas ou modificadas em uma classe.

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

Propriedades somente leitura

O modificador readonly garante que uma propriedade só possa ser definida durante a inicialização e não possa ser modificada posteriormente.

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.

Construtores privados e protegidos

As classes podem ter construtores privados ou protegidos para controlar como e onde são instanciadas.

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);

Tarefa prática

Crie uma classe com um construtor protected e estenda-a em uma subclasse. Adicione métodos para acessar as propriedades protegidas na subclasse.

Parabéns!

Você aprendeu recursos avançados de classes, como modificadores de acesso, classes abstratas, membros estáticos e muito mais. Pratique esses conceitos para escrever código TypeScript orientado a objetos limpo e eficiente!