Campos e Métodos Estáticos - JavaScript

Além de campos e métodos comuns, uma classe pode definir campos e métodos estáticos. Diferentemente dos campos/propriedades e métodos comuns, eles se aplicam a toda a classe, e não a um objeto individual.

Campos Estáticos

Os campos estáticos armazenam estados da classe como um todo, não de um objeto individual. O nome de um campo estático é precedido pela palavra-chave static. Por exemplo:

class Person {
    static retirementAge = 65;
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    print() { 
        console.log(`Nome: ${this.name}  Idade: ${this.age}`); 
    }
}

console.log(Person.retirementAge); // 65
Person.retirementAge = 62;
console.log(Person.retirementAge); // 62

Aqui, na classe Person, é definido o campo estático retirementAge que armazena a idade de aposentadoria convencional. Esse campo pertence à classe Person como um todo e descreve o estado de toda a classe. Como geralmente existe uma idade de aposentadoria comum, utilizamos o nome da classe para acessar ou definir seu valor:

Person.retirementAge = 62;
console.log(Person.retirementAge); // 62

No entanto, não podemos acessar esses campos através de this em métodos não estáticos e no construtor da classe, como no exemplo a seguir:

print() { 
    console.log(`Nome: ${this.name}  Idade: ${this.age}`); 
    console.log(`Idade de aposentadoria: ${this.retirementAge}`);   // não é possível acessar o campo estático através de this
}

Se quisermos acessar campos e métodos estáticos dentro de métodos não estáticos e no construtor, devemos usar o nome da classe:

print() { 
    console.log(`Nome: ${this.name}  Idade: ${this.age}`); 
    console.log(`Idade de aposentadoria: ${Person.retirementAge}`);
}

Métodos Estáticos

Métodos estáticos, assim como campos estáticos, são definidos para toda a classe em geral, e não para um objeto individual. Para definir um método estático, o nome do método é precedido pelo operador static. Por exemplo:

class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    print() { 
        console.log(`Nome: ${this.name}  Idade: ${this.age}`);
    }
    static printClassInfo() { 
        console.log("A classe Person representa uma pessoa");
    }
}
Person.printClassInfo();    // A classe Person representa uma pessoa

Um método estático printClassInfo() simplesmente imprime uma mensagem. Diferentemente de métodos não estáticos que definem o comportamento de um objeto, métodos estáticos definem o comportamento para toda a classe. Portanto, seu chamado usa o nome da classe, não o de um objeto:

Person.printClassInfo();

Como os métodos estáticos se relacionam com a classe como um todo, e não com um objeto específico, não podemos acessar campos ou métodos não estáticos dentro deles, como no seguinte exemplo:

class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    print() { 
        console.log(`Nome: ${this.name}  Idade: ${this.age}`);
    }
    static printAge() { 
        console.log(this.age); // 'this.age' não existe em um contexto estático
    }
}
Person.printAge();  // undefined

Se for necessário acessar propriedades de um objeto em um método estático, podemos definir um parâmetro através do qual o objeto será passado para o método:

class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    static print(person) { 
        console.log(`Nome: ${person.name}  Idade: ${person.age}`);
    }
}
const tom = new Person("Tom", 37);
const bob = new Person("Bob", 41);
Person.print(tom);  // Tom 37
Person.print(bob);  // Bob 41

Além disso, podemos usar a palavra this em métodos estáticos para acessar campos e outros métodos estáticos:

class Person {
    static retirementAge = 65;
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    print() { 
        console.log(`Nome: ${this.name}  Idade: ${this.age}`);
    }
    static calculateRestAges(person) {
        if (this.retirementAge > person.age) {
            const restAges = this.retirementAge - person.age;
            console.log(`Faltam ${restAges} anos para a aposentadoria`);
        } else {
            console.log("Você já está aposentado");
        }
    }
}
const tom = new Person("Tom", 37);
Person.calculateRestAges(tom);      // Faltam 28 anos para a aposentadoria
const bob = new Person("Bob", 71);
Person.calculateRestAges(bob);      // Você já está aposentado

Neste exemplo, o método estático calculateRestAges calcula quantos anos faltam até a aposentadoria de uma pessoa específica, acessando o campo estático retirementAge.

Campos e Métodos Estáticos Privados

Assim como campos e métodos comuns, campos e métodos estáticos também podem ser privados. Esses campos e métodos são acessíveis apenas de outros métodos estáticos da classe:

class Person {
    static #retirementAge = 65;
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    print() { 
        console.log(`Nome: ${this.name}  Idade: ${this.age}`);
    }
    static calculateRestAges(person) {
        if (this.#retirementAge > person.age) {
            const restAges = this.#retirementAge - person.age;
            console.log(`Restam ${restAges} anos até a aposentadoria`);
        }
        else console.log("Você já está aposentado");
    }
}
const tom = new Person("Tom", 37);
Person.calculateRestAges(tom);      // Restam 28 anos até a aposentadoria
const bob = new Person("Bob", 71);
Person.calculateRestAges(bob);      // Você já está aposentado

Neste exemplo, o campo estático retirementAge é privado. Agora, ele só pode ser acessado dentro dos métodos estáticos da classe.