Modificadores de Acesso

Os modificadores de acesso são fundamentais em linguagens orientadas a objetos, pois controlam a visibilidade e o acesso aos membros de uma classe (como propriedades e métodos) de outras classes. TypeScript, ampliando as capacidades de JavaScript, introduz os conceitos de modificadores de acesso para ajudar a estruturar o código de maneira mais segura e mantida. Vamos explorar os três principais modificadores de acesso em TypeScript: public, private e protected.

1. public

O modificador public é o mais aberto dos três níveis de acesso. Membros marcados como public são acessíveis de qualquer lugar, sem restrições. Este é o nível de acesso padrão para membros de classe em TypeScript se nenhum modificador de acesso for explicitamente especificado.

Exemplo:

class Car {
  public engine: string;

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

  public startEngine() {
    console.log(`The engine ${this.engine} has started.`);
  }
}

const car = new Car("V8");
car.startEngine(); // Acessível publicamente

2. private

O modificador private restringe o acesso ao membro da classe de modo que ele não possa ser acessado ou modificado de fora da própria classe. Isso é útil para esconder detalhes de implementação e proteger os dados da classe.

Exemplo:

class Car {
  private engine: string;

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

  private startEngine() {
    console.log(`The engine ${this.engine} has started.`);
  }
}

const car = new Car("V8");
// car.startEngine(); // Erro: 'startEngine' é privado e acessível apenas dentro da classe 'Car'.

3. protected

O modificador protected é semelhante ao private, mas permite que o acesso aos membros da classe seja feito também pelas classes derivadas (subclasses). Isso facilita a criação de uma base de classe com detalhes que devem ser ocultos do mundo externo, mas ainda acessíveis por classes herdeiras.

Exemplo:

class Vehicle {
  protected make: string;

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

class Car extends Vehicle {
  constructor(make: string) {
    super(make);
  }

  displayMake() {
    console.log(`This car is made by: ${this.make}`);
  }
}

const myCar = new Car("Toyota");
myCar.displayMake(); // Funciona, 'make' é protegido e acessível dentro da classe derivada
// console.log(myCar.make); // Erro: 'make' é protegido e não acessível externamente.

Conclusão

Os modificadores de acesso public, private, e protected são ferramentas essenciais para qualquer desenvolvedor TypeScript, permitindo que eles controlem como os componentes de suas classes são expostos e interagem com o restante do sistema. Utilizar corretamente esses modificadores pode ajudar a garantir a integridade dos dados e a encapsulação do código, dois princípios fundamentais da programação orientada a objetos.