Quais as diferenças entre modificadores public, private, protected e abstract no Typescript?
Published: 2024-05-26 12:38:47

o TypeScript, os modificadores de acesso controlam a visibilidade de membros de classes, como propriedades e métodos. Eles definem quais partes do código podem acessar esses membros.

**Public:**

O modificador padrão em TypeScript.
Permite que membros sejam acessados por qualquer classe, dentro ou fora da classe em que foram declarados.
Exemplo:

```ts
class Pessoa {
  public nome: string; // Propriedade pública

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

  public falar(): void {
    console.log(`Olá, meu nome é ${this.nome}`);
  }
}

const pessoa1 = new Pessoa('João');
console.log(pessoa1.nome); // Acessando propriedade pública
pessoa1.falar(); // Acessando método público

```
**Private:**

Restringe o acesso do membro à classe em que foi declarado.
Exemplo:

```ts
class ContaBancaria {
  private saldo: number; // Propriedade privada

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

  public sacar(valor: number): void {
    if (valor > this.saldo) {
      console.error('Saldo insuficiente');
      return;
    }

    this.saldo -= valor;
    console.log(`Saque de R$${valor} realizado com sucesso. Saldo atual: R$${this.saldo}`);
  }

  // O método 'getSaldo' não tem o modificador 'public', então ele é privado
  private getSaldo(): number {
    return this.saldo;
  }
}

const conta1 = new ContaBancaria(1000);
conta1.sacar(500); // Acessando método público
// conta1.saldo; // Erro: 'saldo' é privado e não pode ser acessado fora da classe
```

**Protected:**

Semelhante ao private, mas permite acesso de classes derivadas.
Exemplo:

```ts
TypeScript
class Animal {
  protected nome: string; // Propriedade protegida

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

  public falar(): void {
    console.log(`Eu sou um animal e meu nome é ${this.nome}`);
  }
}

class Cachorro extends Animal {
  constructor(nome: string) {
    super(nome);
  }

  public latir(): void {
    console.log(`Au au! Meu nome é ${this.nome}`);
  }
}

const cachorro1 = new Cachorro('Rex');
cachorro1.falar(); // Acessando método público herdado
cachorro1.latir(); // Acessando método próprio

```

**Abstract:**

Não define implementação, apenas declara um método que deve ser implementado em classes derivadas.
Classes abstratas não podem ser instanciadas diretamente.
Exemplo:

```ts
TypeScript
abstract class FiguraGeometrica {
  abstract calcularArea(): number; // Método abstrato

  public desenhar(): void {
    console.log('Desenhando figura geométrica...');
  }
}

class Retangulo extends FiguraGeometrica {
  private base: number;
  private altura: number;

  constructor(base: number, altura: number) {
    super();
    this.base = base;
    this.altura = altura;
  }

  public calcularArea(): number {
    return this.base * this.altura;
  }
}

const retangulo1 = new Retangulo(5, 7);
console.log(retangulo1.calcularArea()); // Acessando método implementado na classe derivada
retangulo1.desenhar(); // Acessando método herdado
```


 
|Modificado |    Visibilidade | Detalhes | 
| -------------  | --- |-----| 
| public   | Acessível em qualquer lugar| Padrão para membros de classe | 
| private | Somente dentro da classe| Maior encapsulamento |
| protected    | Dentro da classe e classes derivadas| Promove reuso em herança |
| abstract | 	Sem implementação| Define um contrato para classes derivadas |

**Dica :**
Lembre-se de escolher o modificador de acesso adequado para cada membro da classe, considerando o nível de encapsulamento e reuso desejado.


**Fontes**
[github.com/Mcps4/ifpi-ads-eng3-2022](url)
[
https://pt.stackoverflow.com/questions/559723/quais-as-diferen%C3%A7as-entre-modificadores-public-private-protected-e-abstract-no
](url)