Modificadores de Acesso

Na aula de hoje, vamos explorar os modificadores de acesso em TypeScript, essenciais para controlar a visibilidade e a acessibilidade dos membros de classe. Entenderemos como os modificadores “public,” “private,” “protected,” e “readonly” afetam o comportamento das classes em TypeScript. Então, bora começar?

Os modificadores de acesso são uma forma de controlar a visibilidade e a acessibilidade dos membros de classe em TypeScript.

Modificador “public” (Padrão)

O modificador “public” é o padrão para membros de classe em TypeScript. Isso significa que os membros marcados como “public” podem ser acessados de qualquer lugar.

class Produto {
  nome: string;

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

const produto = new Produto("Notebook");
console.log(produto.nome); // Saída: Notebook

Neste exemplo, o campo nome da classe Produto é “public” por padrão, portanto, podemos acessá-lo diretamente.

Modificador “private”

O modificador “private” restringe o acesso aos membros de classe apenas dentro da própria classe. Eles não podem ser acessados fora da classe.

class ContaBancaria {
  private saldo: number;

  constructor(saldoInicial: number) {
    this.saldo = saldoInicial;
  }

  getSaldo(): number {
    return this.saldo;
  }
}

const minhaConta = new ContaBancaria(1000);

// Isso resultará em um erro em tempo de compilaçãoconsole.log(minhaConta.saldo);

// Podemos acessar o saldo usando o método getSaldoconsole.log(minhaConta.getSaldo()); // Saída: 1000

Neste exemplo, o campo saldo é privado, então não podemos acessá-lo diretamente fora da classe. No entanto, podemos criar um método público, como getSaldo, para recuperar o saldo.

Modificador “protected”

O modificador “protected” permite que os membros da classe sejam acessados dentro da classe e de suas subclasses, mas não fora delas.

class Animal {
  protected nome: string;

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

class Cachorro extends Animal {
  latir(): void {
    console.log(`${this.nome} está latindo.`);
  }
}

const cachorro = new Cachorro("Rex");
cachorro.latir(); // Saída: Rex está latindo.// Isso resultará em um erro em tempo de compilaçãoconsole.log(cachorro.nome);

Neste exemplo, o campo nome é protegido, o que significa que podemos acessá-lo dentro da classe Animal e suas subclasses, como Cachorro.

Modificador “readonly”

O modificador “readonly” permite que você defina campos de classe que só podem ser inicializados uma vez, geralmente no construtor. Depois de definidos, eles não podem ser modificados.

class Pessoa {
  readonly nome: string;

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

const pessoa = new Pessoa("Alice");
console.log(pessoa.nome); // Saída: Alice// Isso resultará em um erro em tempo de compilação
pessoa.nome = "Bob";

Neste exemplo, o campo nome é marcado como “readonly”, o que significa que não podemos modificá-lo após a inicialização.

Os modificadores de acesso desempenham um papel fundamental na encapsulação e na estruturação de classes em TypeScript, garantindo que o código seja mais seguro e organizado. Na próxima seção, abordaremos os getters e setters e como eles podem ser usados para controlar o acesso aos campos de classe.

Exercícios

Exercício 1: Modificador “private”

Crie uma classe chamada Cliente com um campo privado chamado email: string. Esta classe deve ter um construtor que aceite o nome do cliente e seu email. Crie também um método público chamado mostrarEmail que exibe o email do cliente no console. Tente acessar o campo email diretamente fora da classe e registre o resultado no console.

Exercício 2: Modificador “protected”

Crie uma classe chamada Veiculo com um campo protegido chamado modelo: string. Em seguida, crie uma classe chamada Carro que herda de Veiculo e tem um método público chamado mostrarModelo que exibe o modelo do carro no console. Crie uma instância da classe Carro e chame o método mostrarModelo. Tente acessar o campo modelo diretamente fora da classe Veiculo e registre o resultado no console.

Exercício 3: Modificador “readonly”

Crie uma classe chamada Produto com um campo readonly chamado codigo: string. O código do produto deve ser definido apenas no construtor. Crie uma instância da classe Produto e exiba o código do produto no console. Em seguida, tente modificar o código do produto após a inicialização e registre o resultado no console.

Lembre-se de importar ou criar as dependências necessárias, como as classes Cliente, Veiculo, e Produto, para que os exercícios funcionem corretamente.