Da trilha de TypeScript Este conceito ainda não saiu como card do dia. ir para o card de hoje

TypeScript POO Intermediário

Classes e modificadores

Em TypeScript, classes são a base da programação orientada a objetos. Além da sintaxe familiar do JavaScript, o TypeScript adiciona modificadores de acesso que controlam a visibilidade de propriedades e métodos: public (padrão), private (só a própria classe acessa) e protected (a classe e suas subclasses acessam).

O modificador readonly impede reatribuições após a inicialização, sendo útil para constantes de instância. TypeScript também oferece parameter properties: ao declarar um parâmetro no construtor com um modificador de acesso, o campo é criado e atribuído automaticamente, reduzindo boilerplate.

A palavra-chave implements garante que uma classe cumpra um contrato definido por uma interface. Isso permite programar para abstrações, aumentando a segurança e a legibilidade do código.

Neste card, vamos explorar como esses recursos trabalham juntos para criar classes robustas e expressivas.

Pontos-chave

  • public é o padrão; private restringe o acesso à própria classe; protected permite acesso em subclasses.
  • readonly só pode ser atribuído no construtor ou na declaração.
  • Parameter properties declaram e inicializam campos diretamente no construtor, com modificadores.
  • implements obriga a classe a seguir a interface, mas não herda implementação.
  • Modificadores são checados em tempo de compilação, não em tempo de execução.
classes_modificadores.ts
interface Logger {
  log(msg: string): void;
}

class ConsoleLogger implements Logger {
  log(msg: string): void {
    console.log(`[LOG] ${msg}`);
  }
}

class ContaBancaria {
  // Parameter properties: public readonly e private
  constructor(
    public readonly titular: string,
    private saldo: number = 0
  ) {}

  // Método público
  public depositar(valor: number): void {
    if (valor <= 0) throw new Error("Valor inválido");
    this.saldo += valor;
  }

  // Método protected: acessível apenas na classe e subclasses
  protected getSaldo(): number {
    return this.saldo;
  }

  // Método público que usa o protected
  public mostrarSaldo(): void {
    console.log(`Saldo de ${this.titular}: R$ ${this.getSaldo().toFixed(2)}`);
  }
}

class ContaPoupanca extends ContaBancaria {
  constructor(titular: string, saldoInicial: number) {
    super(titular, saldoInicial);
  }

  // Pode acessar getSaldo() porque é protected
  public renderJuros(taxa: number): void {
    const juros = this.getSaldo() * taxa;
    this.depositar(juros);
  }
}

// Uso
const logger = new ConsoleLogger();
const conta = new ContaPoupanca("Ana", 1000);
conta.depositar(500);
conta.renderJuros(0.01);
conta.mostrarSaldo();
logger.log("Operação concluída");

// Tentativas de acesso inválido (descomente para ver erros):
// conta.saldo = 0; // Erro: private
// conta.getSaldo(); // Erro: protected
// conta.titular = "Outro"; // Erro: readonly

Exercícios

  1. 1
    Fácil

    Classe Pessoa com parameter properties

    Crie uma classe Pessoa que tenha uma propriedade nome (pública e readonly) e uma propriedade idade (privada). O construtor deve usar parameter properties para declarar e inicializar ambas. Adicione um método público apresentar() que imprime Olá, meu nome é [nome] e tenho [idade] anos..

    Resolver
  2. 2
    Médio

    Conta bancária com protected e readonly

    Implemente uma classe Conta com:

    • titular (public readonly)
    • saldo (protected)
    • Construtor que inicializa ambos.
    • Método depositar(valor: number): void que soma ao saldo.
    • Método sacar(valor: number): void que subtrai do saldo, mas lança erro se o valor for maior que o saldo.
    • Método getSaldo(): number que retorna o saldo (pode ser protected ou public? Use public para permitir consulta externa).

    Depois, crie uma subclasse ContaPoupanca que estende Conta e adiciona um método renderJuros(taxa: number): void que aumenta o saldo em saldo * taxa. Use protected para acessar saldo diretamente na subclasse.

    Resolver
  3. 3
    Desafio

    Sistema de funcionários com interface e modificadores

    Crie uma interface Funcionario com os métodos calcularSalario(): number e getNome(): string. Implemente duas classes:

    • Assalariado que recebe nome (public readonly) e salarioFixo (private) e implementa Funcionario.
    • Comissionado que recebe nome (public readonly), salarioBase (private) e percentualComissao (private), e também implementa Funcionario. O salário é salarioBase + salarioBase * percentualComissao.

    Ambas devem ter um método getNome() que retorna o nome. Use parameter properties para os construtores. Crie uma função imprimirSalario(f: Funcionario) que imprime Nome: [nome], Salário: R$ [salario] com duas casas decimais. Teste com um array de funcionários.

    Resolver

Continue estudando

← Anterior na trilhaConstraints genéricas Próximo na trilha →Classes abstratas Trilha completaTodos os conceitos de TypeScript Qualquer linguagem🎲 Sortear outro conceito