Métodos Estáticos

8.1 Declaração de Métodos Estáticos

Métodos estáticos em JavaScript são definidos na própria classe, e não nas instâncias dela. Eles são chamados diretamente na classe e não nos objetos criados por ela. Muitas vezes, são usados para criar funções auxiliares que têm relação com a classe, mas não com objetos específicos.

Métodos estáticos são declarados usando a palavra-chave static antes da definição do método no corpo da classe.

Exemplo:

• Os métodos add e multiply são declarados como estáticos usando a palavra-chave static
• Esses métodos são chamados diretamente na classe MathHelper e não em suas instâncias

    
      class MathHelper {
        static add(a, b) {
          return a + b;
        }

        static multiply(a, b) {
          return a * b;
        }
      }

      console.log(MathHelper.add(5, 3)); // 8
      console.log(MathHelper.multiply(5, 3)); // 15
    
  

8.2 Uso de Métodos Estáticos

Métodos estáticos são úteis nos seguintes cenários:

1. Funções auxiliares: métodos estáticos podem ser usados para criar funções utilitárias que realizam operações relacionadas à classe.
2. Métodos de fábrica: métodos estáticos podem ser usados para criar instâncias de classe com lógica específica.
3. Processamento de dados: métodos estáticos podem ser usados para processar dados relacionados à classe, sem a necessidade de criar instâncias.

Exemplo de funções auxiliares:

• A classe StringUtil contém métodos estáticos capitalize e reverse, que trabalham com strings
• Esses métodos são chamados diretamente na classe StringUtil

    
      class StringUtil {
        static capitalize(str) {
          return str.charAt(0).toUpperCase() + str.slice(1);
        }

        static reverse(str) {
          return str.split('').reverse().join('');
        }
      }

      console.log(StringUtil.capitalize('hello')); // "Hello"
      console.log(StringUtil.reverse('hello')); // "olleh"
    
  

Exemplo de método de fábrica:

O método estático fromObject cria uma instância da classe Car a partir de um objeto de dados.

    
      class Car {
        constructor(brand, model) {
          this.brand = brand;
          this.model = model;
        }

        static fromObject(obj) {
          return new Car(obj.brand, obj.model);
        }
      }

      const carData = { brand: 'Toyota', model: 'Camry' };
      const car = Car.fromObject(carData);

      console.log(car.brand); // "Toyota"
      console.log(car.model); // "Camry"
    
  

8.3 Métodos Estáticos e Herança

Em JavaScript, métodos estáticos também são herdados por classes derivadas. Classes derivadas podem usar métodos estáticos da classe base ou sobrescrevê-los.

Exemplo de herança de métodos estáticos:

• O método estático identify é definido na classe Animal e sobrescrito na classe Dog
• O método identify é chamado em ambas as classes

    
      class Animal {
        static identify() {
          return 'This is an animal';
        }
      }

      class Dog extends Animal {
        static identify() {
          return 'This is a dog';
        }
      }

      console.log(Animal.identify()); // "This is an animal"
      console.log(Dog.identify()); // "This is a dog"
    
  

8.4 Acesso a Métodos Estáticos Dentro de Outros Métodos

Métodos estáticos podem ser chamados dentro de outros métodos da classe usando o nome da classe.

Exemplo:

O método estático calculateArea é chamado dentro de outro método estático describeCircle usando a palavra-chave this, que nesse contexto se refere à própria classe Geometry.

    
      class Geometry {
        static calculateArea(radius) {
          return Math.PI * radius * radius;
        }

        static describeCircle(radius) {
          const area = this.calculateArea(radius);
          return `A circle with radius ${radius} has an area of ${area.toFixed(2)}.`;
        }
      }

      console.log(Geometry.describeCircle(5)); // "A circle with radius 5 has an area of 78.54."
    
  

8.5 Métodos Estáticos e Instâncias de Classe

Métodos estáticos não podem ser chamados em instâncias de classe. Tentar chamar um método estático em uma instância resultará em erro.

Exemplo:

O método estático add é chamado na classe Calculator, e não em sua instância calc.

    
      class Calculator {
        static add(a, b) {
          return a + b;
        }
      }

      const calc = new Calculator();
      console.log(Calculator.add(3, 4)); // 7

      console.log(calc.add(3, 4)); // Erro: calc.add não é uma função