Campos de classe, campos privados # e membros estáticos
Crie classes com campos públicos, oculte dados com campos privados # e adicione propriedades e métodos estáticos
Campos de classe, campos privados # e membros estáticos é uma aula grátis de JavaScript Academy no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de JavaScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de JavaScript Academy inclui 3 aulas no total.
Por que usar classes?
Objetivo: criar classes pequenas e claras.
- Campos públicos e métodos
- Campos #private para estado oculto
- Propriedades e métodos static para auxiliares no nível da classe
- Mantenha os exemplos pequenos e legíveis

Campos públicos e construtor
Crie uma classe com um campo público e métodos pequenos; mantenha a lógica simples para iniciantes.
// Public fields and a simple method
class Counter {
// public field with default
value = 0;
constructor(start) {
// use a default if start is not provided
this.value = Number.isFinite(start) ? start : 0;
}
inc() {
this.value = this.value + 1;
}
}
const c1 = new Counter(2);
c1.inc();
console.log("value:", c1.value); // 3

Campos privados #
Os campos #private são impostos pela linguagem e só podem ser usados dentro do corpo da classe. Exponha métodos de leitura se necessário.
// Private # fields hide internal state
class SafeCounter {
// private field (only inside the class)
#value = 0;
constructor(start) {
this.#value = Number.isFinite(start) ? start : 0;
}
inc() { this.#value = this.#value + 1; }
getValue() { return this.#value; } // expose via method
}
const sc = new SafeCounter(5);
sc.inc();
console.log("safe value:", sc.getValue());
// External access fails (uncommenting the next line would throw):
// console.log(sc.#value);

Acessores para leituras seguras
Um acessor pode retornar um valor derivado ou validado, mantendo o campo privado.
// Getters provide read-only views; simple guard logic
class User {
#name = "Anonymous";
constructor(name) {
if (typeof name === "string" && name.trim().length > 0) {
this.#name = name.trim();
}
}
get name() {
return this.#name;
}
}
const u = new User(" Ayla ");
console.log("name:", u.name);

Membros estáticos
Os membros static são chamados na classe (por exemplo, MathHelp.circleArea()), não nas instâncias.
// Static = belongs to the class, not to instances
class MathHelp {
static PI = 3.14159;
static circleArea(r) {
if (!(typeof r === "number" && r >= 0)) return 0;
return MathHelp.PI * r * r;
}
}
console.log("PI:", MathHelp.PI);
console.log("area r=2:", MathHelp.circleArea(2));
// Instances do not have the static members:
const mh = new MathHelp();
console.log("instance has PI?", "PI" in mh); // false

Hábitos adequados para iniciantes
Dicas:
- Prefira classes pequenas com poucos métodos claros.
- Use #private para privacidade real; sublinhados são apenas uma convenção de nomenclatura.
- Coloque constantes e utilitários em membros static.
- Exponha poucos métodos de leitura (acessores) se precisar de acesso externo.

Questionário sobre fundamentos de campos privados
Verificação rápida: campos #private.

Resumo
Resumo: use campos públicos para estados simples, #private para ocultar detalhes internos e static para auxiliares no nível da classe. Mantenha cada classe pequena e fácil de ler.

Perguntas Frequentes
A aula “Campos de classe, campos privados # e membros estáticos” é grátis?
Sim — o texto completo de “Campos de classe, campos privados # e membros estáticos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de JavaScript Academy, atualize para CoddyKit PRO. O curso de JavaScript Academy inclui 3 aulas no total.
O que vou aprender em “Campos de classe, campos privados # e membros estáticos”?
Crie classes com campos públicos, oculte dados com campos privados # e adicione propriedades e métodos estáticos Você pratica JavaScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar JavaScript Academy?
Nenhuma experiência prévia é necessária. JavaScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.
Quanto tempo leva a aula “Campos de classe, campos privados # e membros estáticos”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de JavaScript Academy?
Sim. Cada aula de JavaScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Campos de classe, campos privados # e membros estáticos
- Herança, super e quando preferir composição
- Mixins (introdução) — reutilização simples sem hierarquias profundas