Pular para o conteúdo

Documentação

Classes e Orientação a Objetos

A Programação Orientada a Objetos (POO / OOP) organiza o código agrupando dados (propriedades) e comportamentos (métodos) em estruturas chamadas classes. Uma classe serve como um molde a partir do qual você pode instanciar múltiplos objetos com a mesma estrutura.

No JavaScript moderno (ES6+), a palavra-chave class oferece uma sintaxe clara e expressiva para encapsulamento, herança e polimorfismo. Por baixo dos panos, o JavaScript continua operando sobre sua clássica cadeia de protótipos (prototypal inheritance), combinando a elegância da orientação a objetos com o dinamismo do motor JS.

Declarando classes e instâncias

A base da orientação a objetos: como definir moldes, inicializar propriedades e criar objetos com new.

class e constructor

Declara uma classe e define a função construtora (constructor), executada automaticamente quando um novo objeto é criado com o operador new.

Sintaxe
class NomeDaClasse {
  constructor(param1, param2) {
    this.propriedade = param1;
  }
}
Devolve
Uma nova instância do objeto da classe.
class Usuario {
  constructor(nome, nivel) {
    this.nome = nome;
    this.nivel = nivel;
  }
}
const aluno = new Usuario('Carlos', 'iniciante');
console.log(aluno.nome);
console.log(aluno.nivel);
Mostra
Carlos
iniciante

Métodos de instância

Funções declaradas dentro do corpo da classe que operam sobre os dados da instância acessando this.

Sintaxe
class NomeDaClasse {
  nomeDoMetodo(argumentos) {
    return this.propriedade;
  }
}
Devolve
O valor retornado pelo método.
class Jogador {
  constructor(nome) {
    this.nome = nome;
    this.pontos = 0;
  }
  ganharPontos(qtd) {
    this.pontos += qtd;
    return this.pontos;
  }
}
const player = new Jogador('Marina');
player.ganharPontos(50);
console.log(player.pontos);
Mostra
50

Campos públicos no corpo da classe

Permite declarar propriedades públicas diretamente no corpo da classe com valores iniciais, sem precisar atribuí-las dentro do constructor.

Sintaxe
class NomeDaClasse {
  propriedade = valorPadrao;
}
Devolve
Propriedades públicas presentes em cada nova instância.
class Tarefa {
  concluida = false;
  criadaEm = 2026;
  constructor(titulo) {
    this.titulo = titulo;
  }
}
const t = new Tarefa('Aprender classes');
console.log(t.concluida);
console.log(t.criadaEm);
Mostra
false
2026

Encapsulamento, assessores e privacidade

Controle o acesso e a integridade dos dados internos com getters, setters e membros privados nativos (#).

Getters e Setters (get e set)

Métodos especiais que interceptam o acesso de leitura (get) e de gravação (set) a uma propriedade, permitindo validações e valores calculados.

Sintaxe
class Exemplo {
  get area() { return this.largura * this.altura; }
  set lado(v) { if (v > 0) this._lado = v; }
}
Devolve
O valor devolvido pelo getter ou atribuição controlada no setter.
class Termometro {
  constructor(celsius) {
    this.celsius = celsius;
  }
  get fahrenheit() {
    return this.celsius * 1.8 + 32;
  }
}
const t = new Termometro(25);
console.log(t.fahrenheit);
Mostra
77

Campos privados (#campo)

Propriedades declaradas com o prefixo cerquilha (#) que só podem ser acessadas ou modificadas dentro dos métodos da própria classe.

Sintaxe
class Conta {
  #saldo = 0;
  depositar(v) { this.#saldo += v; }
}
Devolve
Valor protegido acessível apenas internamente.
class Cofre {
  #segredo;
  constructor(segredo) {
    this.#segredo = segredo;
  }
  revelar() {
    return `Segredo: ${this.#segredo}`;
  }
}
const cofre = new Cofre('chave-123');
console.log(cofre.revelar());
console.log(cofre['#segredo']);
Mostra
Segredo: chave-123
undefined

Métodos privados (#metodo())

Funções internas prefixadas com # que auxiliam na implementação interna da classe e ficam completamente invisíveis para código externo.

Sintaxe
class Servico {
  #sanitizar(t) { return t.trim(); }
  processar(t) { return this.#sanitizar(t); }
}
Devolve
Valor calculado internamente para outros métodos da classe.
class ServicoEmail {
  #formatar(email) {
    return email.trim().toLowerCase();
  }
  enviar(email) {
    const destinatario = this.#formatar(email);
    return `Enviado para ${destinatario}`;
  }
}
const s = new ServicoEmail();
console.log(s.enviar('  USER@MUNDOJS.COM '));
Mostra
Enviado para user@mundojs.com

Membros estáticos (static)

Propriedades e métodos que pertencem à classe como um todo, em vez de pertencerem a instâncias individuais.

Métodos estáticos (static metodo())

Métodos utilitários ou funções de fábrica pertencentes à classe, chamados diretamente através de NomeDaClasse.metodo() sem necessidade de criar instâncias com new.

Sintaxe
class Utilitario {
  static metodo(parametro) {
    return resultado;
  }
}
Devolve
O valor produzido pelo método estático da classe.
class Conversor {
  static kmParaMilhas(km) {
    return km * 0.621371;
  }
}
console.log(Math.round(Conversor.kmParaMilhas(100)));
Mostra
62

Campos estáticos (static campo)

Propriedades armazenadas diretamente na classe, muito úteis para constantes globais, configurações padrão ou contadores de instâncias.

Sintaxe
class Configuracao {
  static VERSAO = "1.0.0";
}
Devolve
O valor armazenado na propriedade estática da classe.
class Contador {
  static total = 0;
  constructor() {
    Contador.total++;
  }
}
new Contador();
new Contador();
console.log(Contador.total);
Mostra
2

Herança e polimorfismo

Reaproveite estruturas e especialize comportamentos com extends, chamadas a super() e o operador instanceof.

Herança com extends

Cria uma classe filha (subclasse) que herda todas as propriedades e métodos de uma classe pai (superclasse).

Sintaxe
class SubClasse extends SuperClasse {
  // novos métodos ou propriedades
}
Devolve
Uma nova subclasse especializada.
class Animal {
  constructor(nome) {
    this.nome = nome;
  }
  dormir() {
    return `${this.nome} dormiu`;
  }
}
class Gato extends Animal {
  miar() {
    return 'Miau!';
  }
}
const g = new Gato('Mingau');
console.log(g.dormir());
console.log(g.miar());
Mostra
Mingau dormiu
Miau!

super em construtores e métodos

Invoca o construtor da superclasse (super(...)) ou métodos herdados da classe pai (super.metodo()).

Sintaxe
constructor(param1, param2) {
  super(param1);
  this.extra = param2;
}
Devolve
A inicialização ou o retorno do método da superclasse.
class Veiculo {
  constructor(marca) {
    this.marca = marca;
  }
}
class Carro extends Veiculo {
  constructor(marca, modelo) {
    super(marca);
    this.modelo = modelo;
  }
}
const c = new Carro('Fiat', 'Uno');
console.log(c.marca);
console.log(c.modelo);
Mostra
Fiat
Uno

Sobrescrita de métodos (Polimorfismo)

Redefine um método na subclasse com implementação especializada, substituindo ou estendendo o comportamento original herdado.

Sintaxe
class SubClasse extends SuperClasse {
  metodo() {
    return "novo comportamento";
  }
}
Devolve
O retorno especializado do método sobrescrito.
class Instrumento {
  tocar() {
    return 'Som de instrumento';
  }
}
class Violao extends Instrumento {
  tocar() {
    return 'Acordes de violão';
  }
}
const inst = new Violao();
console.log(inst.tocar());
Mostra
Acordes de violão

Operador instanceof

Testa se um objeto descende de uma classe ou função construtora, verificando toda a sua cadeia de herança prototípica.

Sintaxe
objeto instanceof NomeDaClasse
Devolve
true se o objeto pertencer à classe ou a um de seus ancestrais; caso contrário, false.
class Animal {}
class Cachorro extends Animal {}
const rex = new Cachorro();
console.log(rex instanceof Cachorro);
console.log(rex instanceof Animal);
console.log(rex instanceof Array);
Mostra
true
true
false

Protótipos e arquitetura interna

Compreenda a herança prototípica que alimenta as classes no motor do JavaScript.

Protótipos e Object.getPrototypeOf()

Revela como o modelo prototípico funciona por baixo das classes: cada classe armazena seus métodos compartilhados no objeto .prototype, vinculado a todas as instâncias.

Sintaxe
Classe.prototype.metodo ou Object.getPrototypeOf(instancia)
Devolve
O objeto protótipo compartilhado pelas instâncias.
class Pessoa {
  falar() {
    return 'Oi';
  }
}
const p1 = new Pessoa();
const p2 = new Pessoa();
console.log(p1.falar === p2.falar);
console.log(Object.getPrototypeOf(p1) === Pessoa.prototype);
Mostra
true
true

Quer testar? Copie um exemplo e rode no Rascunho.