Méthodes statiques

8.1 Déclaration de méthodes statiques

Les méthodes statiques en JavaScript sont des méthodes définies sur la classe elle-même, et non sur ses instances. Elles sont appelées directement sur la classe, pas sur les objets créés par cette classe. Les méthodes statiques sont souvent utilisées pour créer des fonctions d'aide qui sont liées à la classe, mais pas à des objets spécifiques.

Les méthodes statiques sont déclarées en utilisant le mot-clé static avant la définition de la méthode dans le corps de la classe.

Exemple :

• Les méthodes add et multiply sont déclarées comme statiques en utilisant le mot-clé static
• Ces méthodes sont appelées directement sur la classe MathHelper, et non sur ses instances

    
      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 Utilisation des méthodes statiques

Les méthodes statiques sont utiles dans les scénarios suivants :

1. Fonctions d'aide : les méthodes statiques peuvent être utilisées pour créer des fonctions utilitaires qui exécutent des opérations liées à la classe.
2. Méthodes de fabrique : les méthodes statiques peuvent être utilisées pour créer des instances de classe avec une logique spécifique.
3. Traitement des données : les méthodes statiques peuvent être utilisées pour traiter les données liées à la classe, mais ne nécessitant pas la création d'instances de classe.

Exemple de fonctions d'aide :

• La classe StringUtil contient les méthodes statiques capitalize et reverse, qui travaillent avec des chaînes
• Ces méthodes sont appelées directement sur la 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"
    
  

Exemple de méthode de fabrique :

La méthode statique fromObject crée une instance de la classe Car à partir d'un objet de données.

    
      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éthodes statiques et héritage

En JavaScript, les méthodes statiques sont aussi héritées par les classes dérivées. Les classes dérivées peuvent utiliser les méthodes statiques de la classe de base ou les redéfinir.

Exemple d'héritage de méthodes statiques :

• La méthode statique identify est définie dans la classe Animal et redéfinie dans la classe Dog
• La méthode identify est appelée sur les deux 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 Accès aux méthodes statiques à l'intérieur d'autres méthodes

Les méthodes statiques peuvent être appelées à l'intérieur d'autres méthodes de classe en utilisant le nom de la classe.

Exemple :

La méthode statique calculateArea est appelée à l'intérieur d'une autre méthode statique describeCircle en utilisant le mot-clé this, qui dans ce contexte fait référence à la classe elle-même 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éthodes statiques et instances de classe

Les méthodes statiques ne peuvent pas être appelées sur les instances de classe. Une tentative d'appel d'une méthode statique sur une instance entraînera une erreur.

Exemple :

La méthode statique add est appelée sur la classe Calculator, et non sur son instance 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)); // Erreur : calc.add n'est pas une fonction