Abstract Factory

Abstract Factory is a creational design pattern that lets you produce families of related objects without specifying their concrete classes.

// Abstract Factory
class AnimalFactory {
  createDog() {
    throw new Error("Method createDog() must be implemented.");
  }

  createCat() {
    throw new Error("Method createCat() must be implemented.");
  }
}

// Concrete Factory 1
class WildAnimalFactory extends AnimalFactory {
  createDog() {
    return new WildDog();
  }

  createCat() {
    return new WildCat();
  }
}

// Concrete Factory 2
class DomesticAnimalFactory extends AnimalFactory {
  createDog() {
    return new DomesticDog();
  }

  createCat() {
    return new DomesticCat();
  }
}

// Abstract Product
class Dog {
  sound() {
    throw new Error("Method sound() must be implemented.");
  }
}

// Concrete Product 1
class WildDog extends Dog {
  sound() {
    return "Wild dog barks loudly.";
  }
}

// Concrete Product 2
class DomesticDog extends Dog {
  sound() {
    return "Domestic dog barks softly.";
  }
}

// Abstract Product
class Cat {
  sound() {
    throw new Error("Method sound() must be implemented.");
  }
}

// Concrete Product 1
class WildCat extends Cat {
  sound() {
    return "Wild cat meows loudly.";
  }
}

// Concrete Product 2
class DomesticCat extends Cat {
  sound() {
    return "Domestic cat purrs softly.";
  }
}

// Client
function animalSound(factory) {
  const dog = factory.createDog();
  const cat = factory.createCat();

  console.log(dog.sound());
  console.log(cat.sound());
}

// Example usage
const wildAnimalFactory = new WildAnimalFactory();
const domesticAnimalFactory = new DomesticAnimalFactory();

console.log("Wild Animals:");
animalSound(wildAnimalFactory);

console.log("\nDomestic Animals:");
animalSound(domesticAnimalFactory);

In this example:

• AnimalFactory is the abstract factory with methods to create Dog and Cat objects.

• WildAnimalFactory and DomesticAnimalFactory are concrete factories implementing AnimalFactory.

• Dog and Cat are abstract product classes with a method sound().

• WildDog, DomesticDog, WildCat, and DomesticCat are concrete product classes implementing Dog and Cat.

• The animalSound() function acts as the client, which creates Dog and Cat objects using the factory and calls their sound() methods.

• Finally, we create instances of concrete factories (wildAnimalFactory and domesticAnimalFactory) and pass them to the animalSound() function to produce sounds of wild and domestic animals.