Metodi statici

8.1 Dichiarazione dei metodi statici

I metodi statici in JavaScript sono metodi che sono definiti sulla classe stessa, non sulle sue istanze. Sono chiamati direttamente sulla classe, non sugli oggetti creati da quella classe. I metodi statici sono spesso usati per creare funzioni di supporto che si riferiscono alla classe, ma non a oggetti specifici.

I metodi statici sono dichiarati utilizzando la parola chiave static prima della definizione del metodo nel corpo della classe.

Esempio:

• I metodi add e multiply sono dichiarati come statici utilizzando la parola chiave static
• Questi metodi sono chiamati direttamente sulla classe MathHelper, non sulle sue istanze

    
      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 dei metodi statici

I metodi statici sono utili nei seguenti scenari:

1. Funzioni di supporto: i metodi statici possono essere utilizzati per creare funzioni di utilità che eseguono operazioni relative alla classe.
2. Metodi di fabbrica: i metodi statici possono essere usati per creare istanze di una classe con una logica specifica.
3. Elaborazione dati: i metodi statici possono essere usati per elaborare dati relativi alla classe, ma che non richiedono la creazione di istanze della classe.

Esempio di funzioni di supporto:

• La classe StringUtil contiene metodi statici capitalize e reverse che operano su stringhe
• Questi metodi sono chiamati direttamente sulla 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"
    
  

Esempio di metodo di fabbrica:

Il metodo statico fromObject crea un'istanza della classe Car da un oggetto di dati.

    
      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 Metodi statici ed ereditarietà

In JavaScript i metodi statici sono anche ereditati dalle classi derivate. Le classi derivate possono usare i metodi statici della classe base o sovrascriverli.

Esempio di ereditarietà di metodi statici:

• Il metodo statico identify è definito nella classe Animal e sovrascritto nella classe Dog
• Il metodo identify viene chiamato su entrambe le classi

    
      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 Accesso ai metodi statici all'interno di altri metodi

I metodi statici possono essere chiamati all'interno di altri metodi della classe usando il nome della classe.

Esempio:

Il metodo statico calculateArea viene chiamato all'interno di un altro metodo statico describeCircle usando la parola chiave this, che in questo contesto si riferisce alla classe stessa 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 Metodi statici e istanze della classe

I metodi statici non possono essere chiamati su istanze della classe. Tentare di chiamare un metodo statico su un'istanza causerà un errore.

Esempio:

Il metodo statico add è chiamato sulla classe Calculator, non sulla sua istanza 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)); // Errore: calc.add non è una funzione