Membros estáticos e métodos privados

Membros estáticos: pertencem à CLASSE, não à instância

Com static você define propriedades e métodos que vivem na própria classe, não em cada objeto criado. São acessados pelo nome da classe, sem new.

Analogia: a instância é cada carro fabricado; o estático é informação da fábrica (quantos carros já foram fabricados, a constante de conversão que todos usam, etc.).

class Circulo {
  static PI = 3.14159;           // propriedade estática (constante compartilhada)
  constructor(raio) {
    this.raio = raio;
  }
  area() {
    return Circulo.PI * this.raio * this.raio;
  }
}
console.log(Circulo.PI);          // 3.14159  (pela classe, não pela instância)

Usos típicos

Métodos "factory" que criam instâncias de forma mais expressiva que new:

class Usuario {
  constructor(nome) {
    this.nome = nome;
  }
  static criar(nome) {            // método estático factory
    return new Usuario(nome);
  }
}
const u = Usuario.criar("Ana");   // lê-se melhor que new Usuario("Ana")

Contadores de instâncias (um dado que é de toda a classe, não de um objeto):

class Conexao {
  static abertas = 0;
  constructor() {
    Conexao.abertas++;            // incrementa a cada new
  }
}
new Conexao();
new Conexao();
console.log(Conexao.abertas);     // 2

Utilitários que não precisam de uma instância (como faz Math.max ou Array.from): você agrupa funções relacionadas dentro de uma classe.

Métodos e campos privados

Você já viu os campos privados #campo. Você também pode ter métodos privados #metodo(): helpers internos que a classe usa, mas que o exterior não deve chamar. São invisíveis de fora.

class Senha {
  #valor;
  constructor(texto) {
    this.#valor = texto;
  }
  // método privado: só é chamado de dentro da classe
  #ehLonga() {
    return this.#valor.length >= 8;
  }
  ehSegura() {
    return this.#ehLonga();       // o método público delega ao privado
  }
}
const p = new Senha("supersecreta");
console.log(p.ehSegura());        // true
// p.#ehLonga()  ->  SyntaxError: o método privado não existe fora

Isso permite expor uma interface pública pequena e clara, escondendo os detalhes internos. Amanhã você pode reescrever #ehLonga sem que ninguém de fora perceba, porque ninguém podia depender dele.

Exemplos

Propriedade estática compartilhada por todas as instâncias

class Produto {
  static iva = 0.21;
  constructor(preco) {
    this.preco = preco;
  }
  precoFinal() {
    return this.preco * (1 + Produto.iva);
  }
}
console.log("IVA:", Produto.iva);
console.log("Final:", new Produto(100).precoFinal());

Contador de instâncias com um campo estático

class Sessao {
  static total = 0;
  constructor(usuario) {
    this.usuario = usuario;
    Sessao.total++;
  }
}
new Sessao("ana");
new Sessao("luis");
console.log("Sessões criadas:", Sessao.total);

Método privado como helper interno

class Carrinho {
  #itens = [];
  adicionar(preco) {
    this.#itens.push(preco);
  }
  #soma() {
    return this.#itens.reduce((a, b) => a + b, 0);
  }
  total() {
    return "Total: " + this.#soma();
  }
}
const c = new Carrinho();
c.adicionar(10);
c.adicionar(25);
console.log(c.total());