Quais as diferenças entre modificadores public, private, protected e abstract no Typescript?

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:

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:

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:

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:

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

https://pt.stackoverflow.com/questions/559723/quais-as-diferen%C3%A7as-entre-modificadores-public-private-protected-e-abstract-no