Modificadores de Acesso em TypeScript: Controle a Visibilidade e o Acesso aos Membros das Classes

Utilizando Modificadores de Acesso em TypeScript: Controle a Visibilidade e o Acesso aos Membros das Classes 🔒🔑

Introdução

Em TypeScript, os modificadores de acesso permitem controlar a visibilidade e o acesso aos membros das classes, como propriedades e métodos. Com os modificadores ``public``, ``private`` e ``protected``, podemos estabelecer níveis de encapsulamento adequados e garantir a integridade do nosso código. Neste artigo, vamos explorar o uso desses modificadores em TypeScript, fornecendo vários exemplos de código para ilustrar sua aplicação prática.

Modificador de Acesso ``public``

O modificador ``public`` é o padrão em TypeScript, o que significa que se nenhum modificador for especificado, o membro será público por padrão. Os membros públicos podem ser acessados de qualquer lugar, tanto dentro quanto fora da classe. Vejamos um exemplo:

class Carro {
  public marca: string;

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

  public acelerar(): void {
    console.log(``O carro da marca ${this.marca} está acelerando.``);
  }
}

const meuCarro = new Carro("Toyota");
meuCarro.acelerar();

Neste exemplo, a propriedade ``marca`` e o método ``acelerar()`` são marcados como públicos. Isso significa que eles podem ser acessados e utilizados tanto dentro da classe quanto fora dela, como na criação de uma instância de ``Carro`` e na chamada do método ``acelerar()``.

Modificador de Acesso ``private`` 🔒

O modificador ``private`` restringe o acesso aos membros apenas à classe onde foram declarados. Esses membros não podem ser acessados nem modificados de fora da classe. Vejamos um exemplo:

class ContaBancaria {
  private saldo: number;

  constructor() {
    this.saldo = 0;
  }

  public depositar(valor: number): void {
    this.saldo += valor;
    console.log(``Depósito realizado. Saldo atual: ${this.saldo}``);
  }

  public consultarSaldo(): void {
    console.log(``Saldo atual: ${this.saldo}``);
  }
}

const minhaConta = new ContaBancaria();
minhaConta.depositar(1000);
minhaConta.consultarSaldo();

Neste exemplo, a propriedade ``saldo`` é marcada como privada. Isso significa que ela só pode ser acessada e modificada dentro da própria classe ``ContaBancaria``, não sendo possível acessá-la diretamente fora da classe. No entanto, os métodos públicos ``depositar()`` e ``consultarSaldo()`` podem interagir com o saldo privado.

Modificador de Acesso ``protected``

O modificador ``protected`` é semelhante ao ``private``, mas permite que os membros sejam acessados também pelas subclasses. Isso permite a herança e o compartilhamento de membros protegidos entre as classes. Vejamos um exemplo:

class Veiculo {
  protected marca: string;

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

class Carro extends Veiculo {
  private modelo: string;

  constructor(marca: string, modelo: string) {
    super(marca);
    this.modelo = modelo;
  }

  public exibirInform ações(): void {
    console.log(``Marca: ${this.marca}, Modelo: ${this.modelo}``);
  }
}

const meuCarro = new Carro("Toyota", "Corolla");
meuCarro.exibirInformacoes();

Neste exemplo, a classe ``Veiculo`` possui uma propriedade protegida ``marca``, que pode ser acessada pela classe ``Carro``, que a estende. A propriedade ``modelo`` da classe ``Carro`` é privada e só pode ser acessada dentro da própria classe. O método ``exibirInformacoes()`` utiliza tanto a propriedade protegida ``marca`` quanto a propriedade privada ``modelo``.

Conclusão 📚

Os modificadores de acesso em TypeScript (``public``, ``private`` e ``protected``) desempenham um papel fundamental no controle de visibilidade e acesso aos membros das classes. O uso adequado desses modificadores nos permite estabelecer níveis adequados de encapsulamento, garantir a integridade do código e promover a reutilização de classes e seus membros. Ao compreender e aplicar corretamente esses modificadores, podemos criar classes mais coesas, seguras e flexíveis em nossos projetos TypeScript.

Neste artigo, exploramos os conceitos e exemplos práticos de uso dos modificadores de acesso em TypeScript. Agora você tem as ferramentas necessárias para utilizar esses modificadores em suas classes, otimizando a visibilidade e o controle dos membros. Lembre-se de escolher os modificadores de acesso adequados de acordo com as necessidades do seu código e aplicar os princípios de encapsulamento e segurança em suas implementações.