Aula 85 — Campos Privados (#)

Até aqui, já criamos classes, métodos e herança.

Mas ainda existe um problema clássico:

como proteger dados internos de uma classe?

É exatamente isso que os campos privados resolvem.

🎯 Objetivo da aula

Ao final desta aula, você será capaz de:

• Entender o que são campos privados
• Usar o prefixo #
• Diferenciar campos públicos e privados
• Proteger o estado interno de uma classe
• Evitar acessos indevidos

O problema dos campos públicos

Até pouco tempo atrás, todo campo de uma classe era público:

 
  class ContaBancaria { constructor(saldo) { this.saldo = saldo; } }
  const conta = new ContaBancaria(1000);
  conta.saldo = 0; // ❌ qualquer um pode alterar

Isso funciona, mas:

• quebra regras de negócio
• expõe dados sensíveis
• dificulta manutenção

O que são campos privados?

Campos privados são propriedades que:

• só podem ser acessadas dentro da classe
• não existem fora dela
• usam o prefixo #

Criando um campo privado

 
  class ContaBancaria { #saldo;
  constructor(saldoInicial) {
    this.#saldo = saldoInicial;
  }
  consultarSaldo() 
  {
    return this.#saldo;
  }
}
const conta = new ContaBancaria(1000);
console.log(conta.consultarSaldo()); // Saída será: 1000

Agora o campo #saldo está protegido.

Tentando acessar de fora

 console.log(conta.#saldo); // ❌ Erro de sintaxe 

Isso não é um erro em tempo de execução — o código nem chega a rodar.

Campos privados + métodos públicos

O padrão correto é:

• campos privados guardam dados
• métodos públicos controlam o acesso

 
  class ContaBancaria { #saldo;
  constructor(saldoInicial) {
    this.#saldo = saldoInicial;
  }
  depositar(valor) {
    if (valor > 0) {
      this.#saldo += valor;
    }
  }

sacar(valor) {
  if (valor <= this.#saldo) {
    this.#saldo -= valor;
  }
}

consultarSaldo() 
  {
  return this.#saldo;
  }
}

const conta = new ContaBancaria(500);
conta.depositar(200);
conta.sacar(100);
console.log(conta.consultarSaldo()); // Saída será: 600

Por que isso é encapsulamento real?

Porque agora:

• ninguém altera o estado diretamente
• regras ficam centralizadas
• a classe controla seu próprio estado

Isso aproxima JavaScript de linguagens com encapsulamento clássico — mas sem perder flexibilidade.

Campos privados não aparecem no objeto

 console.log(Object.keys(conta)); // Saída será: [] 

Campos privados:

• não são enumeráveis
• não aparecem em inspeções
• não podem ser acessados por reflexão comum

Comparação com convenções antigas

Antes do #, era comum ver:

 class Conta { constructor() { this._saldo = 0; // ❌ só convenção } } 

Isso:

• não é privado de verdade
• pode ser acessado externamente

Quando usar campos privados?

• dados sensíveis
• estado interno
• regras de negócio
• proteção contra uso indevido

Quando não exagerar

Nem todo campo precisa ser privado.

• objetos simples
• DTOs
• dados de leitura

Na próxima aula, vamos fechar esse bloco com Métodos Estáticos.